예제 #1
0
 def get_create_params(user_facing=False):
     create_params = {}
     create_params_locked = {}
     if user_facing:
         create_params['user_facing'] = Tunable(
             description=
             "\n                                                   If enabled, we will start the situation as user facing.\n                                                   Note: We can only have one user facing situation at a time,\n                                                   so make sure you aren't tuning multiple user facing\n                                                   situations to occur at once.\n                                                   ",
             tunable_type=bool,
             default=False)
     else:
         create_params_locked['user_facing'] = False
     return {
         'weighted_situations':
         TunableList(
             description=
             '\n            A weighted list of situations to be used while fulfilling the\n            desired Sim count.\n            ',
             tunable=TunableTuple(
                 situation=Situation.TunableReference(pack_safe=True),
                 params=TunableTuple(
                     description=
                     '\n                    Situation creation parameters.\n                    ',
                     locked_args=create_params_locked,
                     **create_params),
                 weight=Tunable(tunable_type=int, default=1),
                 weight_multipliers=TunableMultiplier.TunableFactory(
                     description=
                     "\n                    Tunable tested multiplier to apply to weight.\n                    \n                    *IMPORTANT* The only participants that work are ones\n                    available globally, such as Lot and ActiveHousehold. Only\n                    use these participant types or use tests that don't rely\n                    on any, such as testing all objects via Object Criteria\n                    test or testing active zone with the Zone test.\n                    ",
                     locked_args={'base_value': 1}),
                 tests=TunableTestSet(
                     description=
                     "\n                    A set of tests that must pass for the situation and weight\n                    pair to be available for selection.\n                    \n                    *IMPORTANT* The only participants that work are ones\n                    available globally, such as Lot and ActiveHousehold. Only\n                    use these participant types or use tests that don't rely\n                    on any, such as testing all objects via Object Criteria\n                    test or testing active zone with the Zone test.\n                    "
                 )))
     }
예제 #2
0
class GoDancingZoneDirector(SchedulingZoneDirector):
    INSTANCE_TUNABLES = {
        'go_dancing_background_situation':
        Situation.TunableReference(
            description=
            '\n            The situation that is always runnning at the Cafe to make sure any\n            Sims that show up beyond the schedule tuning will get coffee. These\n            could be Sims the player invites, the player themselves, and clique\n            Sims. \n            \n            Note, the situation that this points to will be a very\n            generic situation that spins up a CafeGenericSimSituation for that\n            individual Sim. This is so that Sims can get coffee on their own\n            autonomy and be independent of one another.\n            ',
            class_restrictions=('GoDancingBackgroundSituation', ))
    }

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._background_situation_id = None

    def create_situations_during_zone_spin_up(self):
        super().create_situations_during_zone_spin_up()
        situation_manager = services.get_zone_situation_manager()
        for situation in situation_manager:
            if type(situation) is self.go_dancing_background_situation:
                self._background_situation_id = situation.id
                break
        else:
            self._background_situation_id = situation_manager.create_situation(
                self.go_dancing_background_situation,
                user_facing=False,
                creation_source=self.instance_name)
예제 #3
0
class EmergencyFrequency(HasTunableSingletonFactory, AutoFactoryInit):
    FACTORY_TUNABLES = {
        'max_emergency_situations_per_shift':
        TunableRange(
            description=
            '\n            The maximum number of times during a shift that an emergency\n            situation can be created/started.\n            ',
            tunable_type=int,
            default=1,
            minimum=0),
        'inital_lockout_in_sim_minutes':
        TunableSimMinute(
            description=
            '\n            The time, in Sim minutes, that pass at the beginning of a shift\n            before the first check for creating/starting an emergency happens.\n            ',
            default=60),
        'cool_down_in_sim_minutes':
        TunableSimMinute(
            description=
            '\n            How often a check for whether or not to create/start an emergency\n            happens.\n            ',
            default=60),
        'percent_chance_of_emergency':
        TunablePercent(
            description=
            '\n            The percentage chance that on any given check an emergency is to\n            to be created/started.\n            ',
            default=30),
        'weighted_situations':
        TunableList(
            description=
            '\n            A weighted list of situations to be used as emergencies. When a\n            check passes to create/start an emergency, this is the list\n            of emergency situations that will be chosen from.\n            ',
            tunable=TunableTuple(situation=Situation.TunableReference(),
                                 weight=Tunable(tunable_type=int, default=1)))
    }
예제 #4
0
class _ComplainState(CommonInteractionStartedSituationState):
    FACTORY_TUNABLES = {'neighbor_situation': Situation.TunableReference(description='\n            The Situation for the loud neighbor to come out and see what the\n            player wants when they bang on the door.\n            ', class_restrictions=('NeighborResponseSituation',)), 'turn_off_loud_door_state': Tunable(description='\n            If enabled, we will set the door to the loud door off state when\n            entering this situation state.\n            ', tunable_type=bool, default=False)}

    def __init__(self, *args, neighbor_situation=None, turn_off_loud_door_state=None, **kwargs):
        super().__init__(*args, **kwargs)
        self._neighbor_situation = neighbor_situation
        self._turn_off_loud_door_state = turn_off_loud_door_state
        self.neighbor_response_situation_id = None

    def on_activate(self, reader=None):
        super().on_activate(reader)

    def _create_neighbor_response_situation(self):
        situation_manager = services.get_zone_situation_manager()
        guest_list = SituationGuestList(invite_only=True)
        guest_list.add_guest_info(SituationGuestInfo(self.owner._neighbor_sim_id, self._neighbor_situation.loud_neighbor_job_and_role_state.job, RequestSpawningOption.MUST_SPAWN, BouncerRequestPriority.EVENT_VIP))
        self.neighbor_response_situation_id = situation_manager.create_situation(self._neighbor_situation, guest_list=guest_list, user_facing=False)

    def _set_loud_door_state_off(self):
        if self._turn_off_loud_door_state and self.owner._neighbor_door_id is not None:
            apartment_door = services.object_manager().get(self.owner._neighbor_door_id)
            if apartment_door is not None:
                apartment_door.set_state(self.owner.loud_door_state_off.state, self.owner.loud_door_state_off)

    def _on_interaction_of_interest_started(self):
        self._create_neighbor_response_situation()
        services.get_zone_situation_manager().remove_sim_from_auto_fill_blacklist(self.owner._neighbor_sim_id)
        self._set_loud_door_state_off()
class GoDancingBackgroundSituation(SituationComplexCommon):
    INSTANCE_TUNABLES = {
        'generic_sim_job':
        TunableSituationJobAndRoleState(
            description=
            "\n            A job and role state that essentially does nothing but filter out\n            Sims that shouldn't be placed in the party-goer situation.\n            "
        ),
        'party_goer_situation':
        Situation.TunableReference(
            description=
            '\n            The individual, party-goer situation we want to use for\n            Sims that show up at the party so they want to dance and more.\n            ',
            class_restrictions=('GoDancingBackgroundPartyGoerSituation', ))
    }
    REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES

    @classmethod
    def _states(cls):
        return (SituationStateData(1, _GoDancingGenericState), )

    @classmethod
    def _get_tuned_job_and_default_role_state_tuples(cls):
        return [(cls.generic_sim_job.job, cls.generic_sim_job.role_state)]

    @classmethod
    def default_job(cls):
        return cls.generic_sim_job.job

    def start_situation(self):
        super().start_situation()
        self._change_state(_GoDancingGenericState())

    def _issue_requests(self):
        request = SelectableSimRequestFactory(
            self,
            callback_data=_RequestUserData(
                role_state_type=self.generic_sim_job.role_state),
            job_type=self.generic_sim_job.job,
            exclusivity=self.exclusivity)
        self.manager.bouncer.submit_request(request)

    def _on_set_sim_job(self, sim, job_type):
        super()._on_set_sim_job(sim, job_type)
        situation_manager = services.get_zone_situation_manager()
        guest_list = SituationGuestList(invite_only=True)
        guest_info = SituationGuestInfo.construct_from_purpose(
            sim.sim_info.id, self.party_goer_situation.default_job(),
            SituationInvitationPurpose.INVITED)
        guest_list.add_guest_info(guest_info)
        situation_manager.create_situation(self.party_goer_situation,
                                           guest_list=guest_list,
                                           user_facing=False)
예제 #6
0
class CafeZoneDirector(SchedulingZoneDirector):
    INSTANCE_TUNABLES = {'cafe_generic_arrival_situation': Situation.TunableReference(description='\n            The situation that is always runnning at the Cafe to make sure any\n            Sims that show up beyond the schedule tuning will get coffee. These\n            could be Sims the player invites, the player themselves, and clique\n            Sims. \n            \n            Note, the situation that this points to will be a very\n            generic situation that spins up a CafeGenericSimSituation for that\n            individual Sim. This is so that Sims can get coffee on their own\n            autonomy and be independent of one another.\n            ', class_restrictions=('CafeGenericBackgroundSituation',))}

    def add_sim_info_into_arrival_situation(self, sim_info, during_spin_up=False):
        situation_manager = services.get_zone_situation_manager()
        situation = situation_manager.get_situation_by_type(self.cafe_generic_arrival_situation)
        if situation is None:
            situation_manager.create_situation(self.cafe_generic_arrival_situation, guest_list=None, user_facing=False, creation_source=self.instance_name)

    def create_situations_during_zone_spin_up(self):
        super().create_situations_during_zone_spin_up()
        situation_manager = services.get_zone_situation_manager()
        situation_manager.create_situation(self.cafe_generic_arrival_situation, guest_list=None, user_facing=False, creation_source=self.instance_name)

    def handle_sim_summon_request(self, sim_info, purpose):
        self.add_sim_info_into_arrival_situation(sim_info)
