def populate_community_board_op(self, sim_info, op, target_id): op.sim_id = sim_info.id op.target_id = target_id op.influence_points = self.get_influence(sim_info) op.title = self.community_board_dialog_title() if hasattr(op, 'schedule_text'): op.schedule_text = self.get_schedule_text() for policy in self._enacted_policies: with ProtocolBufferRollback(op.enacted_policies) as enacted_policy: enacted_policy.policy_id = policy.guid64 if policy in self._up_for_repeal_policies: if policy.vote_count_statistic is None: enacted_policy.count = 0 else: enacted_policy.count = int(self.get_stat_value(policy.vote_count_statistic)) for policy in self._balloted_policies: with ProtocolBufferRollback(op.balloted_policies) as balloted_policy: balloted_policy.policy_id = policy.guid64 stat = policy.vote_count_statistic if stat is None: balloted_policy.count = 0 else: balloted_policy.count = int(self.get_stat_value(stat)) balloted_policy.max_count = stat.max_value op.provider_type = self.provider_type_id op.new_policy_allowed = self.is_new_policy_allowed(sim_info) if not services.street_service().voting_open: op.policy_disabled_tooltip = self.COMMUNITY_BOARD_TEXT.voting_closed_policy_tooltip_text() if not self.is_eligible_voter(sim_info): op.disabled_tooltip = self.COMMUNITY_BOARD_TEXT.ineligible_voter_confirm_tooltip_text(sim_info) op.policy_disabled_tooltip = self.COMMUNITY_BOARD_TEXT.ineligible_voter_policy_tooltip_text(sim_info)
def __call__(self, test_targets=None): if not self.gameplay_option.supporting_pack_installed: return TestResult(False, '{} option missing required pack', self.gameplay_option, self.tooltip) value = None if self.gameplay_option == TestableGameOptions.CIVIC_POLICY_NPC_VOTING_ENABLED or self.gameplay_option == TestableGameOptions.ECO_FOOTPRINT_GAMEPLAY: street_service = services.street_service() if street_service is not None: if self.gameplay_option == TestableGameOptions.CIVIC_POLICY_NPC_VOTING_ENABLED: value = street_service.enable_automatic_voting else: value = street_service.enable_eco_footprint if value is None: return TestResult(False, 'game option {} is unknown in current pack', self.gameplay_option, tooltip=self.tooltip) if self.invert: if value: return TestResult(False, 'test negated, game option {} is set to {}', self.gameplay_option, value, tooltip=self.tooltip) elif not value: return TestResult(False, 'game option {} is set to {}', self.gameplay_option, value, tooltip=self.tooltip) return TestResult.TRUE
def buildbuy_session_end(zone_id): services.object_manager( zone_id).rebuild_objects_to_ignore_portal_validation_cache() for obj in services.object_manager(zone_id).get_all(): obj.on_buildbuy_exit() posture_graph_service = services.current_zone().posture_graph_service posture_graph_service.on_exit_buildbuy() _build_buy_exit_callbacks() pythonutils.try_highwater_gc() services.get_zone_modifier_service( ).check_for_and_apply_new_zone_modifiers(zone_id) if _sync_venue_service_to_zone_venue_type(zone_id): zone_director = services.venue_service().get_zone_director() if zone_director is not None: zone_director.on_exit_buildbuy() object_preference_tracker = services.object_preference_tracker() if object_preference_tracker is not None: object_preference_tracker.validate_objects(zone_id) services.business_service().on_build_buy_exit() services.current_zone().on_build_buy_exit() services.utilities_manager().on_build_buy_exit() services.get_reset_and_delete_service().on_build_buy_exit() street_service = services.street_service() if street_service is not None: street = services.current_street() if street is not None: provider = street_service.get_provider(street) if provider is not None: provider.on_build_buy_exit() services.object_manager().clear_objects_to_ignore_portal_validation_cache()
def is_eligible_voter(self, sim_info): household = sim_info.household if household is None: return False street = services.street_service().get_street(self) return street is world.street.get_street_instance_from_world_id( household.get_home_world_id())
def handle_community_board(community_board_response: str, _connection=None): proto = UI_pb2.CommunityBoardResponse() text_format.Merge(community_board_response, proto) sim_info = services.sim_info_manager().get(proto.sim_id) if sim_info is None: return if proto.provider_type == StreetProvider.provider_type_id: street_civic_policy_service = services.street_service() if street_civic_policy_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return world_id = sim_info.household.get_home_world_id() street = world.street.get_street_instance_from_world_id(world_id) provider = street_civic_policy_service.get_provider(street) else: source_venue = services.venue_service().source_venue if source_venue is None: return provider = source_venue.civic_policy_provider if provider is not None: for policy in proto.balloted_policies: policy_instance = provider.get_policy_instance_for_tuning( policy.policy_id) if policy_instance is None: continue provider.add_to_ballot(policy_instance) provider.vote_by_instance(policy_instance, policy.count, user_directed=True) provider.modify_influence(sim_info, -proto.influence_points) provider.handle_vote_interaction(sim_info, proto.target_id, bool(proto.balloted_policies))
def _get_civic_policy_provider(self, *args, **kwargs): street_service = services.street_service() if street_service is None: return else: street = self._get_street(**kwargs) if street is not None: return street_service.get_provider(street)
def street_civic_policy_force_daily_vote(_connection=None): street_civic_policy_service = services.street_service() if street_civic_policy_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return services.get_event_manager().process_event( TestEvent.CivicPolicyDailyRandomVoting)
def finalize_startup(self, policy): self._policy = policy street_service = services.street_service() self._street = None if street_service is None else street_service.get_street( self.policy.provider) if self._street is None: logger.error('{} failed to get street from {}', self, self.policy.provider)
def get_street(self, *, subjects): street_service = services.street_service() if street_service is None: return if not subjects: logger.error( 'Failed to resolve participant ParticipantType.Street.') return return street_service.get_street(subjects[0])
def _save_street_eco_footprint_data(self, eco_footprint_data): eco_footprint_data.current_eco_footprint_state = self._curr_state_type eco_footprint_data.effects_are_simulated = self._simulating_eco_footprint_on_street street = services.street_service().get_street(self) if street is services.current_street( ) and not self._street_convergence_fully_computed: self._fully_compute_street_convergence() eco_footprint_data.convergence = self.get_street_footprint_convergence_value( )
def finalize_startup(self, policy): super().finalize_startup(policy) if self._street is None: return def handle_moved_sim_info(sim_info, old_street, new_street): if not self.policy.enacted: return if old_street is self._street and self.repeal_loot is not None: self._repeal_for_sim_info(sim_info) if new_street is self._street and self.enact_loot is not None: self._enact_for_sim_info(sim_info) services.street_service( ).register_sim_info_home_street_change_callback( self._street, handle_moved_sim_info) if self.policy.enacted: self._start_schedule()
def repeal(self): super().repeal() for effect in self._civic_policy_effects: effect.repeal() street_service = services.street_service() street = None if street_service is None else street_service.get_street( self.provider) services.get_event_manager().process_event( TestEvent.CivicPoliciesChanged, custom_keys=((street, type(self)), ))
def get_world_description_id(self): street_service = services.street_service() if street_service is not None: world_description_id = world.street.get_world_description_id_from_street( street_service.get_street(self)) if world_description_id is None: return 0 else: return world_description_id return 0
def set_npc_voting_enabled(enabled: bool = False, _connection=None): street_civic_policy_service = services.street_service() if street_civic_policy_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return street_civic_policy_service.enable_automatic_voting = enabled services.get_event_manager().process_event( TestEvent.TestedGameOptionChanged, custom_keys=(TestableGameOptions.CIVIC_POLICY_NPC_VOTING_ENABLED, ))
def vote_by_instance(self, policy_instance, count=1, user_directed=False, lobby_interaction=False): if policy_instance.vote_count_statistic is not None: policy_list = None def get_current_rank(): policy_list.sort(key=lambda policy: (self.get_stat_value(policy.vote_count_statistic), policy.guid64), reverse=True) return policy_list.index(policy_instance) if user_directed: factor = 0 if policy_instance in self._balloted_policies: policy_list = list(self._balloted_policies) factor = 1 elif policy_instance in self._up_for_repeal_policies: policy_list = list(self._up_for_repeal_policies) factor = -1 orig_rank = get_current_rank() elif lobby_interaction: factor = 0 if policy_instance in self._balloted_policies: factor = 1 elif policy_instance in self._up_for_repeal_policies: factor = -1 value = self.get_stat_value(policy_instance.vote_count_statistic) + count self.set_stat_value(policy_instance.vote_count_statistic, value) services.street_service().update_community_board_tooltip(self) if user_directed: if policy_list is not None: with telemetry_helper.begin_hook(civic_policy_telemetry_writer, TELEMETRY_HOOK_CIVIC_POLICY_VOTE) as hook: hook.write_guid(TELEMETRY_FIELD_NEIGHBORHOOD, self.get_world_description_id()) hook.write_guid(TELEMETRY_FIELD_POLICY, policy_instance.guid64) hook.write_guid(TELEMETRY_FIELD_VOTES, factor*value) hook.write_guid(TELEMETRY_FIELD_PLAYER_VOTES, factor*count) hook.write_guid(TELEMETRY_FIELD_OLD_RANK, orig_rank) hook.write_guid(TELEMETRY_FIELD_NEW_RANK, get_current_rank()) if lobby_interaction: with telemetry_helper.begin_hook(civic_policy_telemetry_writer, TELEMETRY_HOOK_CIVIC_POLICY_LOBBY) as hook: hook.write_guid(TELEMETRY_FIELD_NEIGHBORHOOD, self.get_world_description_id()) hook.write_guid(TELEMETRY_FIELD_POLICY, policy_instance.guid64) hook.write_guid(TELEMETRY_FIELD_VOTES, factor*value) return True return False
def set_eco_footprint_state(state: EcoFootprintStateType, update_lot_footprint_values: bool = True, _connection=None): street_service = services.street_service() if street_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return street_provider = street_service.get_provider(services.current_street()) street_provider.force_set_eco_footprint_state(state, update_lot_footprint_values)
def set_eco_footprint_enabled(enabled: bool = True, _connection=None): street_service = services.street_service() if street_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return street_service.enable_eco_footprint = enabled services.get_event_manager().process_event( TestEvent.TestedGameOptionChanged, custom_keys=(TestableGameOptions.ECO_FOOTPRINT_GAMEPLAY, )) return True
def get_participants(self, participant_type, **kwargs): if participant_type == ParticipantType.Street: street_service = services.street_service() if street_service is None: return () street_civic_policy_provider = street_service.get_provider( self._street) if street_civic_policy_provider is None: return () return (street_civic_policy_provider, ) return super().get_participants(participant_type, **kwargs)
def run_auto_voting_tests(self, test_set): if not services.street_service().enable_automatic_voting: return False if not test_set: return True resolvers = list(self.open_close_voting_loot_resolver_list) resolvers.append(VenuePolicyProviderResolver(self)) for resolver in resolvers: if test_set.run_tests(resolver): return True return False
def _recompute_street_convergence(self, *args): street_footprint_stat = self.get_street_footprint() street_service = services.street_service() lot = services.active_lot() lot_footprint_value = lot.commodity_tracker.get_value( EcoFootprintTunables.LOT_FOOTPRINT) aggregate = self.inactive_lots_total + self.active_lot_weight * lot_footprint_value aggregate *= EcoFootprintTunables.get_product_of_tested_modifiers( street_service.get_street(self)) street_footprint_stat.convergence_value = aggregate self._update_street_decay_rate() self._update_eco_footprint_effects()
def street_civic_policy_force_daily_vote(open_voting: bool = True, _connection=None): street_civic_policy_service = services.street_service() if street_civic_policy_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return street_civic_policy_service._force_voting_open = open_voting if open_voting: msg = 'Voting open, vote counts reset to 0' sims4.commands.automation_output(msg, _connection) sims4.commands.cheat_output(msg, _connection) street_civic_policy_service._open_voting()
def enact(self): street_service = services.street_service() if street_service is None: return (neighborhood_proto, street_data) = street_service.get_neighborhood_proto(self._street) if neighborhood_proto is None: logger.error('{} failed to find neighborhood data street info', self) return if self.map_overlay not in street_data.map_overlays: street_data.map_overlays.append(self.map_overlay) self._send_update_msg(neighborhood_proto)
def run_test(self, provider, tooltip): street_service = services.street_service() voting_open = street_service is not None and street_service.voting_open if voting_open: if self.negate: return TestResult( False, 'Civic Policy Provider failed negated voting open', tooltip=tooltip) elif not self.negate: return TestResult(False, 'Civic Policy Provider failed voting open', tooltip=tooltip) return TestResult.TRUE
def send_update_message(self): repeal_policy_id = 0 repeal_sigs = 0 for policy in self._up_for_repeal_policies: if policy.vote_count_statistic is None: repeal_sigs = 0 else: repeal_sigs = int( self.get_stat_value(policy.vote_count_statistic)) repeal_policy_id = policy.guid64 op = CivicPolicyPanelUpdate(services.street_service().voting_open, repeal_policy_id, repeal_sigs, self.get_schedule_text()) Distributor.instance().add_op_with_no_owner(op)
def repeal(self): if self.map_overlay == MapOverlayEnum.NONE: logger.warn('{} tuned to an invalid map overlay {}', self, self.map_overlay) return street_service = services.street_service() if street_service is None: return (neighborhood_proto, street_data) = street_service.get_neighborhood_proto(self._street, add=False) if neighborhood_proto is None: return if self.map_overlay in street_data.map_overlays: street_data.map_overlays.remove(self.map_overlay) self._send_update_msg(neighborhood_proto)
def finalize_startup(self): street_service = services.street_service() street = street_service.get_street(self) for (state_type, state) in self._eco_footprint_states.items(): is_active = state_type == self._curr_state_type state.finalize_startup(is_active) if not self._is_eco_footprint_compatible: return if street is services.current_street(): self._fully_compute_street_convergence() self.update_simulation_if_stale( street_service.enable_eco_footprint) elif self._simulating_eco_footprint_on_street: if self._persisted_convergence is not None: footprint_stat = self.get_street_footprint() footprint_stat.convergence_value = self._persisted_convergence
def force_set_eco_footprint_value(self, new_value, update_lot_values=True): if not self._is_eco_footprint_compatible: return street = services.street_service().get_street(self) street_footprint = self.get_street_footprint() street_footprint.set_value(new_value) if update_lot_values: zone_manager = services.get_zone_manager() for (lot_id, zone_ids ) in world.street.get_lot_id_to_zone_ids_dict(street).items(): zone = zone_manager.get(zone_ids[0], allow_uninstantiated_zones=True) if zone is not None: zone.lot.commodity_tracker.set_value( EcoFootprintTunables.LOT_FOOTPRINT, new_value) self._fully_compute_street_convergence() self._update_eco_footprint_effects(skip_nudge=True)
def run_test(self, provider, tooltip): street_service = services.street_service() voting_open = street_service is not None and street_service.voting_open if voting_open: time_of_change = street_service.voting_close_time else: time_of_change = street_service.voting_open_time now = services.time_service().sim_now time_left = time_of_change - now if callable(self.threshold.value): self.threshold.value = self.threshold.value() result = self.threshold.compare(time_left) if not result: return TestResult( False, 'Civic Policy Provider failed voting time until change test', tooltip=tooltip) return TestResult.TRUE
def street_civic_policy_repeal(policy: TunableInstanceParam( sims4.resources.Types.SNIPPET), opt_target: OptionalSimInfoParam = None, _connection=None): street_service = services.street_service() if street_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return sim = get_optional_target(opt_target, _connection, target_type=OptionalSimInfoParam) world_id = sim.household.get_home_world_id() street = world.street.get_street_instance_from_world_id(world_id) if not street_service.repeal(street, policy): sims4.commands.automation_output('{} not repealed'.format(policy), _connection) sims4.commands.cheat_output('{} not repealed'.format(policy), _connection)
def street_civic_policy_add_influence(count: int = 1, opt_target: OptionalSimInfoParam = None, _connection=None): street_civic_policy_service = services.street_service() if street_civic_policy_service is None: sims4.commands.automation_output('Pack not loaded', _connection) sims4.commands.cheat_output('Pack not loaded', _connection) return sim = get_optional_target(opt_target, _connection, target_type=OptionalSimInfoParam) world_id = sim.household.get_home_world_id() street = world.street.get_street_instance_from_world_id(world_id) provider = street_civic_policy_service.get_provider(street) if provider is None: sims4.commands.automation_output('Street has no provider', _connection) sims4.commands.cheat_output('Street has no provider', _connection) return provider.modify_influence(sim.sim_info, count)