예제 #7
0
class SubSituationState(CommonSituationState):
    FACTORY_TUNABLES = {
        'sub_situation':
        Situation.TunableReference(
            description=
            '\n            Sub-situation to run within this situation state. When the sub-situation\n            ends, the owning situation state will end.\n            ',
            tuning_group=SituationComplexCommon.SITUATION_STATE_GROUP,
            class_restrictions='SituationSimple')
    }

    def __init__(self, sub_situation, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.sub_situation = sub_situation
        self._sub_situation_id = None

    def start_situation(self):
        if self._sub_situation_id is None:
            sub_situation_id = self.owner.manager.create_situation(
                self.sub_situation)
            self._sub_situation_id = sub_situation_id
        if self._sub_situation_id is not None:
            self.owner.manager.register_for_callback(
                self._sub_situation_id,
                SituationCallbackOption.END_OF_SITUATION,
                self._on_sub_situation_end_callback)
            self.owner.manager.disable_save_to_situation_manager(
                self._sub_situation_id)

    def on_activate(self, *args, **kwargs):
        super().on_activate(*args, **kwargs)
        self.start_situation()

    def _on_sub_situation_end_callback(self, sub_situation_id,
                                       situation_callback_option, data):
        if sub_situation_id == self._sub_situation_id:
            self._sub_situation_id = None
            self._on_sub_situation_end(sub_situation_id)

    def on_deactivate(self, *args, **kwargs):
        super().on_deactivate(*args, **kwargs)
        if self._sub_situation_id is not None:
            situation_manager = services.get_zone_situation_manager()
            situation_manager.destroy_situation_by_id(self._sub_situation_id)

    def _on_sub_situation_end(self, sub_situation_id):
        raise NotImplementedError
class VisitorSituationOnArrivalZoneDirectorMixin:
    INSTANCE_TUNABLES = {'user_sim_arrival_situation': Situation.TunableReference(description='\n            The situation to place all of the Sims from the users household\n            in when they arrive.\n            '), 'place_all_user_sims_in_same_arrival_situation': Tunable(description='\n            If this is enabled then all user sims will be placed in the same\n            situation instead of each in their own situation.\n            ', tunable_type=bool, default=False), 'place_travel_companion_in_same_arrival_situation': Tunable(description='\n            If this is enabled, the travel companion will put into the same\n            situation with user sims. If this checked,\n            place_all_user_sims_in_same_arrival_situation has to be True as\n            well or there will be unit test error.\n            ', tunable_type=bool, default=False), 'travel_companion_arrival_situation': OptionalTunable(description="\n            If enabled then Sims that aren't controllable that travel with the\n            users Sims will be placed in the tuned situation on arrival. If\n            place_travel_companion_in_same_arrival_situation is checked, this\n            needs to be disable or there will be unit test error.\n            ", tunable=Situation.TunableReference(description="\n                If the user invites NPC's to travel with them to this lot then\n                this is the situation that they will be added to.\n                "))}

    @classmethod
    def _verify_tuning_callback(cls):
        if cls.place_travel_companion_in_same_arrival_situation and not cls.place_all_user_sims_in_same_arrival_situation:
            logger.error("{} set place_travel_companion_in_same_arrival_situation to True but doesn't support place_all_user_sims_in_same_arrival_situation, this is invalid.", cls.__name__)
        if cls.place_travel_companion_in_same_arrival_situation and cls.travel_companion_arrival_situation is not None:
            logger.error('{} set place_travel_companion_in_same_arrival_situation to True but specify travel_companion_arrival_situation, this is invalid', cls.__name__)

    def _sim_info_already_in_arrival_situation(self, sim_info, situation_manager):
        seeds = situation_manager.get_zone_persisted_seeds_during_zone_spin_up()
        for seed in seeds:
            if sim_info in seed.invited_sim_infos_gen():
                if seed.situation_type is self.user_sim_arrival_situation:
                    if services.current_zone().time_has_passed_in_world_since_zone_save():
                        if seed.allow_time_jump:
                            return True
                    return True
        return False

    def create_arrival_situation_for_sim(self, sim_info, situation_type=DEFAULT, during_spin_up=False):
        if situation_type is DEFAULT:
            situation_type = self.user_sim_arrival_situation
        situation_manager = services.get_zone_situation_manager()
        if during_spin_up and self._sim_info_already_in_arrival_situation(sim_info, situation_manager):
            return
        guest_list = SituationGuestList(invite_only=True)
        guest_info = SituationGuestInfo.construct_from_purpose(sim_info.id, situation_type.default_job(), SituationInvitationPurpose.INVITED)
        guest_list.add_guest_info(guest_info)
        self.create_arrival_situation(situation_type, guest_list, situation_manager)

    def create_arrival_situation(self, situation_type, guest_list, situation_manager):
        try:
            creation_source = self.instance_name
        except:
            creation_source = str(self)
        situation_manager.create_situation(situation_type, guest_list=guest_list, user_facing=False, creation_source=creation_source)

    def get_all_sim_arrival_guest_list(self, situation_manager, during_spin_up=False):
        sim_infos = [sim_info for sim_info in self.get_user_controlled_sim_infos()]
        if self.place_travel_companion_in_same_arrival_situation:
            sim_infos.extend(self._traveled_sim_infos)
        guest_list = SituationGuestList(invite_only=True)
        for sim_info in sim_infos:
            if during_spin_up and self._sim_info_already_in_arrival_situation(sim_info, situation_manager):
                continue
            guest_info = SituationGuestInfo.construct_from_purpose(sim_info.id, self.user_sim_arrival_situation.default_job(), SituationInvitationPurpose.INVITED)
            guest_list.add_guest_info(guest_info)
        return guest_list

    def create_situations_during_zone_spin_up(self):
        super().create_situations_during_zone_spin_up()
        situation_manager = services.get_zone_situation_manager()
        if self.place_all_user_sims_in_same_arrival_situation:
            guest_list = self.get_all_sim_arrival_guest_list(situation_manager, during_spin_up=True)
            self.create_arrival_situation(self.user_sim_arrival_situation, guest_list, situation_manager)
        else:
            for sim_info in self.get_user_controlled_sim_infos():
                self.create_arrival_situation_for_sim(sim_info, during_spin_up=True)
        if self.travel_companion_arrival_situation:
            for sim_info in self._traveled_sim_infos:
                if not sim_info.is_selectable:
                    self.create_arrival_situation_for_sim(sim_info, situation_type=self.travel_companion_arrival_situation, during_spin_up=True)

    def handle_sim_summon_request(self, sim_info, purpose):
        self.create_arrival_situation_for_sim(sim_info)
예제 #9
0
class YardSaleSituation(SituationComplexCommon):
    INSTANCE_TUNABLES = {
        'user_job':
        TunableTuple(
            description=
            '\n            The job and role which the Sim is placed into.\n            ',
            situation_job=SituationJob.TunableReference(
                description=
                '\n                A reference to a SituationJob that can be performed at this Situation.\n                '
            ),
            role_state=RoleState.TunableReference(
                description=
                '\n                A role state the sim assigned to the job will perform.\n                '
            )),
        'manage_customers_state':
        ManageCustomersState.TunableFactory(
            tuning_group=SituationComplexCommon.SITUATION_STATE_GROUP),
        'customer_situation':
        Situation.TunableReference(
            description=
            '\n            Customer Situation to spawn that will pull customers to purchase\n            items from the craft sales table.\n            ',
            class_restrictions=('YardSaleCustomerSituation', )),
        'number_of_expected_customers':
        TunableInterval(
            description=
            '\n            The number of customers we expect to have at any given time the\n            yard sale is running. The yard sale will attempt to manage this\n            many customer situations at any given time.\n            ',
            tunable_type=int,
            default_lower=0,
            default_upper=10,
            minimum=0,
            maximum=10)
    }

    def __init__(self, *arg, **kwargs):
        super().__init__(*arg, **kwargs)
        self.scoring_enabled = False
        reader = self._seed.custom_init_params_reader
        if reader is None:
            self.customer_situations = []
        else:
            self.customer_situations = list(
                reader.read_uint32s(CUSTOMER_SITUATIONS_TOKEN, list()))

    @classmethod
    def default_job(cls):
        pass

    @classmethod
    def _get_tuned_job_and_default_role_state_tuples(cls):
        return [(cls.user_job.situation_job, cls.user_job.role_state)]

    @classmethod
    def _states(cls):
        return (SituationStateData(1,
                                   ManageCustomersState,
                                   factory=cls.manage_customers_state), )

    def start_situation(self):
        super().start_situation()
        self._change_state(self.manage_customers_state())

    def _self_destruct(self):
        situation_manager = services.get_zone_situation_manager()
        for situation_id in self.customer_situations:
            situation = situation_manager.get(situation_id)
            if situation is not None:
                situation._self_destruct()
        self.customer_situations.clear()
        super()._self_destruct()

    def get_customer_situations(self):
        customers = []
        situation_manager = services.get_zone_situation_manager()
        for situation_id in self.customer_situations:
            situation = situation_manager.get(situation_id)
            if situation is not None:
                customers.append(situation)
        self.customer_situations = [situation.id for situation in customers]
        return self.customer_situations

    def create_customer_situation(self):
        situation_manager = services.get_zone_situation_manager()
        situation_id = situation_manager.create_situation(
            self.customer_situation, guest_list=None, user_facing=False)
        self.customer_situations.append(situation_id)
예제 #10
0
class InfectedSituation(SubSituationOwnerMixin, SituationComplexCommon):
    INSTANCE_TUNABLES = {'infected_state': _InfectedState.TunableFactory(display_name='Infected State', tuning_group=SituationComplexCommon.SITUATION_STATE_GROUP), 'possessed_start_time': TunableTimeOfDay(description='\n            Time of day Sims become possessed.\n            ', tuning_group=GroupNames.SITUATION), 'possessed_duration_hours': TestedSum.TunableFactory(description='\n            How long the possession lasts.\n            ', tuning_group=GroupNames.SITUATION), 'possessed_situation': Situation.TunableReference(description='\n            Possessed situation to place Sim in.\n            ', class_restrictions=('PossessedSituation',), tuning_group=GroupNames.SITUATION), 'default_job_and_role': TunableSituationJobAndRoleState(description='\n            The job/role the infected Sim will be in.\n            ', tuning_group=GroupNames.SITUATION), 'possessed_buff_tag': TunableTag(description='\n            Tag for buffs that can add the Possessed Mood through the Infection\n            System. Possessed status is refreshed when these buffs are added\n            or removed.\n            ', filter_prefixes=('Buff',)), 'possessed_buff_no_animate_tag': TunableTag(description='\n            Possession buffs with this tag will not play the start possession\n            animation.\n            ', filter_prefixes=('Buff',)), 'possession_time_buff': TunableBuffReference(description='\n            The buff to add to the Sim when it is the possessed start time.\n            ')}
    REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._start_possession_alarm = None
        self._end_possession_alarm = None
        self._possession_sources = []

    @classmethod
    def _states(cls):
        return (SituationStateData.from_auto_factory(0, cls.infected_state),)

    @classmethod
    def _get_tuned_job_and_default_role_state_tuples(cls):
        return ((cls.default_job_and_role.job, cls.default_job_and_role.role_state),)

    @classmethod
    def default_job(cls):
        pass

    @classproperty
    def situation_serialization_option(cls):
        return SituationSerializationOption.DONT

    def start_situation(self):
        super().start_situation()
        self._change_state(self.infected_state())
        sim_info = self._get_sim_info()
        for buff in sim_info.Buffs.get_all_buffs_with_tag(self.possessed_buff_tag):
            self._request_possession(buff.buff_type, animate_possession_override=False)
        now = services.time_service().sim_now
        time_span_day = create_time_span(days=1)
        start_day_time = self._get_possessed_start_day_time()
        time_span = now.time_till_next_day_time(start_day_time)
        self._start_possession_alarm = alarms.add_alarm(self, time_span, self._on_possession_start, repeating_time_span=time_span_day, repeating=True)
        end_day_time = self._get_possessed_end_day_time()
        sim_info.Buffs.on_buff_added.register(self._on_buff_added)
        sim_info.Buffs.on_buff_removed.register(self._on_buff_removed)
        in_possession_window = now.time_between_day_times(start_day_time, end_day_time)
        if in_possession_window:
            elapsed_time = create_time_span(days=1) - now.time_till_next_day_time(start_day_time)
            self._trigger_possession_time(elapsed_time=elapsed_time)

    def on_remove(self):
        sim_info = self._get_sim_info()
        sim_info.Buffs.on_buff_added.unregister(self._on_buff_added)
        sim_info.Buffs.on_buff_removed.unregister(self._on_buff_removed)
        super().on_remove()

    @property
    def sim_id(self):
        return self._guest_list.host_sim_id

    def _get_sim_info(self):
        sim_info = services.sim_info_manager().get(self.sim_id)
        return sim_info

    def _get_possessed_start_day_time(self):
        return self.possessed_start_time

    def _get_possessed_end_day_time(self):
        sim_info = self._get_sim_info()
        if sim_info is None:
            logger.error('Missing SimInfo for infected sim')
            return
        start_day_time = self._get_possessed_start_day_time()
        resolver = SingleSimResolver(sim_info)
        hours = self.possessed_duration_hours.get_modified_value(resolver)
        end_day_time = start_day_time + create_time_span(hours=hours)
        return end_day_time

    def _on_possession_start(self, _):
        self._trigger_possession_time()

    def _trigger_possession_time(self, elapsed_time=None):
        sim_info = self._get_sim_info()
        if sim_info is None:
            logger.error('Missing SimInfo for infected sim')
            return
        possession_buff = self.possession_time_buff
        sim_info.add_buff_from_op(possession_buff.buff_type, possession_buff.buff_reason)
        buff_commodity = sim_info.get_statistic(possession_buff.buff_type.commodity, add=False)
        if buff_commodity:
            resolver = SingleSimResolver(sim_info)
            hours = self.possessed_duration_hours.get_modified_value(resolver)
            buff_time = hours*60
            if elapsed_time is not None:
                buff_time -= elapsed_time.in_minutes()
            buff_commodity.set_value(buff_time)

    def _on_sub_situation_end(self, sub_situation_id):
        if services.current_zone().is_zone_shutting_down:
            return
        if self._possession_sources:
            sim_info = self._get_sim_info()
            for source in tuple(self._possession_sources):
                sim_info.remove_buff_by_type(source)

    def _start_possession_situation(self, animate_possession_override=None):
        guest_list = SituationGuestList(invite_only=True, host_sim_id=self.sim_id)
        animate_possession = services.current_zone().is_zone_running
        if animate_possession:
            if animate_possession_override is not None:
                animate_possession = animate_possession_override
        self._create_sub_situation(self.possessed_situation, guest_list=guest_list, user_facing=False, animate_possession=animate_possession)

    def _on_possession_sources_changed(self):
        sub_situations = self._get_sub_situations()
        if sub_situations:
            sub_situations[0].on_possession_sources_changed()

    def _request_possession(self, source, animate_possession_override=None):
        if source in self._possession_sources:
            logger.error('Redundant source: {}', source)
            return
        self._possession_sources.append(source)
        if not self._sub_situation_ids:
            self._start_possession_situation(animate_possession_override=animate_possession_override)
        self._on_possession_sources_changed()

    def _remove_possession_request(self, source):
        if source not in self._possession_sources:
            logger.error('Missing source: {}', source)
            return
        self._possession_sources.remove(source)
        self._on_possession_sources_changed()

    def _on_buff_added(self, buff_type, owner_sim_id):
        if self.possessed_buff_tag not in buff_type.tags:
            return
        animate = None
        if self.possessed_buff_no_animate_tag in buff_type.tags:
            animate = False
        self._request_possession(buff_type, animate_possession_override=animate)

    def _on_buff_removed(self, buff_type, owner_sim_id):
        if self.possessed_buff_tag not in buff_type.tags:
            return
        self._remove_possession_request(buff_type)

    def get_possession_source(self):
        sim_info = self._get_sim_info()
        if sim_info is None:
            return (None, None)
        buff_component = sim_info.Buffs
        longest_source = None
        buff_duration = None
        for source in self._possession_sources:
            buff = buff_component.get_buff_by_type(source)
            if buff is None:
                continue
            buff_commodity = buff.get_commodity_instance()
            if buff_commodity is None:
                longest_source = buff
                buff_duration = None
                break
            buff_value = buff_commodity.get_value()
            if not buff_duration is None:
                if buff_value > buff_duration:
                    buff_duration = buff_value
                    longest_source = buff
            buff_duration = buff_value
            longest_source = buff
        return (longest_source, buff_duration)
예제 #11
0
class SituationManager(DistributableObjectManager):
    __qualname__ = 'SituationManager'
    DEFAULT_LEAVE_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The situation type for the background leave situation.\n                                            It collects sims who are not in other situations and\n                                            asks them to leave periodically.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION),
        class_restrictions=situations.complex.leave_situation.LeaveSituation)
    DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The situation type that drives the sim off the lot pronto.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION),
        class_restrictions=situations.complex.single_sim_leave_situation.
        SingleSimLeaveSituation)
    DEFAULT_VISIT_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The default visit situation used when you ask someone to \n                                            hang out or invite them in.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION))
    DEFAULT_TRAVEL_SITUATION = Situation.TunableReference(
        description=
        ' \n                                            The default situation for when you \n                                            are simply traveling with a group \n                                            of Sims.\n                                            '
    )
    NPC_SOFT_CAP = sims4.tuning.tunable.Tunable(
        description=
        '\n                The base value for calculating the soft cap on the maximum \n                number of NPCs instantiated.\n                \n                The actual value of the NPC soft cap will be\n                this tuning value minus the number of sims in the active household.\n                \n                There is no hard cap because certain types of NPCs must always\n                spawn or the game will be broken. The prime example of a \n                game breaker is the Grim Reaper.\n                \n                If the number of NPCs is:\n                \n                1) At or above the soft cap only game breaker NPCs will be spawned.\n                \n                2) Above the soft cap then low priority NPCs will be driven from the lot.\n                \n                3) Equal to the soft cap and there are pending requests for higher priority\n                NPCs, then lower priority NPCs will be driven from the lot.\n                                \n                ',
        tunable_type=int,
        default=20,
        tuning_filter=sims4.tuning.tunable_base.FilterTag.EXPERT_MODE)
    LEAVE_INTERACTION_TAGS = TunableSet(
        description=
        '\n                The tags indicating leave lot interactions, but not \n                leave lot must run interactions.\n                These are used to determine if a leave lot interaction is running\n                or cancel one if it is.\n                ',
        tunable=TunableEnumWithFilter(tunable_type=tag.Tag,
                                      default=tag.Tag.INVALID,
                                      tuning_filter=FilterTag.EXPERT_MODE,
                                      filter_prefixes=tag.INTERACTION_PREFIX))
    SUPER_SPEED_THREE_REQUEST_BUFF = TunableBuffReference(
        description=
        "\n        The buff to apply to the Sim when we're trying to make them run the\n        leave situation from a super speed three request.\n        ",
        deferred=True)
    _npc_soft_cap_override = None
    _perf_test_cheat_enabled = False

    def __init__(self, manager_id=0):
        super().__init__(manager_id=manager_id)
        self._get_next_session_id = UniqueIdGenerator(1)
        self._added_to_distributor = set()
        self._callbacks = {}
        self._departing_situation_seed = None
        self._arriving_situation_seed = None
        self._zone_seeds_for_zone_spinup = []
        self._open_street_seeds_for_zone_spinup = []
        self._debug_sims = set()
        self._leave_situation_id = 0
        self._player_greeted_situation_id = 0
        self._player_waiting_to_be_greeted_situation_id = 0
        self._sim_being_created = None
        self._sim_data = {}
        self._delay_situation_destruction_ref_count = 0
        self._situations_for_delayed_destruction = set()
        self._bouncer = None
        self._zone_spin_up_greeted_complete = False
        self._pre_bouncer_update = []

    def start(self):
        self._bouncer = Bouncer()

    def destroy_situations_on_teardown(self):
        self.destroy_all_situations(include_system=True)
        self._sim_data.clear()
        self._bouncer.destroy()
        self._bouncer = None

    def reset(self, create_system_situations=True):
        self.destroy_all_situations(include_system=True)
        self._added_to_distributor.clear()
        self._callbacks.clear()
        self._bouncer.reset()
        if create_system_situations:
            self._create_system_situations()

    def add_pre_bouncer_update(self, situation):
        self._pre_bouncer_update.append(situation)

    def update(self):
        if self._bouncer is not None:
            try:
                situations = tuple(self._pre_bouncer_update)
                if situations:
                    self._pre_bouncer_update = []
                    for situation in situations:
                        situation.on_pre_bouncer_update()
                self._bouncer._update()
            except Exception:
                logger.exception('Exception while updating the Bouncer.')

    @property
    def npc_soft_cap(self):
        cap = self.NPC_SOFT_CAP if self._npc_soft_cap_override is None else self._npc_soft_cap_override
        if services.active_household() is None:
            return 0
        return cap - services.active_household().size_of_household

    def set_npc_soft_cap_override(self, override):
        self._npc_soft_cap_override = override

    def enable_perf_cheat(self, enable=True):
        self._perf_test_cheat_enabled = enable
        self._bouncer.spawning_freeze(enable)
        self._bouncer.cap_cheat(enable)

    def get_all(self):
        return [
            obj for obj in self._objects.values()
            if obj._stage == SituationStage.RUNNING
        ]

    def get_new_situation_creation_session(self):
        return self._get_next_session_id()

    @property
    def bouncer(self):
        return self._bouncer

    @property
    def sim_being_created(self):
        return self._sim_being_created

    def add_debug_sim_id(self, sim_id):
        self._debug_sims.add(sim_id)

    def _determine_player_greeted_status_during_zone_spin_up(self):
        if not services.current_zone(
        ).venue_service.venue.requires_visitation_rights:
            return GreetedStatus.NOT_APPLICABLE
        active_household = services.active_household()
        if active_household is None:
            return GreetedStatus.NOT_APPLICABLE
        if active_household.home_zone_id == services.current_zone().id:
            return GreetedStatus.NOT_APPLICABLE
        cur_status = GreetedStatus.WAITING_TO_BE_GREETED
        lot_seeds = list(self._zone_seeds_for_zone_spinup)
        if self._arriving_situation_seed is not None:
            lot_seeds.append(self._arriving_situation_seed)
        for seed in lot_seeds:
            status = seed.get_player_greeted_status()
            logger.debug('Player:{} :{}',
                         status,
                         seed.situation_type,
                         owner='sscholl')
            while status == GreetedStatus.GREETED:
                cur_status = status
                break
        return cur_status

    def get_npc_greeted_status_during_zone_fixup(self, sim_info):
        if not services.current_zone(
        ).venue_service.venue.requires_visitation_rights:
            return GreetedStatus.NOT_APPLICABLE
        if sim_info.lives_here:
            return GreetedStatus.NOT_APPLICABLE
        cur_status = GreetedStatus.NOT_APPLICABLE
        for seed in self._zone_seeds_for_zone_spinup:
            status = seed.get_npc_greeted_status(sim_info)
            logger.debug('NPC:{} :{} :{}',
                         sim_info,
                         status,
                         seed.situation_type,
                         owner='sscholl')
            if status == GreetedStatus.GREETED:
                cur_status = status
                break
            while status == GreetedStatus.WAITING_TO_BE_GREETED:
                cur_status = status
        return cur_status

    def is_player_greeted(self):
        return self._player_greeted_situation_id != 0

    def is_player_waiting_to_be_greeted(self):
        return self._player_waiting_to_be_greeted_situation_id != 0 and self._player_greeted_situation_id == 0

    @property
    def is_zone_spin_up_greeted_complete(self):
        return self._zone_spin_up_greeted_complete

    def create_situation(self,
                         situation_type,
                         guest_list=None,
                         user_facing=True,
                         duration_override=None,
                         custom_init_writer=None,
                         zone_id=0,
                         scoring_enabled=True,
                         spawn_sims_during_zone_spin_up=False):
        if guest_list is None:
            guest_list = SituationGuestList()
        hire_cost = guest_list.get_hire_cost()
        reserved_funds = None
        if guest_list.host_sim is not None:
            reserved_funds = guest_list.host_sim.family_funds.try_remove(
                situation_type.cost() + hire_cost,
                Consts_pb2.TELEMETRY_EVENT_COST, guest_list.host_sim)
            if reserved_funds is None:
                return
            reserved_funds.apply()
        situation_id = id_generator.generate_object_id()
        self._send_create_situation_telemetry(situation_type, situation_id,
                                              guest_list, hire_cost, zone_id)
        if zone_id != 0 and services.current_zone().id != zone_id:
            return self._create_departing_seed_and_travel(
                situation_type,
                situation_id,
                guest_list,
                user_facing,
                duration_override,
                custom_init_writer,
                zone_id,
                scoring_enabled=scoring_enabled)
        situation_seed = SituationSeed(
            situation_type,
            SeedPurpose.NORMAL,
            situation_id,
            guest_list,
            user_facing=user_facing,
            duration_override=duration_override,
            scoring_enabled=scoring_enabled,
            spawn_sims_during_zone_spin_up=spawn_sims_during_zone_spin_up)
        if custom_init_writer is not None:
            situation_seed.setup_for_custom_init_params(custom_init_writer)
        return self.create_situation_from_seed(situation_seed)

    def create_visit_situation_for_unexpected(self, sim):
        duration_override = None
        if self._perf_test_cheat_enabled:
            duration_override = 0
        self.create_visit_situation(sim, duration_override=duration_override)

    def create_visit_situation(self,
                               sim,
                               duration_override=None,
                               visit_type_override=None):
        situation_id = None
        visit_type = visit_type_override if visit_type_override is not None else self.DEFAULT_VISIT_SITUATION
        if visit_type is not None:
            guest_list = situations.situation_guest_list.SituationGuestList(
                invite_only=True)
            guest_info = situations.situation_guest_list.SituationGuestInfo.construct_from_purpose(
                sim.id, visit_type.default_job(), situations.
                situation_guest_list.SituationInvitationPurpose.INVITED)
            guest_list.add_guest_info(guest_info)
            situation_id = self.create_situation(
                visit_type,
                guest_list=guest_list,
                user_facing=False,
                duration_override=duration_override)
        if situation_id is None:
            logger.error('Failed to create visit situation for sim: {}', sim)
            self.make_sim_leave(sim)
        return situation_id

    def create_situation_from_seed(self, seed):
        if not seed.allow_creation:
            return
        if seed.user_facing:
            situation = self.get_user_facing_situation()
            if situation is not None:
                self.destroy_situation_by_id(situation.id)
        if seed.situation_type.is_unique_situation:
            for situation in self.running_situations():
                while type(situation) is seed.situation_type:
                    return
        situation = seed.situation_type(seed)
        try:
            if seed.is_loadable:
                situation._destroy()
                return
            else:
                situation.start_situation()
        except Exception:
            logger.exception('Exception thrown while starting situation')
            situation._destroy()
            return
        self.add(situation)
        if situation.is_user_facing or situation.distribution_override:
            distributor.system.Distributor.instance().add_object(situation)
            self._added_to_distributor.add(situation)
            situation.on_added_to_distributor()
        return situation.id

    def _create_departing_seed_and_travel(self,
                                          situation_type,
                                          situation_id,
                                          guest_list=None,
                                          user_facing=True,
                                          duration_override=None,
                                          custom_init_writer=None,
                                          zone_id=0,
                                          scoring_enabled=True):
        traveling_sim = guest_list.get_traveler()
        if traveling_sim is None:
            logger.error(
                'No traveling sim available for creating departing seed for situation: {}.',
                situation_type)
            return
        if traveling_sim.client is None:
            logger.error(
                'No client on traveling sim: {} for for situation: {}.',
                traveling_sim, situation_type)
            return
        if traveling_sim.household is None:
            logger.error(
                'No household on traveling sim for for situation: {}.',
                situation_type)
            return
        situation_seed = SituationSeed(situation_type,
                                       SeedPurpose.TRAVEL,
                                       situation_id,
                                       guest_list,
                                       user_facing,
                                       duration_override,
                                       zone_id,
                                       scoring_enabled=scoring_enabled)
        if situation_seed is None:
            logger.error('Failed to create departing seed.for situation: {}.',
                         situation_type)
            return
        if custom_init_writer is not None:
            situation_seed.setup_for_custom_init_params(custom_init_writer)
        self._departing_situation_seed = situation_seed
        travel_info = protocolbuffers.InteractionOps_pb2.TravelSimsToZone()
        travel_info.zone_id = zone_id
        travel_info.sim_ids.append(traveling_sim.id)
        traveling_sim_ids = guest_list.get_other_travelers(traveling_sim)
        travel_info.sim_ids.extend(traveling_sim_ids)
        distributor.system.Distributor.instance().add_event(
            protocolbuffers.Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info)
        services.game_clock_service().request_pause('Situation Travel')
        logger.debug('Travel seed creation time {}',
                     services.time_service().sim_now)
        logger.debug('Travel seed future time {}',
                     services.time_service().sim_future)
        return situation_id

    def _create_system_situations(self):
        self._leave_situation_id = 0
        for situation in self.running_situations():
            while type(situation) is self.DEFAULT_LEAVE_SITUATION:
                self._leave_situation_id = situation.id
                break
        if self._leave_situation_id == 0:
            self._leave_situation_id = self.create_situation(
                self.DEFAULT_LEAVE_SITUATION,
                user_facing=False,
                duration_override=0)

    @property
    def auto_manage_distributor(self):
        return False

    def call_on_remove(self, situation):
        super().call_on_remove(situation)
        self._callbacks.pop(situation.id, None)
        if situation in self._added_to_distributor:
            dist = distributor.system.Distributor.instance()
            dist.remove_object(situation)
            self._added_to_distributor.remove(situation)
            situation.on_removed_from_distributor()

    def is_distributed(self, situation):
        return situation in self._added_to_distributor

    def _request_destruction(self, situation):
        if self._delay_situation_destruction_ref_count == 0:
            return True
        self._situations_for_delayed_destruction.add(situation)
        return False

    def destroy_situation_by_id(self, situation_id):
        if situation_id in self:
            if situation_id == self._leave_situation_id:
                self._leave_situation_id = 0
            if situation_id == self._player_greeted_situation_id:
                self._player_greeted_situation_id = 0
            if situation_id == self._player_waiting_to_be_greeted_situation_id:
                self._player_waiting_to_be_greeted_situation_id = 0
            self.remove_id(situation_id)

    def destroy_all_situations(self, include_system=False):
        all_situations = tuple(self.values())
        for situation in all_situations:
            if include_system == False and situation.id == self._leave_situation_id:
                pass
            try:
                self.destroy_situation_by_id(situation.id)
            except Exception:
                logger.error(
                    'Error when destroying situation {}. You are probably screwed.',
                    situation)

    def register_for_callback(self, situation_id, situation_callback_option,
                              callback_fn):
        registrant = _CallbackRegistration(situation_callback_option,
                                           callback_fn)
        registrant_list = self._callbacks.setdefault(situation_id, [])
        registrant_list.append(registrant)

    def create_greeted_npc_visiting_npc_situation(self, npc_sim_info):
        services.current_zone().venue_service.venue.summon_npcs(
            (npc_sim_info, ),
            venues.venue_constants.NPCSummoningPurpose.PLAYER_BECOMES_GREETED)

    def create_greeted_player_visiting_npc_situation(self, sim=None):
        if sim is None:
            guest_list = situations.situation_guest_list.SituationGuestList()
        else:
            guest_list = situations.situation_guest_list.SituationGuestList(
                host_sim_id=sim.id)
        greeted_situation_type = services.current_zone(
        ).venue_service.venue.player_greeted_situation_type
        if greeted_situation_type is None:
            return
        self._player_greeted_situation_id = self.create_situation(
            greeted_situation_type, user_facing=False, guest_list=guest_list)

    def create_player_waiting_to_be_greeted_situation(self):
        self._player_waiting_to_be_greeted_situation_id = self.create_situation(
            services.current_zone(
            ).venue_service.venue.player_ungreeted_situation_type,
            user_facing=False)

    def _handle_player_greeting_situations_during_zone_spin_up(self):
        if self._zone_spin_up_player_greeted_status == GreetedStatus.NOT_APPLICABLE:
            return
        if self._zone_spin_up_player_greeted_status == GreetedStatus.GREETED:
            greeted_situation_type = services.current_zone(
            ).venue_service.venue.player_greeted_situation_type
            for situation in self.running_situations():
                while type(situation) is greeted_situation_type:
                    break
            self.create_greeted_player_visiting_npc_situation()
            return
        waiting_situation_type = services.current_zone(
        ).venue_service.venue.player_ungreeted_situation_type
        for situation in self.running_situations():
            while type(situation) is waiting_situation_type:
                break
        self.create_player_waiting_to_be_greeted_situation()

    def handle_npcs_during_zone_fixup(self):
        if services.game_clock_service(
        ).time_has_passed_in_world_since_zone_save() or services.current_zone(
        ).active_household_changed_between_save_and_load():
            sim_infos_to_fix_up = []
            for sim_info in services.sim_info_manager(
            ).get_sim_infos_saved_in_zone():
                while sim_info.is_npc and not sim_info.lives_here and sim_info.get_sim_instance(
                ) is not None:
                    sim_infos_to_fix_up.append(sim_info)
            if sim_infos_to_fix_up:
                logger.debug('Fixing up {} npcs during zone fixup',
                             len(sim_infos_to_fix_up),
                             owner='sscholl')
                services.current_zone().venue_service.venue.zone_fixup(
                    sim_infos_to_fix_up)

    def make_waiting_player_greeted(self, door_bell_ringing_sim=None):
        for situation in self.running_situations():
            situation._on_make_waiting_player_greeted(door_bell_ringing_sim)
        if self._player_greeted_situation_id == 0:
            self.create_greeted_player_visiting_npc_situation(
                door_bell_ringing_sim)

    def save(self,
             zone_data=None,
             open_street_data=None,
             save_slot_data=None,
             **kwargs):
        if zone_data is None:
            return
        SituationSeed.serialize_travel_seed_to_slot(
            save_slot_data, self._departing_situation_seed)
        zone_seeds = []
        street_seeds = []
        for situation in self.running_situations():
            seed = situation.save_situation()
            while seed is not None:
                if situation.situation_serialization_option == SituationSerializationOption.OPEN_STREETS:
                    street_seeds.append(seed)
                else:
                    zone_seeds.append(seed)
        SituationSeed.serialize_seeds_to_zone(zone_seeds, zone_data)
        SituationSeed.serialize_seeds_to_open_street(street_seeds,
                                                     open_street_data)

    def on_pre_spawning_sims(self):
        zone = services.current_zone()
        save_slot_proto = services.get_persistence_service(
        ).get_save_slot_proto_buff()
        seed = SituationSeed.deserialize_travel_seed_from_slot(save_slot_proto)
        if seed is not None:
            if zone.id != seed.zone_id:
                logger.debug(
                    'Travel situation :{} not loaded. Expected zone :{} but is on zone:{}',
                    seed.situation_type, seed.zone_id,
                    services.current_zone().id)
                seed.allow_creation = False
            else:
                time_since_travel_seed_created = services.time_service(
                ).sim_now - seed.create_time
                if time_since_travel_seed_created > date_and_time.TimeSpan.ZERO:
                    logger.debug(
                        'Not loading traveled situation :{} because time has passed {}',
                        seed.situation_type, time_since_travel_seed_created)
                    seed.allow_creation = False
        self._arriving_situation_seed = seed
        zone_proto = services.get_persistence_service().get_zone_proto_buff(
            zone.id)
        if zone_proto is not None:
            self._zone_seeds_for_zone_spinup = SituationSeed.deserialize_seeds_from_zone(
                zone_proto)
        for seed in self._zone_seeds_for_zone_spinup:
            while not seed.situation_type._should_seed_be_loaded(seed):
                seed.allow_creation = False
        open_street_proto = services.get_persistence_service(
        ).get_open_street_proto_buff(zone.open_street_id)
        if open_street_proto is not None:
            self._open_street_seeds_for_zone_spinup = SituationSeed.deserialize_seeds_from_open_street(
                open_street_proto)
        for seed in self._open_street_seeds_for_zone_spinup:
            while not seed.situation_type._should_seed_be_loaded(seed):
                seed.allow_creation = False
        self._zone_spin_up_player_greeted_status = self._determine_player_greeted_status_during_zone_spin_up(
        )

    def create_situations_during_zone_spin_up(self):
        for seed in self._zone_seeds_for_zone_spinup:
            self.create_situation_from_seed(seed)
        for seed in self._open_street_seeds_for_zone_spinup:
            self.create_situation_from_seed(seed)
        self._create_system_situations()
        if self._arriving_situation_seed is not None:
            self.create_situation_from_seed(self._arriving_situation_seed)
        self._handle_player_greeting_situations_during_zone_spin_up()
        self.handle_npcs_during_zone_fixup()

    def on_all_situations_created_during_zone_spin_up(self):
        self._bouncer.start()

    def get_sim_serialization_option(self, sim):
        result = sims.sim_info_types.SimSerializationOption.UNDECLARED
        for situation in self.get_situations_sim_is_in(sim):
            option = situation.situation_serialization_option
            if option == situations.situation_types.SituationSerializationOption.LOT:
                result = sims.sim_info_types.SimSerializationOption.LOT
                break
            else:
                while option == situations.situation_types.SituationSerializationOption.OPEN_STREETS:
                    result = sims.sim_info_types.SimSerializationOption.OPEN_STREETS
        return result

    def remove_sim_from_situation(self, sim, situation_id):
        situation = self.get(situation_id)
        if situation is None:
            return
        self._bouncer.remove_sim_from_situation(sim, situation)

    def on_reset(self, sim_ref):
        pass

    def on_sim_creation(self, sim):
        sim_data = self._sim_data.setdefault(sim.id,
                                             _SituationManagerSimData(sim.id))
        sim_data.set_created_time(services.time_service().sim_now)
        self._prune_sim_data()
        self._sim_being_created = sim
        if sim.id in self._debug_sims:
            self._debug_sims.discard(sim.id)
            if self._perf_test_cheat_enabled:
                self.create_visit_situation_for_unexpected(sim)
            else:
                services.current_zone().venue_service.venue.summon_npcs(
                    (sim.sim_info, ), NPCSummoningPurpose.DEFAULT)
        self._bouncer.on_sim_creation(sim)
        self._sim_being_created = None

    def get_situations_sim_is_in(self, sim):
        return [
            situation for situation in self.values()
            if situation._stage == SituationStage.RUNNING
        ]

    def is_user_facing_situation_running(self):
        for situation in self.values():
            while situation.is_user_facing:
                return True
        return False

    def get_user_facing_situation(self):
        for situation in self.values():
            while situation.is_user_facing:
                return situation

    def running_situations(self):
        return [
            obj for obj in self._objects.values()
            if obj._stage == SituationStage.RUNNING
        ]

    def is_situation_with_tags_running(self, tags):
        for situation in self.values():
            while situation._stage == SituationStage.RUNNING and situation.tags & tags:
                return True
        return False

    def user_ask_sim_to_leave_now_must_run(self, sim):
        if not sim.sim_info.is_npc or sim.sim_info.lives_here:
            return
        ask_to_leave = True
        for situation in self.get_situations_sim_is_in(sim):
            while not situation.on_ask_sim_to_leave(sim):
                ask_to_leave = False
                break
        if ask_to_leave:
            self.make_sim_leave_now_must_run(sim)

    def make_sim_leave_now_must_run(self,
                                    sim,
                                    super_speed_three_request=False):
        if services.current_zone().is_zone_shutting_down:
            return
        for situation in self.get_situations_sim_is_in(sim):
            while type(situation) is self.DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION:
                return
        if super_speed_three_request:
            sim.add_buff(
                buff_type=self.SUPER_SPEED_THREE_REQUEST_BUFF.buff_type,
                buff_reason=self.SUPER_SPEED_THREE_REQUEST_BUFF.buff_reason)
        leave_now_type = self.DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION
        guest_list = situations.situation_guest_list.SituationGuestList(
            invite_only=True)
        guest_info = situations.situation_guest_list.SituationGuestInfo(
            sim.id,
            leave_now_type.default_job(),
            RequestSpawningOption.CANNOT_SPAWN,
            BouncerRequestPriority.VIP,
            expectation_preference=True)
        guest_list.add_guest_info(guest_info)
        self.create_situation(leave_now_type,
                              guest_list=guest_list,
                              user_facing=False)

    def make_sim_leave(self, sim):
        leave_situation = self.get(self._leave_situation_id)
        if leave_situation is None:
            logger.error(
                'The leave situation is missing. Making the sim leave now must run.'
            )
            self.make_sim_leave_now_must_run(sim)
            return
        leave_situation.invite_sim_to_leave(sim)

    def expedite_leaving(self):
        leave_situation = self.get(self._leave_situation_id)
        if leave_situation is None:
            return
        for sim in leave_situation.all_sims_in_situation_gen():
            self.make_sim_leave_now_must_run(sim)

    def get_time_span_sim_has_been_on_lot(self, sim):
        sim_data = self._sim_data.get(sim.id)
        if sim_data is None:
            return
        if sim_data.created_time is None:
            return
        return services.time_service().sim_now - sim_data.created_time

    def get_remaining_blacklist_time_span(self, sim_id):
        sim_data = self._sim_data.get(sim_id)
        if sim_data is None:
            return date_and_time.TimeSpan.ZERO
        return sim_data.get_remaining_blacklisted_time_span()

    def get_auto_fill_blacklist(self):
        blacklist = set()
        for (sim_id, sim_data) in tuple(self._sim_data.items()):
            while sim_data.is_blacklisted:
                blacklist.add(sim_id)
        return blacklist

    def add_sim_to_auto_fill_blacklist(self, sim_id, blacklist_until=None):
        sim_data = self._sim_data.setdefault(sim_id,
                                             _SituationManagerSimData(sim_id))
        sim_data.blacklist(blacklist_until=blacklist_until)
        self._prune_sim_data()

    def _prune_sim_data(self):
        to_remove_ids = []
        for (sim_id, sim_data) in self._sim_data.items():
            while services.object_manager().get(
                    sim_id) is None and sim_data.is_blacklisted == False:
                to_remove_ids.append(sim_id)
        for sim_id in to_remove_ids:
            del self._sim_data[sim_id]

    def _get_callback_registrants(self, situation_id):
        return list(self._callbacks.get(situation_id, []))

    def _send_create_situation_telemetry(self, situation_type, situation_id,
                                         guest_list, hire_cost, zone_id):
        if hasattr(situation_type, 'guid64'):
            with telemetry_helper.begin_hook(
                    writer, TELEMETRY_HOOK_CREATE_SITUATION) as hook:
                hook.write_int('situ', situation_id)
                hook.write_int('host', guest_list.host_sim_id)
                hook.write_guid('type', situation_type.guid64)
                hook.write_bool('invi', guest_list.invite_only)
                hook.write_bool('hire', hire_cost)
                hook.write_bool(
                    'nzon', zone_id != 0
                    and services.current_zone().id != zone_id)
            sim_info_manager = services.sim_info_manager()
            if sim_info_manager is not None:
                while True:
                    for guest_infos in guest_list._job_type_to_guest_infos.values(
                    ):
                        for guest_info in guest_infos:
                            if guest_info.sim_id == 0:
                                pass
                            guest_sim = sim_info_manager.get(guest_info.sim_id)
                            if guest_sim is None:
                                pass
                            client = services.client_manager(
                            ).get_client_by_household_id(
                                guest_sim.household_id)
                            with telemetry_helper.begin_hook(
                                    writer, TELEMETRY_HOOK_GUEST) as hook:
                                hook.write_int('situ', situation_id)
                                if client is None:
                                    hook.write_int('npcg', guest_info.sim_id)
                                else:
                                    hook.write_int('pcgu', guest_info.sim_id)
                                    hook.write_guid('jobb',
                                                    guest_info.job_type.guid64)
예제 #12
0
class SituationManager(DistributableObjectManager):
    DEFAULT_LEAVE_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The situation type for the background leave situation.\n                                            It collects sims who are not in other situations and\n                                            asks them to leave periodically.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION),
        class_restrictions=situations.complex.leave_situation.LeaveSituation)
    DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The situation type that drives the sim off the lot pronto.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION),
        class_restrictions=situations.complex.single_sim_leave_situation.
        SingleSimLeaveSituation)
    DEFAULT_VISIT_SITUATION = sims4.tuning.tunable.TunableReference(
        description=
        '\n                                            The default visit situation used when you ask someone to \n                                            hang out or invite them in.\n                                            ',
        manager=services.get_instance_manager(sims4.resources.Types.SITUATION))
    DEFAULT_TRAVEL_SITUATION = Situation.TunableReference(
        description=
        ' \n                                            The default situation for when you \n                                            are simply traveling with a group \n                                            of Sims.\n                                            '
    )
    LEAVE_INTERACTION_TAGS = TunableSet(
        description=
        '\n                The tags indicating leave lot interactions, but not \n                leave lot must run interactions.\n                These are used to determine if a leave lot interaction is running\n                or cancel one if it is.\n                ',
        tunable=TunableEnumWithFilter(tunable_type=tag.Tag,
                                      default=tag.Tag.INVALID,
                                      tuning_filter=FilterTag.EXPERT_MODE,
                                      filter_prefixes=tag.INTERACTION_PREFIX))
    SUPER_SPEED_THREE_REQUEST_BUFF = TunableBuffReference(
        description=
        "\n        The buff to apply to the Sim when we're trying to make them run the\n        leave situation from a super speed three request.\n        ",
        deferred=True)
    DEFAULT_PLAYER_PLANNED_DRAMA_NODE = sims4.tuning.tunable.TunableReference(
        description=
        '\n        The drama node that will be scheduled when a player plans an event for the future.\n        ',
        manager=services.get_instance_manager(
            sims4.resources.Types.DRAMA_NODE))
    _perf_test_cheat_enabled = False

    def __init__(self, manager_id=0):
        super().__init__(manager_id=manager_id)
        self._get_next_session_id = UniqueIdGenerator(1)
        self._added_to_distributor = set()
        self._callbacks = defaultdict(lambda: defaultdict(CallableList))
        self._departing_situation_seed = None
        self._arriving_situation_seed = None
        self._zone_seeds_for_zone_spinup = []
        self._open_street_seeds_for_zone_spinup = []
        self._debug_sims = set()
        self._leave_situation_id = 0
        self._player_greeted_situation_id = 0
        self._player_waiting_to_be_greeted_situation_id = 0
        self._sim_being_created = None
        self._sim_data = {}
        self._delay_situation_destruction_ref_count = 0
        self._situations_for_delayed_destruction = set()
        self._bouncer = None
        self._pause_handle = None
        self._zone_spin_up_greeted_complete = False

    @classproperty
    def save_error_code(cls):
        return persistence_error_types.ErrorCodes.SERVICE_SAVE_FAILED_SITUATION_MANAGER

    def start(self):
        self._bouncer = Bouncer()

    def stop(self):
        if self._pause_handle is not None:
            pause_handle = self._pause_handle
            self._pause_handle = None
            services.game_clock_service().remove_request(
                pause_handle, source=GameSpeedChangeSource.SITUATION)

    def destroy_situations_on_teardown(self):
        self.destroy_all_situations(include_system=True)
        self._sim_data.clear()
        self._bouncer.destroy()
        self._bouncer = None

    def reset(self, create_system_situations=True):
        self.destroy_all_situations(include_system=True)
        self._added_to_distributor.clear()
        self._callbacks.clear()
        self._bouncer.reset()
        if create_system_situations:
            self._create_system_situations()

    def update(self):
        if self._bouncer is not None:
            try:
                self._bouncer._update()
            except Exception:
                logger.exception('Exception while updating the Bouncer.')

    def enable_perf_cheat(self, enable=True):
        self._perf_test_cheat_enabled = enable
        self._bouncer.spawning_freeze(enable)
        self._bouncer.cap_cheat(enable)

    def get_all(self):
        return [
            obj for obj in self._objects.values()
            if obj._stage == SituationStage.RUNNING
        ]

    def get_new_situation_creation_session(self):
        return self._get_next_session_id()

    @property
    def bouncer(self):
        return self._bouncer

    @property
    def sim_being_created(self):
        return self._sim_being_created

    def add_debug_sim_id(self, sim_id):
        self._debug_sims.add(sim_id)

    def _determine_player_greeted_status_during_zone_spin_up(self):
        if not services.current_zone(
        ).venue_service.active_venue.requires_visitation_rights:
            return GreetedStatus.NOT_APPLICABLE
        active_household = services.active_household()
        if active_household is None:
            return GreetedStatus.NOT_APPLICABLE
        if active_household.considers_current_zone_its_residence():
            return GreetedStatus.NOT_APPLICABLE
        cur_status = GreetedStatus.WAITING_TO_BE_GREETED
        lot_seeds = list(self._zone_seeds_for_zone_spinup)
        if self._arriving_situation_seed is not None:
            lot_seeds.append(self._arriving_situation_seed)
        for seed in lot_seeds:
            status = seed.get_player_greeted_status()
            logger.debug('Player:{} :{}',
                         status,
                         seed.situation_type,
                         owner='sscholl')
            if status == GreetedStatus.GREETED:
                cur_status = status
                break
        return cur_status

    def get_npc_greeted_status_during_zone_fixup(self, sim_info):
        if not services.current_zone(
        ).venue_service.active_venue.requires_visitation_rights:
            return GreetedStatus.NOT_APPLICABLE
        if sim_info.lives_here:
            return GreetedStatus.NOT_APPLICABLE
        cur_status = GreetedStatus.NOT_APPLICABLE
        for seed in self._zone_seeds_for_zone_spinup:
            status = seed.get_npc_greeted_status(sim_info)
            logger.debug('NPC:{} :{} :{}',
                         sim_info,
                         status,
                         seed.situation_type,
                         owner='sscholl')
            if status == GreetedStatus.GREETED:
                cur_status = status
                break
            if status == GreetedStatus.WAITING_TO_BE_GREETED:
                cur_status = status
        return cur_status

    def is_player_greeted(self):
        return self._player_greeted_situation_id != 0

    def is_player_waiting_to_be_greeted(self):
        return self._player_waiting_to_be_greeted_situation_id != 0 and self._player_greeted_situation_id == 0

    def create_situation(self,
                         situation_type,
                         guest_list=None,
                         user_facing=True,
                         duration_override=None,
                         custom_init_writer=None,
                         zone_id=0,
                         scoring_enabled=True,
                         spawn_sims_during_zone_spin_up=False,
                         creation_source=None,
                         travel_request_kwargs=frozendict(),
                         linked_sim_id=GLOBAL_SITUATION_LINKED_SIM_ID,
                         scheduled_time=None,
                         **extra_kwargs):
        zone = services.current_zone()
        if zone.is_zone_shutting_down:
            return
        current_zone_id = services.current_zone_id()
        situation_type = services.narrative_service(
        ).get_possible_replacement_situation(situation_type)
        if services.get_zone_modifier_service().is_situation_prohibited(
                zone_id if zone_id else current_zone_id, situation_type):
            return
        if guest_list is None:
            guest_list = SituationGuestList()
        hire_cost = guest_list.get_hire_cost()
        host_sim_info = guest_list.host_sim_info
        if host_sim_info is not None and not host_sim_info.household.funds.try_remove(
                situation_type.cost() + hire_cost,
                Consts_pb2.TELEMETRY_EVENT_COST, host_sim_info):
            return
        situation_id = id_generator.generate_object_id()
        self._send_create_situation_telemetry(situation_type, situation_id,
                                              guest_list, hire_cost, zone_id)
        if zone_id and zone_id != current_zone_id and scheduled_time is None:
            return self._create_situation_and_travel(
                situation_type,
                situation_id,
                guest_list,
                user_facing,
                duration_override,
                custom_init_writer,
                zone_id,
                scoring_enabled=scoring_enabled,
                creation_source=creation_source,
                linked_sim_id=linked_sim_id,
                travel_request_kwargs=travel_request_kwargs)
        situation_seed = SituationSeed(
            situation_type,
            SeedPurpose.NORMAL,
            situation_id,
            guest_list,
            user_facing=user_facing,
            duration_override=duration_override,
            zone_id=zone_id,
            scoring_enabled=scoring_enabled,
            spawn_sims_during_zone_spin_up=spawn_sims_during_zone_spin_up,
            creation_source=creation_source,
            linked_sim_id=linked_sim_id,
            **extra_kwargs)
        if custom_init_writer is not None:
            situation_seed.setup_for_custom_init_params(custom_init_writer)
        return_id = None
        if scheduled_time is not None:
            uid = services.drama_scheduler_service().schedule_node(
                self.DEFAULT_PLAYER_PLANNED_DRAMA_NODE,
                SingleSimResolver(guest_list.host_sim.sim_info),
                specific_time=scheduled_time,
                situation_seed=situation_seed)
            return_id = situation_id if uid is not None else None
        else:
            return_id = self.create_situation_from_seed(situation_seed)
        return return_id

    def _create_situation_and_travel(self, situation_type, *args,
                                     travel_request_kwargs, **kwargs):
        travel_fn = lambda: self._create_departing_seed_and_travel(
            situation_type, *args, **kwargs)
        travel_request_situtaion = None
        for situation in self.get_user_facing_situations_gen():
            if travel_request_situtaion is None:
                travel_request_situtaion = situation
            elif situation.travel_request_behavior.restrict > travel_request_situtaion.travel_request_behavior.restrict:
                travel_request_situtaion = situation
        if travel_request_situtaion is not None:
            return travel_request_situtaion.travel_request_behavior(
                travel_request_situtaion, situation_type, travel_fn,
                **travel_request_kwargs)
        return travel_fn()

    def create_visit_situation_for_unexpected(self, sim):
        duration_override = None
        if self._perf_test_cheat_enabled:
            duration_override = 0
        self.create_visit_situation(sim, duration_override=duration_override)

    def create_visit_situation(self,
                               sim,
                               duration_override=None,
                               visit_type_override=None):
        situation_id = None
        visit_type = visit_type_override if visit_type_override is not None else self.DEFAULT_VISIT_SITUATION
        if visit_type is not None:
            guest_list = situations.situation_guest_list.SituationGuestList(
                invite_only=True)
            guest_info = situations.situation_guest_list.SituationGuestInfo.construct_from_purpose(
                sim.id, visit_type.default_job(), situations.
                situation_guest_list.SituationInvitationPurpose.INVITED)
            guest_list.add_guest_info(guest_info)
            situation_id = self.create_situation(
                visit_type,
                guest_list=guest_list,
                user_facing=False,
                duration_override=duration_override)
        if situation_id is None:
            logger.error('Failed to create visit situation for sim: {}', sim)
            self.make_sim_leave(sim)
        return situation_id

    def create_situation_from_seed(self, seed):
        if not seed.allow_creation:
            return
        if seed.user_facing:
            for situation in tuple(self.get_user_facing_situations_gen()):
                if seed.linked_sim_id == GLOBAL_SITUATION_LINKED_SIM_ID:
                    if situation.linked_sim_id == GLOBAL_SITUATION_LINKED_SIM_ID:
                        self.destroy_situation_by_id(situation.id)
        if seed.situation_type.is_unique_situation:
            for situation in self.running_situations():
                if type(situation) is seed.situation_type:
                    return
        try:
            situation = seed.situation_type(seed)
        except ValueError:
            logger.exception('Failed to initialize situation: {}',
                             seed.situation_type)
            return
        try:
            if seed.is_loadable:
                if not situation.load_situation():
                    situation._destroy()
                    return
            else:
                situation.start_situation()
        except Exception:
            logger.exception('Exception thrown while starting situation')
            situation._destroy()
            return
        if situation._stage == SituationStage.DYING:
            return
        self.add(situation)
        if situation.is_user_facing or situation.distribution_override:
            distributor.system.Distributor.instance().add_object(situation)
            self._added_to_distributor.add(situation)
            situation.on_added_to_distributor()
        return situation.id

    def travel_existing_situation(self, situation, zone_id):
        seed = situation.save_situation()
        seed.zone_id = zone_id
        self.travel_seed(seed)
        situation._self_destruct()

    def _create_departing_seed_and_travel(
            self,
            situation_type,
            situation_id,
            guest_list=None,
            user_facing=True,
            duration_override=None,
            custom_init_writer=None,
            zone_id=0,
            scoring_enabled=True,
            creation_source=None,
            linked_sim_id=GLOBAL_SITUATION_LINKED_SIM_ID):
        current_zone = services.current_zone()
        if current_zone is not None and not current_zone.is_zone_running:
            logger.error(
                'Unable to travel during spin-up: {}. A travel interaction was save/loaded, which is incorrect. Make it one-shot or non-saveable.',
                situation_type)
            return
        traveling_sim = guest_list.get_traveler()
        if traveling_sim is None:
            logger.error(
                'No traveling Sim available for creating departing seed for situation: {}.',
                situation_type)
            return
        if traveling_sim.client is None:
            logger.error(
                'No client on traveling Sim: {} for for situation: {}.',
                traveling_sim, situation_type)
            return
        if traveling_sim.household is None:
            logger.error(
                'No household on traveling Sim for for situation: {}.',
                situation_type)
            return
        situation_seed = SituationSeed(situation_type,
                                       SeedPurpose.TRAVEL,
                                       situation_id,
                                       guest_list,
                                       user_facing,
                                       duration_override,
                                       zone_id,
                                       scoring_enabled=scoring_enabled,
                                       creation_source=creation_source,
                                       linked_sim_id=linked_sim_id)
        if situation_seed is None:
            logger.error('Failed to create departing seed for situation: {}.',
                         situation_type)
            return
        if custom_init_writer is not None:
            situation_seed.setup_for_custom_init_params(custom_init_writer)
        return self.travel_seed(situation_seed)

    def travel_seed(self, seed):
        self._departing_situation_seed = seed
        traveling_sim = seed.guest_list.get_traveler()
        travel_info = protocolbuffers.InteractionOps_pb2.TravelSimsToZone()
        travel_info.zone_id = seed.zone_id
        travel_info.sim_ids.append(traveling_sim.id)
        traveling_sim_ids = seed.guest_list.get_other_travelers(traveling_sim)
        travel_info.sim_ids.extend(traveling_sim_ids)
        distributor.system.Distributor.instance().add_event(
            protocolbuffers.Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info)
        if self._pause_handle is None:
            self._pause_handle = services.game_clock_service().push_speed(
                ClockSpeedMode.PAUSED,
                reason='Situation Travel',
                source=GameSpeedChangeSource.SITUATION)
        logger.debug('Travel seed now time {}',
                     services.time_service().sim_now)
        logger.debug('Travel seed future time {}',
                     services.time_service().sim_future)
        return seed.situation_id

    def _create_system_situations(self):
        self._leave_situation_id = 0
        for situation in self.running_situations():
            if type(situation) is self.DEFAULT_LEAVE_SITUATION:
                self._leave_situation_id = situation.id
                break
        if self._leave_situation_id == 0:
            self._leave_situation_id = self.create_situation(
                self.DEFAULT_LEAVE_SITUATION,
                user_facing=False,
                duration_override=0)

    @property
    def auto_manage_distributor(self):
        return False

    def call_on_remove(self, situation):
        super().call_on_remove(situation)
        self._callbacks.pop(situation.id, None)
        if situation in self._added_to_distributor:
            dist = distributor.system.Distributor.instance()
            dist.remove_object(situation)
            self._added_to_distributor.remove(situation)
            situation.on_removed_from_distributor()

    def is_distributed(self, situation):
        return situation in self._added_to_distributor

    def _request_destruction(self, situation):
        if self._delay_situation_destruction_ref_count == 0:
            return True
        self._situations_for_delayed_destruction.add(situation)
        return False

    def pre_destroy_situation_by_id(self, situation_id):
        situation = self.get(situation_id)
        if situation is not None:
            situation.pre_destroy()

    def destroy_situation_by_id(self, situation_id):
        if situation_id in self:
            if situation_id == self._leave_situation_id:
                self._leave_situation_id = 0
            if situation_id == self._player_greeted_situation_id:
                self._player_greeted_situation_id = 0
            if situation_id == self._player_waiting_to_be_greeted_situation_id:
                self._player_waiting_to_be_greeted_situation_id = 0
            self.remove_id(situation_id)

    def destroy_all_situations(self, include_system=False):
        all_situations = tuple(self.values())
        for situation in all_situations:
            if include_system == False and situation.id == self._leave_situation_id:
                continue
            try:
                self.destroy_situation_by_id(situation.id)
            except Exception:
                logger.error(
                    'Error when destroying situation {}. You are probably screwed.',
                    situation)

    def register_for_callback(self, situation_id, situation_callback_option,
                              callback_fn):
        if situation_id not in self:
            logger.error(
                "Failed to register situation callback. Situation doesn't exist. {}, {}, {}",
                situation_id,
                situation_callback_option,
                callback_fn,
                owner='rmccord')
            return
        callable_list = self._callbacks[situation_id][
            situation_callback_option]
        if callback_fn not in callable_list:
            callable_list.append(callback_fn)
        self._callbacks[situation_id][
            situation_callback_option] = callable_list

    def unregister_callback(self, situation_id, situation_callback_option,
                            callback_fn):
        if situation_id not in self:
            return
        callable_list = self._callbacks[situation_id][
            situation_callback_option]
        if callback_fn in callable_list:
            callable_list.remove(callback_fn)
        self._callbacks[situation_id][
            situation_callback_option] = callable_list

    def create_greeted_npc_visiting_npc_situation(self, npc_sim_info):
        services.current_zone().venue_service.active_venue.summon_npcs(
            (npc_sim_info, ),
            venues.venue_constants.NPCSummoningPurpose.PLAYER_BECOMES_GREETED)

    def _create_greeted_player_visiting_npc_situation(self, sim=None):
        if sim is None:
            guest_list = situations.situation_guest_list.SituationGuestList()
        else:
            guest_list = situations.situation_guest_list.SituationGuestList(
                host_sim_id=sim.id)
        greeted_situation_type = services.current_zone(
        ).venue_service.active_venue.player_greeted_situation_type
        if greeted_situation_type is None:
            return
        self._player_greeted_situation_id = self.create_situation(
            greeted_situation_type, user_facing=False, guest_list=guest_list)

    def _create_player_waiting_to_be_greeted_situation(self):
        self._player_waiting_to_be_greeted_situation_id = self.create_situation(
            services.current_zone(
            ).venue_service.active_venue.player_ungreeted_situation_type,
            user_facing=False)

    def make_player_waiting_to_be_greeted_during_zone_spin_up(self):
        waiting_situation_type = services.current_zone(
        ).venue_service.active_venue.player_ungreeted_situation_type
        for situation in self.running_situations():
            if type(situation) is waiting_situation_type:
                self._player_waiting_to_be_greeted_situation_id = situation.id
                break
        else:
            self._create_player_waiting_to_be_greeted_situation()

    def make_player_greeted_during_zone_spin_up(self):
        greeted_situation_type = services.current_zone(
        ).venue_service.active_venue.player_greeted_situation_type
        for situation in self.running_situations():
            if type(situation) is greeted_situation_type:
                self._player_greeted_situation_id = situation.id
                break
        else:
            self._create_greeted_player_visiting_npc_situation()

    def destroy_player_waiting_to_be_greeted_situation(self):
        if self._player_waiting_to_be_greeted_situation_id is 0:
            return
        situation = self.get(self._player_waiting_to_be_greeted_situation_id)
        if situation is None:
            return
        situation._self_destruct()
        self._player_waiting_to_be_greeted_situation_id = 0

    def make_waiting_player_greeted(self, door_bell_ringing_sim=None):
        for situation in self.running_situations():
            situation._on_make_waiting_player_greeted(door_bell_ringing_sim)
        if self._player_greeted_situation_id == 0:
            self._create_greeted_player_visiting_npc_situation(
                door_bell_ringing_sim)

    def get_situation_by_type(self, situation_type):
        for situation in self.running_situations():
            if type(situation) is situation_type:
                return situation

    def get_situations_by_type(self, *situation_types):
        found_situations = []
        for situation in self.running_situations():
            if isinstance(situation, situation_types):
                found_situations.append(situation)
        return found_situations

    def get_situations_by_tags(self, situation_tags):
        found_situations = []
        for situation in self.running_situations():
            if situation.tags & situation_tags:
                found_situations.append(situation)
        return found_situations

    def is_situation_running(self, situation_type):
        return any(
            isinstance(situation, situation_type)
            for situation in self.running_situations())

    def disable_save_to_situation_manager(self, situation_id):
        situation = self.get(situation_id)
        if situation is not None:
            situation.save_to_situation_manager = False

    def save(self,
             zone_data=None,
             open_street_data=None,
             save_slot_data=None,
             **kwargs):
        if zone_data is None:
            return
        zone = services.current_zone()
        if zone.venue_service.build_buy_edit_mode:
            return self._save_for_edit_mode(zone_data=zone_data,
                                            open_street_data=open_street_data,
                                            save_slot_data=save_slot_data)
        SituationSeed.serialize_travel_seed_to_slot(
            save_slot_data, self._departing_situation_seed)
        zone_seeds = []
        street_seeds = []
        holiday_seeds = []
        for situation in self.running_situations():
            if not situation.save_to_situation_manager:
                continue
            seed = situation.save_situation()
            if seed is not None:
                if situation.situation_serialization_option == SituationSerializationOption.OPEN_STREETS:
                    street_seeds.append(seed)
                elif situation.situation_serialization_option == SituationSerializationOption.LOT:
                    zone_seeds.append(seed)
                else:
                    holiday_seeds.append(seed)
        SituationSeed.serialize_seeds_to_zone(zone_seeds=zone_seeds,
                                              zone_data_msg=zone_data,
                                              blacklist_data=self._sim_data)
        SituationSeed.serialize_seeds_to_open_street(
            open_street_seeds=street_seeds,
            open_street_data_msg=open_street_data)
        active_household = services.active_household()
        if active_household is not None:
            active_household.holiday_tracker.set_holiday_situation_seeds(
                holiday_seeds)

    def _save_for_edit_mode(self,
                            zone_data=None,
                            open_street_data=None,
                            save_slot_data=None):
        SituationSeed.serialize_travel_seed_to_slot(
            save_slot_data, self._arriving_situation_seed)
        SituationSeed.serialize_seeds_to_zone(
            zone_seeds=self._zone_seeds_for_zone_spinup,
            zone_data_msg=zone_data,
            blacklist_data=self._sim_data)
        SituationSeed.serialize_seeds_to_open_street(
            open_street_seeds=self._open_street_seeds_for_zone_spinup,
            open_street_data_msg=open_street_data)

    def spin_up_for_edit_mode(self):
        self.create_seeds_during_zone_spin_up()

    def load(self, zone_data=None):
        if zone_data is None:
            return
        for blacklist_data in zone_data.gameplay_zone_data.situations_data.blacklist_data:
            sim_id = blacklist_data.sim_id
            sim_data = self._sim_data.setdefault(
                sim_id, _SituationManagerSimData(sim_id))
            sim_data.load(blacklist_data)

    def create_seeds_during_zone_spin_up(self):
        zone = services.current_zone()
        save_slot_proto = services.get_persistence_service(
        ).get_save_slot_proto_buff()
        self._arriving_situation_seed = SituationSeed.deserialize_travel_seed_from_slot(
            save_slot_proto)
        zone_proto = services.get_persistence_service().get_zone_proto_buff(
            zone.id)
        if zone_proto is not None:
            self._zone_seeds_for_zone_spinup = SituationSeed.deserialize_seeds_from_zone(
                zone_proto)
        open_street_proto = services.get_persistence_service(
        ).get_open_street_proto_buff(zone.open_street_id)
        if open_street_proto is not None:
            self._open_street_seeds_for_zone_spinup = SituationSeed.deserialize_seeds_from_open_street(
                open_street_proto)

    def get_arriving_seed_during_zone_spin(self):
        return self._arriving_situation_seed

    def get_zone_persisted_seeds_during_zone_spin_up(self):
        return list(self._zone_seeds_for_zone_spinup)

    def get_open_street_persisted_seeds_during_zone_spin_up(self):
        return list(self._open_street_seeds_for_zone_spinup)

    def create_situations_during_zone_spin_up(self):
        for seed in self._zone_seeds_for_zone_spinup:
            self.create_situation_from_seed(seed)
        for seed in self._open_street_seeds_for_zone_spinup:
            self.create_situation_from_seed(seed)
        self._create_system_situations()
        if self._arriving_situation_seed is not None:
            arrived_id = self.create_situation_from_seed(
                self._arriving_situation_seed)
            situation = self.get(arrived_id)
            if situation is not None:
                situation.on_arrived()

    def on_all_situations_created_during_zone_spin_up(self):
        self._bouncer.request_all_sims_during_zone_spin_up()

    def on_all_sims_spawned_during_zone_spin_up(self):
        self._bouncer.assign_all_sims_during_zone_spin_up()
        for situation in self.running_situations():
            if situation.should_time_jump():
                situation.on_time_jump()

    def on_hit_their_marks_during_zone_spin_up(self):
        self._bouncer.start_full_operations()

    def make_situation_seed_zone_director_requests(self):
        venue_service = services.current_zone().venue_service
        for seed in itertools.chain((self._arriving_situation_seed, ),
                                    self._zone_seeds_for_zone_spinup,
                                    self._open_street_seeds_for_zone_spinup):
            if seed is None:
                continue
            (zone_director,
             request_type) = seed.situation_type.get_zone_director_request()
            if not zone_director is None:
                if request_type is None:
                    continue
                if seed.is_loadable and not seed.situation_type.should_seed_be_loaded(
                        seed):
                    continue
                preserve_state = seed.is_loadable
                venue_service.request_zone_director(
                    zone_director, request_type, preserve_state=preserve_state)

    def get_sim_serialization_option(self, sim):
        result = sims.sim_info_types.SimSerializationOption.UNDECLARED
        for situation in self.get_situations_sim_is_in(sim):
            option = situation.situation_serialization_option
            if option == situations.situation_types.SituationSerializationOption.LOT:
                result = sims.sim_info_types.SimSerializationOption.LOT
                break
            elif option == situations.situation_types.SituationSerializationOption.OPEN_STREETS:
                result = sims.sim_info_types.SimSerializationOption.OPEN_STREETS
        return result

    def remove_sim_from_situation(self, sim, situation_id):
        situation = self.get(situation_id)
        if situation is None:
            return
        self._bouncer.remove_sim_from_situation(sim, situation)

    def on_sim_reset(self, sim):
        for situation in self.running_situations():
            if situation.is_sim_in_situation(sim):
                situation.on_sim_reset(sim)

    def on_begin_sim_creation_notification(self, sim):
        sim_data = self._sim_data.setdefault(sim.id,
                                             _SituationManagerSimData(sim.id))
        sim_data.set_created_time(services.time_service().sim_now)
        self._prune_sim_data()
        self._sim_being_created = sim

    def on_end_sim_creation_notification(self, sim):
        if sim.id in self._debug_sims:
            self._debug_sims.discard(sim.id)
            if self._perf_test_cheat_enabled:
                self.create_visit_situation_for_unexpected(sim)
            else:
                services.current_zone().venue_service.active_venue.summon_npcs(
                    (sim.sim_info, ), NPCSummoningPurpose.DEFAULT)
        self._bouncer._on_end_sim_creation_notification(sim)
        self._sim_being_created = None

    def get_situations_sim_is_in(self, sim):
        return [
            situation for situation in self.values()
            if situation.is_sim_in_situation(sim)
            if situation._stage == SituationStage.RUNNING
        ]

    def get_situations_sim_is_in_by_tag(self, sim, tag):
        return [
            situation for situation in self.get_situations_sim_is_in(sim)
            if tag in situation.tags
        ]

    def is_user_facing_situation_running(self, global_user_facing_only=False):
        for situation in self.values():
            if situation.is_user_facing:
                if not global_user_facing_only:
                    return True
                if situation.linked_sim_id == GLOBAL_SITUATION_LINKED_SIM_ID:
                    return True
        return False

    def get_user_facing_situations_gen(self):
        for situation in self.values():
            if situation.is_user_facing:
                yield situation

    def running_situations(self):
        return [
            obj for obj in self._objects.values()
            if obj._stage == SituationStage.RUNNING
        ]

    def is_situation_with_tags_running(self, tags):
        for situation in self.values():
            if situation._stage == SituationStage.RUNNING:
                if situation.tags & tags:
                    return True
        return False

    def user_ask_sim_to_leave_now_must_run(self, sim):
        if not sim.sim_info.is_npc or sim.sim_info.lives_here:
            return
        ask_to_leave = True
        for situation in self.get_situations_sim_is_in(sim):
            if not situation.on_ask_sim_to_leave(sim):
                ask_to_leave = False
                break
        if ask_to_leave:
            self.make_sim_leave_now_must_run(sim)

    def make_sim_leave_now_must_run(self, sim):
        if services.current_zone().is_zone_shutting_down:
            return
        for situation in self.get_situations_sim_is_in(sim):
            if type(situation) is self.DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION:
                return
        leave_now_type = self.DEFAULT_LEAVE_NOW_MUST_RUN_SITUATION
        guest_list = situations.situation_guest_list.SituationGuestList(
            invite_only=True)
        guest_info = situations.situation_guest_list.SituationGuestInfo(
            sim.id,
            leave_now_type.default_job(),
            RequestSpawningOption.CANNOT_SPAWN,
            BouncerRequestPriority.EVENT_VIP,
            expectation_preference=True)
        guest_list.add_guest_info(guest_info)
        self.create_situation(leave_now_type,
                              guest_list=guest_list,
                              user_facing=False)

    def is_sim_ss3_safe(self, sim):
        for situation in self.get_situations_sim_is_in(sim):
            if not situation.should_send_on_lot_home_in_super_speed_3:
                return False
        return True

    def ss3_make_all_npcs_leave_now(self):
        sim_info_manager = services.sim_info_manager()
        current_zone_id = services.current_zone_id()
        for sim in sim_info_manager.instanced_sims_gen():
            if not sim.is_npc:
                continue
            if sim.is_on_active_lot() and not self.is_sim_ss3_safe(sim):
                continue
            if sim.sim_info.vacation_or_home_zone_id == current_zone_id:
                continue
            sim.add_buff(
                buff_type=self.SUPER_SPEED_THREE_REQUEST_BUFF.buff_type,
                buff_reason=self.SUPER_SPEED_THREE_REQUEST_BUFF.buff_reason)
            self.make_sim_leave_now_must_run(sim)

    def make_sim_leave(self, sim):
        leave_situation = self.get(self._leave_situation_id)
        if leave_situation is None:
            logger.error(
                'The leave situation is missing. Making the sim leave now must run.'
            )
            self.make_sim_leave_now_must_run(sim)
            return
        leave_situation.invite_sim_to_leave(sim)

    def expedite_leaving(self):
        leave_situation = self.get(self._leave_situation_id)
        if leave_situation is None:
            return
        for sim in leave_situation.all_sims_in_situation_gen():
            self.make_sim_leave_now_must_run(sim)

    def get_time_span_sim_has_been_on_lot(self, sim):
        sim_data = self._sim_data.get(sim.id)
        if sim_data is None:
            return
        if sim_data.created_time is None:
            return
        return services.time_service().sim_now - sim_data.created_time

    def get_blacklist_info(self, sim_id):
        sim_data = self._sim_data.get(sim_id)
        if sim_data is None:
            return
        return sim_data.get_blacklist_info()

    def get_auto_fill_blacklist(self, sim_job=None):
        blacklist = set()
        for (sim_id, sim_data) in tuple(self._sim_data.items()):
            if sim_data.is_blacklisted(sim_job=sim_job):
                blacklist.add(sim_id)
        return blacklist

    def add_sim_to_auto_fill_blacklist(self,
                                       sim_id,
                                       sim_job=None,
                                       blacklist_all_jobs_time=None):
        sim_data = self._sim_data.setdefault(sim_id,
                                             _SituationManagerSimData(sim_id))
        sim_data.blacklist(sim_job,
                           blacklist_all_jobs_time=blacklist_all_jobs_time)
        self._prune_sim_data()

    def remove_sim_from_auto_fill_blacklist(self, sim_id, sim_job=None):
        sim_data = self._sim_data.get(sim_id)
        if sim_data is not None:
            sim_data.whitelist(sim_job=sim_job)
        self._prune_sim_data()

    def send_situation_start_ui(self,
                                actor,
                                target=None,
                                situations_available=None,
                                creation_time=None):
        msg = Situations_pb2.SituationPrepare()
        msg.situation_session_id = self.get_new_situation_creation_session()
        msg.creation_time = creation_time if creation_time is not None else 0
        msg.sim_id = actor.id
        if target is not None:
            msg.is_targeted = True
            msg.target_id = target.id
        if situations_available is not None:
            for situation in situations_available:
                msg.situation_resource_id.append(situation.guid64)
        shared_messages.add_message_if_selectable(
            actor, Consts_pb2.MSG_SITUATION_PREPARE, msg, True)

    def _prune_sim_data(self):
        to_remove_ids = []
        for (sim_id, sim_data) in self._sim_data.items():
            sim_info = services.sim_info_manager().get(sim_id)
            if not sim_info is None:
                if not sim_info.is_instanced(
                        allow_hidden_flags=ALL_HIDDEN_REASONS):
                    if sim_data.is_blacklisted == False:
                        to_remove_ids.append(sim_id)
            if sim_data.is_blacklisted == False:
                to_remove_ids.append(sim_id)
        for sim_id in to_remove_ids:
            del self._sim_data[sim_id]

    def _issue_callback(self, situation_id, callback_option, data):
        self._callbacks[situation_id][callback_option](situation_id,
                                                       callback_option, data)

    def _send_create_situation_telemetry(self, situation_type, situation_id,
                                         guest_list, hire_cost, zone_id):
        if hasattr(situation_type, 'guid64'):
            with telemetry_helper.begin_hook(
                    writer, TELEMETRY_HOOK_CREATE_SITUATION) as hook:
                hook.write_int('situ', situation_id)
                hook.write_int('host', guest_list.host_sim_id)
                hook.write_guid('type', situation_type.guid64)
                hook.write_bool('invi', guest_list.invite_only)
                hook.write_bool('hire', hire_cost)
                hook.write_bool(
                    'nzon', zone_id != 0
                    and services.current_zone().id != zone_id)
            sim_info_manager = services.sim_info_manager()
            if sim_info_manager is not None:
                for guest_infos in guest_list._job_type_to_guest_infos.values(
                ):
                    for guest_info in guest_infos:
                        if guest_info.sim_id == 0:
                            continue
                        guest_sim = sim_info_manager.get(guest_info.sim_id)
                        if guest_sim is None:
                            continue
                        client = services.client_manager(
                        ).get_client_by_household_id(guest_sim.household_id)
                        with telemetry_helper.begin_hook(
                                writer, TELEMETRY_HOOK_GUEST) as hook:
                            hook.write_int('situ', situation_id)
                            hook.write_guid('type', situation_type.guid64)
                            if client is None:
                                hook.write_int('npcg', guest_info.sim_id)
                            else:
                                hook.write_int('pcgu', guest_info.sim_id)
                                hook.write_guid('jobb',
                                                guest_info.job_type.guid64)
예제 #13
0
class ZoneDirectorApb(CareerEventZoneDirectorProxy):
    INSTANCE_TUNABLES = {'detective_career': DetectiveCareer.TunableReference(description='\n            The career that we want to use to spawn the criminal.\n            ', tuning_group=GroupNames.CAREER), 'apb_situation': Situation.TunableReference(description='\n            The situation controlling the APB. This will manage the criminal Sim\n            as well as all the decoys.\n            ', tuning_group=GroupNames.CAREER), 'apb_neutral_situation': Situation.TunableReference(description='\n            The situation controlling all Sims in the zone, including Sims in\n            the APB situation.\n            ', tuning_group=GroupNames.CAREER), 'apb_situation_job_detective': SituationJob.TunableReference(description='\n            The job that the detective is put into for the duration of the APB.\n            ', tuning_group=GroupNames.CAREER), 'apb_situation_job_decoy': SituationJob.TunableReference(description='\n            The job that the decoys are put into for the duration of the APB.\n            ', tuning_group=GroupNames.CAREER), 'apb_situation_job_criminal': SituationJob.TunableReference(description='\n            The job that the criminal is put into for the duration of the APB.\n            ', tuning_group=GroupNames.CAREER)}

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._persisted_decoy_sim_ids = None
        self._apb_situation_id = None

    def create_situations_during_zone_spin_up(self):
        sim_info = self._career_event.sim_info
        career = sim_info.careers.get(self.detective_career.guid64)
        if career is not None:
            situation_manager = services.get_zone_situation_manager()
            situation_manager.create_situation(self.apb_neutral_situation, user_facing=False, creation_source=self.instance_name)
            guest_list = SituationGuestList(invite_only=True, filter_requesting_sim_id=sim_info.sim_id)
            if not career.active_criminal_sim_id:
                career.create_criminal_fixup()
            guest_list.add_guest_info(SituationGuestInfo(career.active_criminal_sim_id, self.apb_situation_job_criminal, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP))
            guest_list.add_guest_info(SituationGuestInfo(sim_info.sim_id, self.apb_situation_job_detective, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP))
            decoy_sim_ids = career.get_decoy_sim_ids_for_apb(persisted_sim_ids=self._persisted_decoy_sim_ids)
            for decoy in decoy_sim_ids:
                guest_list.add_guest_info(SituationGuestInfo(decoy, self.apb_situation_job_decoy, RequestSpawningOption.DONT_CARE, BouncerRequestPriority.EVENT_VIP))
            self._persisted_decoy_sim_ids = None
            self._apb_situation_id = situation_manager.create_situation(self.apb_situation, guest_list=guest_list, spawn_sims_during_zone_spin_up=True, user_facing=False, creation_source=self.instance_name)
            with telemetry_helper.begin_hook(detective_apb_telemetry_writer, TELEMETRY_HOOK_APB_CALL, sim_info=sim_info) as hook:
                hook.write_int(TELEMETRY_CLUES_FOUND, len(career.get_discovered_clues()))
        return super().create_situations_during_zone_spin_up()

    def _load_custom_zone_director(self, zone_director_proto, reader):
        super()._load_custom_zone_director(zone_director_proto, reader)
        if reader is not None:
            self._persisted_decoy_sim_ids = reader.read_uint64s(DECOY_SIM_IDS, ())

    def _save_custom_zone_director(self, zone_director_proto, writer):
        super()._save_custom_zone_director(zone_director_proto, writer)
        situation_manager = services.get_zone_situation_manager()
        apb_situation = situation_manager.get(self._apb_situation_id)
        if apb_situation is not None:
            sim_ids = (sim.id for sim in apb_situation.all_sims_in_job_gen(self.apb_situation_job_decoy))
            writer.write_uint64s(DECOY_SIM_IDS, sim_ids)
예제 #14
0
class CreateAndAddToSituation(HasTunableSingletonFactory, AutoFactoryInit):

    @staticmethod
    def _verify_tunable_callback(instance_class, tunable_name, source, value):
        if value.situation_job is not None:
            jobs = value.situation_to_create.get_tuned_jobs()
            if value.situation_job not in jobs:
                logger.error('CreateAndAddToSituation {} references a job {} that is not tuned in the situation {}.', source, value.situation_job, value.situation_to_create, owner='manus')
        elif value.situation_to_create.default_job() is None:
            logger.error('CreateAndAddToSituation {} references a situation {} \n                without referencing a job and the situation does not have a default job.\n                Either tune a default job on the situation or tune a job reference\n                here.', source, value.situation_to_create, owner='sscholl')

    FACTORY_TUNABLES = {'description': 'Create a new situation of this type and add the NPC to its tuned job.', 'situation_to_create': Situation.TunableReference(pack_safe=True), 'situation_job': SituationJob.TunableReference(description="\n            The situation job to assign the sim to. If set to None\n            the sim will be assigned to the situation's default job.\n            ", allow_none=True, pack_safe=True), 'verify_tunable_callback': _verify_tunable_callback}

    def __call__(self, all_sim_infos, purpose=None, host_sim_info=None):
        host_sim_id = host_sim_info.sim_id if host_sim_info is not None else 0
        situation_job = self.situation_job if self.situation_job is not None else self.situation_to_create.default_job()

        def _create_situation(sim_infos):
            guest_list = SituationGuestList(invite_only=True, host_sim_id=host_sim_id)
            for sim_info in sim_infos:
                guest_info = situation_guest_list.SituationGuestInfo.construct_from_purpose(sim_info.sim_id, situation_job, situation_guest_list.SituationInvitationPurpose.INVITED)
                guest_list.add_guest_info(guest_info)
            services.get_zone_situation_manager().create_situation(self.situation_to_create, guest_list=guest_list, user_facing=False)

        if self.situation_to_create.supports_multiple_sims:
            _create_situation(all_sim_infos)
        else:
            for one_sim_info in all_sim_infos:
                _create_situation((one_sim_info,))
class EveryoneTakeATurnOnceSituation(SituationComplexCommon):
    INSTANCE_TUNABLES = {
        'gather_together_state':
        GatherTogetherState.TunableFactory(
            description=
            '\n            The state of the situation when the situation first starts,\n            which lasts until every sim is in place and ready to take a turn.\n            ',
            tuning_group=GroupNames.STATE),
        'taking_turns_state':
        TakingTurnsState.TunableFactory(
            description=
            '\n            The state that means all Sims have gathered and are taking turns.\n            ',
            tuning_group=GroupNames.STATE),
        'job_and_role_state':
        TunableSituationJobAndRoleState(
            description='\n            Job and Role State.\n            '),
        'sim_took_turn_buff':
        Buff.TunableReference(
            description=
            '\n            The buff that is on a Sim that has already taken a turn.\n            '
        ),
        'sub_situation':
        Situation.TunableReference(
            description=
            '\n            Each participating Sim will in their own instance of this situation.\n            ',
            class_restrictions=('EveryoneTakeATurnOnceSubSituation', ))
    }
    REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._guest_sub_situation_dict = {}
        self.gathering_sim_ids = set()
        self._ready_sim_ids = set()
        self.target_object = self._get_target_object()

    def _get_target_object(self):
        target_object = None
        default_target_id = self._seed.extra_kwargs.get(
            'default_target_id', None)
        if default_target_id is not None:
            target_object = services.object_manager().get(default_target_id)
        return target_object

    def _get_sub_situations(self):
        sub_situations = set()
        situation_manager = services.get_zone_situation_manager()
        if situation_manager is None:
            return sub_situations
        for situation_id in self._guest_sub_situation_dict.values():
            situation = situation_manager.get(situation_id)
            if situation is not None:
                sub_situations.add(situation)
        return sub_situations

    @classmethod
    def default_job(cls):
        return cls.job_and_role_state.job

    @classmethod
    def _states(cls):
        return [
            SituationStateData(1,
                               GatherTogetherState,
                               factory=cls.gather_together_state),
            SituationStateData(2,
                               TakingTurnsState,
                               factory=cls.taking_turns_state)
        ]

    @classmethod
    def _get_tuned_job_and_default_role_state_tuples(cls):
        return [(cls.job_and_role_state.job, cls.job_and_role_state.role_state)
                ]

    def _on_set_sim_job(self, sim, job_type):
        super()._on_set_sim_job(sim, job_type)
        situation_manager = services.get_zone_situation_manager()
        guest_list = SituationGuestList(invite_only=True)
        guest_list.add_guest_info(
            SituationGuestInfo(sim.sim_id,
                               self.sub_situation.job_and_role_state.job,
                               RequestSpawningOption.DONT_CARE,
                               BouncerRequestPriority.EVENT_VIP))
        sub_situation_id = situation_manager.create_situation(
            self.sub_situation,
            guest_list=guest_list,
            background_situation_id=self.id,
            user_facing=False)
        self._guest_sub_situation_dict[sim.id] = sub_situation_id
        self.gathering_sim_ids.add(sim.id)

    def _get_sub_situation_for_sim_id(self, sim_id):
        sub_situation = None
        sub_situation_id = self._guest_sub_situation_dict.get(sim_id, None)
        if sub_situation_id is not None:
            situation_manager = services.get_zone_situation_manager()
            if situation_manager is not None:
                sub_situation = situation_manager.get(sub_situation_id)
        return sub_situation

    def _on_remove_sim_from_situation(self, sim):
        super()._on_remove_sim_from_situation(sim)
        self.gathering_sim_ids.discard(sim.id)
        sub_situation = self._get_sub_situation_for_sim_id(sim.id)
        if sub_situation is not None:
            situation_manager = services.get_zone_situation_manager()
            situation_manager.destroy_situation_by_id(sub_situation.id)
        self._guest_sub_situation_dict.pop(sim.id, None)

    def _destroy(self):
        self._cleanup_sub_situations()
        super()._destroy()

    def start_situation(self):
        super().start_situation()
        self._change_state(self.gather_together_state())

    def set_sim_as_ready(self, sim_info):
        if sim_info is not None:
            self.gathering_sim_ids.discard(sim_info.id)
            if not sim_info.has_buff(self.sim_took_turn_buff.buff_type):
                self._ready_sim_ids.add(sim_info.id)

    def do_next_turn(self, set_others_waiting=False):
        if self._ready_sim_ids:
            sim_id = self._ready_sim_ids.pop()
            sub_situation = self._get_sub_situation_for_sim_id(sim_id)
            if sub_situation is not None:
                if self._ready_sim_ids:
                    if set_others_waiting:
                        for waiting_sims_id in self._ready_sim_ids:
                            waiting_sub_situation = self._get_sub_situation_for_sim_id(
                                waiting_sims_id)
                            if waiting_sub_situation is not None:
                                waiting_sub_situation.wait_for_turn()
                    sub_situation.take_turn()
                else:
                    sub_situation.take_last_turn()
                return
        self._self_destruct()

    def cleanup_expired_sims(self):
        sim_info_manager = services.sim_info_manager()
        for sim_id in tuple(self.gathering_sim_ids):
            sim_info = sim_info_manager.get(sim_id)
            if sim_info is not None:
                sim = sim_info.get_sim_instance()
                if sim is not None:
                    if self.is_sim_in_situation(sim):
                        self.remove_sim_from_situation(sim)

    def _cleanup_sub_situations(self):
        for situation in self._get_sub_situations():
            if situation is not None:
                situation._self_destruct()
class CafeGenericBackgroundSituation(SituationComplexCommon):
    INSTANCE_TUNABLES = {'generic_sim_job': TunableSituationJobAndRoleState(description="\n            A job and role state that essentially does nothing but filter out\n            Sims that shouldn't be placed in the generic cafe sim situation.\n            "), 'cafe_generic_customer_situation': Situation.TunableReference(description='\n            The individual, generic cafe customer situation we want to use for\n            Sims that show up at the Cafe so they can go get coffee.\n            ', class_restrictions=('CafeGenericCustomerSituation',))}
    REMOVE_INSTANCE_TUNABLES = Situation.NON_USER_FACING_REMOVE_INSTANCE_TUNABLES

    @classmethod
    def _states(cls):
        return (SituationStateData(1, _CafeGenericState),)

    @classmethod
    def _get_tuned_job_and_default_role_state_tuples(cls):
        return [(cls.generic_sim_job.job, cls.generic_sim_job.role_state)]

    @classmethod
    def default_job(cls):
        return cls.generic_sim_job.job

    def start_situation(self):
        super().start_situation()
        self._change_state(_CafeGenericState())

    def _issue_requests(self):
        request = BouncerRequestFactory(self, callback_data=_RequestUserData(role_state_type=self.generic_sim_job.role_state), job_type=self.generic_sim_job.job, request_priority=BouncerRequestPriority.BACKGROUND_MEDIUM, user_facing=False, exclusivity=self.exclusivity)
        self.manager.bouncer.submit_request(request)

    def _on_set_sim_job(self, sim, job_type):
        super()._on_set_sim_job(sim, job_type)
        situation_manager = services.get_zone_situation_manager()
        guest_list = SituationGuestList(invite_only=True)
        guest_info = SituationGuestInfo(sim.sim_info.id, self.cafe_generic_customer_situation.default_job(), RequestSpawningOption.DONT_CARE, BouncerRequestPriority.BACKGROUND_MEDIUM)
        guest_list.add_guest_info(guest_info)
        situation_manager.create_situation(self.cafe_generic_customer_situation, guest_list=guest_list, user_facing=False)
예제 #17
0
class Venue(metaclass=HashedTunedInstanceMetaclass,
            manager=services.get_instance_manager(sims4.resources.Types.VENUE)
            ):
    __qualname__ = 'Venue'
    INSTANCE_TUNABLES = {
        'display_name':
        TunableLocalizedString(
            description=
            '\n            Name that will be displayed for the venue\n            ',
            export_modes=ExportModes.All),
        'display_name_incomplete':
        TunableLocalizedString(
            description=
            '\n            Name that will be displayed for the incomplete venue\n            ',
            export_modes=ExportModes.All),
        'venue_description':
        TunableLocalizedString(
            description='Description of Venue that will be displayed',
            export_modes=ExportModes.All),
        'venue_icon':
        TunableResourceKey(None,
                           resource_types=sims4.resources.CompoundTypes.IMAGE,
                           description='Venue Icon for UI',
                           export_modes=ExportModes.All),
        'venue_thumbnail':
        TunableResourceKey(None,
                           resource_types=sims4.resources.CompoundTypes.IMAGE,
                           description='Image of Venue that will be displayed',
                           export_modes=ExportModes.All),
        'allow_game_triggered_events':
        Tunable(
            description=
            '\n            Whether this venue can have game triggered events. ex for careers\n            ',
            tunable_type=bool,
            default=False),
        'background_event_schedule':
        TunableSituationWeeklyScheduleFactory(
            description=
            '\n            The Background Events that run on this venue. They run underneath\n            any user facing Situations and there can only be one at a time. The\n            schedule times and durations are windows in which background events\n            can start.\n            '
        ),
        'special_event_schedule':
        TunableSituationWeeklyScheduleFactory(
            description=
            '\n            The Special Events that run on this venue. These run on top of\n            Background Events. We run only one user facing event at a time, so\n            if the player started something then this may run in the\n            background, otherwise the player will be invited to join in on this\n            Venue Special Event.\n            '
        ),
        'required_objects':
        TunableList(
            description=
            '\n            A list of objects that are required to be on a lot before\n            that lot can be labeled as this venue.\n            ',
            tunable=TunableVenueObject(
                description=
                "\n                    Specify object tag(s) that must be on this venue.\n                    Allows you to group objects, i.e. weight bench,\n                    treadmill, and basketball goals are tagged as\n                    'exercise objects.'\n                    \n                    This is not the same as automatic objects tuning. \n                    Please read comments for both the fields.\n                    "
            ),
            export_modes=ExportModes.All),
        'npc_summoning_behavior':
        sims4.tuning.tunable.TunableMapping(
            description=
            '\n            Whenever an NPC is summoned to a lot by the player, determine\n            which action to take based on the summoning purpose. The purpose\n            is a dynamic enum: venues.venue_constants.NPCSummoningPurpose.\n            \n            The action will generally involve either adding a sim to an existing\n            situation or creating a situation then adding them to it.\n            \n            \\depot\\Sims4Projects\\Docs\\Design\\Open Streets\\Open Street Invite Matrix.xlsx\n            \n            residential: This is behavior pushed on the NPC if this venue was a residential lot.\n            create_situation: Place the NPC in the specified situation/job pair.\n            add_to_background_situation: Add the NPC the currently running background \n            situation in the venue.\n            ',
            key_type=sims4.tuning.tunable.TunableEnumEntry(
                venues.venue_constants.NPCSummoningPurpose,
                venues.venue_constants.NPCSummoningPurpose.DEFAULT),
            value_type=TunableVariant(
                locked_args={'disabled': None},
                residential=ResidentialLotArrivalBehavior.TunableFactory(),
                create_situation=CreateAndAddToSituation.TunableFactory(),
                add_to_background_situation=AddToBackgroundSituation.
                TunableFactory(),
                default='disabled'),
            tuning_group=GroupNames.TRIGGERS),
        'player_requires_visitation_rights':
        OptionalTunable(
            description=
            'If enabled, then lots of this venue type  \n            will require player Sims that are not on their home lot to go through \n            the process of being greeted before they are\n            given full rights to using the lot.\n            ',
            tunable=TunableTuple(
                ungreeted=Situation.TunableReference(
                    description=
                    '\n                    The situation to create for ungreeted player sims on this lot.',
                    display_name='Player Ungreeted Situation'),
                greeted=Situation
                .TunableReference(
                    description=
                    '\n                    The situation to create for greeted player sims on this lot.',
                    display_name='Player Greeted Situation'))),
        'zone_fixup':
        TunableVariant(
            description=
            '\n            Specify what to do with a non resident NPC\n            when the zone has to be fixed up on load. \n            This fix up will occur if sim time or the\n            active household has changed since the zone was last saved.\n            ',
            residential=ResidentialZoneFixupForNPC.TunableFactory(),
            create_situation=CreateAndAddToSituation.TunableFactory(),
            add_to_background_situation=AddToBackgroundSituation.
            TunableFactory(),
            default='residential',
            tuning_group=GroupNames.SPECIAL_CASES),
        'travel_interaction_name':
        TunableVariant(
            description=
            '\n            Specify what name a travel interaction gets when this Venue is an\n            adjacent lot.\n            ',
            visit_residential=ResidentialTravelDisplayName.TunableFactory(
                description=
                '\n                The interaction name for when the destination lot is a\n                residence.\n                '
            ),
            visit_venue=TunableLocalizedStringFactory(
                description=
                '\n                The interaction name for when the destination lot is a\n                commercial venue.\n                Tokens: 0:ActorSim\n                Example: "Visit The Bar"\n                '
            ),
            tuning_group=GroupNames.SPECIAL_CASES),
        'travel_with_interaction_name':
        TunableVariant(
            description=
            '\n            Specify what name a travel interaction gets when this Venue is an\n            adjacent lot.\n            ',
            visit_residential=ResidentialTravelDisplayName.TunableFactory(
                description=
                '\n                The interaction name for when the destination lot is a\n                residence and the actor Sim is traveling with someone.\n                '
            ),
            visit_venue=TunableLocalizedStringFactory(
                description=
                '\n                The interaction name for when the destination lot is a\n                commercial venue and the actor is traveling with someone.\n                Tokens: 0:ActorSim\n                Example: "Visit The Bar With..."\n                '
            ),
            tuning_group=GroupNames.SPECIAL_CASES),
        'venue_requires_front_door':
        Tunable(
            description=
            '\n            True if this venue should run the front door generation code. \n            If it runs, venue will have the ring doorbell interaction and \n            its additional behavior.\n            ',
            tunable_type=bool,
            default=False),
        'automatic_objects':
        TunableList(
            description=
            '\n            A list of objects that is required to exist on this venue (e.g. the\n            mailbox). If any of these objects are missing from this venue, they\n            will be auto-placed on zone load.',
            tunable=TunableTuple(
                description=
                "\n                An item that is required to be present on this venue. The object's tag \n                will be used to determine if any similar objects are present. If no \n                similar objects are present, then the object's actual definition is used to \n                create an object of this type.\n                \n                This is not the same as required objects tuning. Please read comments \n                for both the fields.\n                \n                E.g. To require a mailbox to be present on a lot, tune a hypothetical basicMailbox \n                here. The code will not trigger as long as a basicMailbox, fancyMailbox, or \n                cheapMailbox are present on the lot. If none of them are, then a basicMailbox \n                will be automatically created.\n                ",
                default_value=TunableReference(
                    manager=services.definition_manager(),
                    description=
                    'The default object to use if no suitably tagged object is present on the lot.'
                ),
                tag=TunableEnumEntry(description='The tag to search for',
                                     tunable_type=tag.Tag,
                                     default=tag.Tag.INVALID))),
        'hide_from_buildbuy_ui':
        Tunable(
            description=
            '\n            If True, this venue type will not be available in the venue picker\n            in build/buy.\n            ',
            tunable_type=bool,
            default=False,
            export_modes=ExportModes.All),
        'allows_fire':
        Tunable(
            description=
            '\n            If True a fire can happen on this venue, \n            otherwise fires will not spawn on this venue.\n            ',
            tunable_type=bool,
            default=False),
        'allow_rolestate_routing_on_navmesh':
        Tunable(
            description=
            '\n            Allow all RoleStates routing permission on lot navmeshes of this\n            venue type. This is particularly useful for outdoor venue types\n            (lots with no walls), where it is awkward to have to "invite a sim\n            in" before they may route on the lot, be called over, etc.\n            \n            This tunable overrides the "Allow Npc Routing On Active Lot"\n            tunable of individual RoleStates.\n            ',
            tunable_type=bool,
            default=False)
    }

    @classmethod
    def _verify_tuning_callback(cls):
        if cls.special_event_schedule is not None:
            for entry in cls.special_event_schedule.schedule_entries:
                while entry.situation.venue_situation_player_job is None:
                    logger.error(
                        'Venue Situation Player Job {} tuned in Situation: {}',
                        entry.situation.venue_situation_player_job,
                        entry.situation)

    def __init__(self, **kwargs):
        self._active_background_event_id = None
        self._active_special_event_id = None
        self._background_event_schedule = None
        self._special_event_schedule = None

    def set_active_event_ids(self,
                             background_event_id=None,
                             special_event_id=None):
        self._active_background_event_id = background_event_id
        self._active_special_event_id = special_event_id

    @property
    def active_background_event_id(self):
        return self._active_background_event_id

    @property
    def active_special_event_id(self):
        return self._active_special_event_id

    def schedule_background_events(self, schedule_immediate=True):
        self._background_event_schedule = self.background_event_schedule(
            start_callback=self._start_background_event,
            schedule_immediate=False)
        if schedule_immediate:
            (
                best_time_span, best_data_list
            ) = self._background_event_schedule.time_until_next_scheduled_event(
                services.time_service().sim_now, schedule_immediate=True)
            if best_time_span is not None and best_time_span == date_and_time.TimeSpan.ZERO:
                while True:
                    for best_data in best_data_list:
                        self._start_background_event(
                            self._background_event_schedule, best_data)

    def schedule_special_events(self, schedule_immediate=True):
        self._special_event_schedule = self.special_event_schedule(
            start_callback=self._try_start_special_event,
            schedule_immediate=schedule_immediate)

    def _start_background_event(self, scheduler, alarm_data, extra_data=None):
        entry = alarm_data.entry
        situation = entry.situation
        situation_manager = services.get_zone_situation_manager()
        if self._active_background_event_id is not None and self._active_background_event_id in situation_manager:
            situation_manager.destroy_situation_by_id(
                self._active_background_event_id)
        situation_id = services.get_zone_situation_manager().create_situation(
            situation, user_facing=False, spawn_sims_during_zone_spin_up=True)
        self._active_background_event_id = situation_id

    def _try_start_special_event(self, scheduler, alarm_data, extra_data):
        entry = alarm_data.entry
        situation = entry.situation
        situation_manager = services.get_zone_situation_manager()
        if self._active_special_event_id is None:
            client_manager = services.client_manager()
            client = next(iter(client_manager.values()))
            invited_sim = client.active_sim
            active_sim_available = situation.is_situation_available(
                invited_sim)

            def _start_special_event(dialog):
                guest_list = None
                if dialog.accepted:
                    start_user_facing = True
                    guest_list = SituationGuestList()
                    guest_info = SituationGuestInfo.construct_from_purpose(
                        invited_sim.id, situation.venue_situation_player_job,
                        SituationInvitationPurpose.INVITED)
                    guest_list.add_guest_info(guest_info)
                else:
                    start_user_facing = False
                situation_id = situation_manager.create_situation(
                    situation,
                    guest_list=guest_list,
                    user_facing=start_user_facing)
                self._active_special_event_id = situation_id

            if not situation_manager.is_user_facing_situation_running(
            ) and active_sim_available:
                dialog = situation.venue_invitation_message(
                    invited_sim, SingleSimResolver(invited_sim))
                dialog.show_dialog(
                    on_response=_start_special_event,
                    additional_tokens=(
                        situation.display_name,
                        situation.venue_situation_player_job.display_name))
            else:
                situation_id = situation_manager.create_situation(
                    situation, user_facing=False)
                self._active_special_event_id = situation_id

    def shut_down(self):
        if self._background_event_schedule is not None:
            self._background_event_schedule.destroy()
        if self._special_event_schedule is not None:
            self._special_event_schedule.destroy()
        situation_manager = services.get_zone_situation_manager()
        if self._active_background_event_id is not None:
            situation_manager.destroy_situation_by_id(
                self._active_background_event_id)
            self._active_background_event_id = None
        if self._active_special_event_id is not None:
            situation_manager.destroy_situation_by_id(
                self._active_special_event_id)
            self._active_special_event_id = None

    @classmethod
    def lot_has_required_venue_objects(cls, lot):
        failure_reasons = []
        for required_object_tuning in cls.required_objects:
            object_test = required_object_tuning.object
            object_list = object_test()
            num_objects = len(object_list)
            while num_objects < required_object_tuning.number:
                pass
        failure_message = None
        failure = len(failure_reasons) > 0
        if failure:
            failure_message = ''
            for message in failure_reasons:
                failure_message += message + '\n'
        return (not failure, failure_message)

    def summon_npcs(self, npc_infos, purpose, host_sim_info=None):
        if self.npc_summoning_behavior is None:
            return
        summon_behavior = self.npc_summoning_behavior.get(purpose)
        if summon_behavior is None:
            summon_behavior = self.npc_summoning_behavior.get(
                venues.venue_constants.NPCSummoningPurpose.DEFAULT)
            if summon_behavior is None:
                return
        summon_behavior(npc_infos, host_sim_info)

    @classproperty
    def requires_visitation_rights(cls):
        return cls.player_requires_visitation_rights is not None

    @classproperty
    def player_ungreeted_situation_type(cls):
        if cls.player_requires_visitation_rights is None:
            return
        return cls.player_requires_visitation_rights.ungreeted

    @classproperty
    def player_greeted_situation_type(cls):
        if cls.player_requires_visitation_rights is None:
            return
        return cls.player_requires_visitation_rights.greeted