def __init__(
      self,
      model: language_model.LanguageModel,
      memory: associative_memory.AssociativeMemory,
      cooperative_option: str,
      resolution_scene: str,
      cooperator_reward_fn: SchellingFunction,
      defector_reward_fn: SchellingFunction,
      players: Sequence[deprecated_agent.BasicAgent | entity_agent.EntityAgent],
      acting_player_names: Sequence[str],
      outcome_summarization_fn: Callable[
          [Mapping[str, int],
           Mapping[str, str],
           Mapping[str, float],
           Mapping[str, float]],
          Mapping[str, str],
      ],
      clock_now: Callable[[], datetime.datetime],
      active_players_observe_joint_action_and_outcome: bool = False,
      name: str = 'scoring function',
      verbose: bool = False,
  ):
    """Initialize a scoring function component.

    Args:
      model: a language model
      memory: an associative memory
      cooperative_option: which option choice constitutes cooperation
      resolution_scene: on which scene type should this component be updated
        after the event, i.e. when to check the joint action and compute results
      cooperator_reward_fn: reward obtained by cooperators as a function of
        the number of other cooperators
      defector_reward_fn: reward obtained by defectors as a function of the
        number of other defectors
      players: sequence of agents (a superset of the active players)
      acting_player_names: sequence of names of players who act each stage
      outcome_summarization_fn: function of binarized joint actions and
        rewards which returns an outcome description message for each player
      clock_now: Function to call to get current time.
      active_players_observe_joint_action_and_outcome: False by default, if set
        to True, then active players observe the full joint action and outcome,
        otherwise they observe only their own actions and rewards description.
        Inactive players always observe the full joint action and outcome.
      name: name of this component e.g. Possessions, Account, Property, etc
      verbose: whether to print the full update chain of thought or not
    """
    self._model = model
    self._memory = memory
    self._cooperative_option = cooperative_option
    self._cooperator_reward_fn = cooperator_reward_fn
    self._defector_reward_fn = defector_reward_fn
    self._players = players
    self._acting_player_names = acting_player_names
    self._outcome_summarization_fn = outcome_summarization_fn
    self._clock_now = clock_now
    self._name = name
    self._active_players_observe_joint_action_and_outcome = (
        active_players_observe_joint_action_and_outcome
    )
    self._verbose = verbose

    self._history = []
    self._state = ''
    self._partial_states = {player.name: '' for player in self._players}
    self._player_scores = {player.name: 0 for player in self._players}

    self._map_names_to_players = {
        player.name: player for player in self._players}

    self._resolution_scene = resolution_scene
    self._current_scene = current_scene.CurrentScene(
        name='current scene type',
        memory=self._memory,
        clock_now=self._clock_now,
        verbose=self._verbose,
    )

    self.reset()
    # Set the initial state's string representation.
    self.update()
Initialize a scoring function component.

    Args:
      model: a language model
      memory: an associative memory
      cooperative_option: which option choice constitutes cooperation
      resolution_scene: on which scene type should this component be updated
        after the event, i.e. when to check the joint action and compute results
      cooperator_reward_fn: reward obtained by cooperators as a function of
        the number of other cooperators
      defector_reward_fn: reward obtained by defectors as a function of the
        number of other defectors
      players: sequence of agents (a superset of the active players)
      acting_player_names: sequence of names of players who act each stage
      outcome_summarization_fn: function of binarized joint actions and
        rewards which returns an outcome description message for each player
      clock_now: Function to call to get current time.
      active_players_observe_joint_action_and_outcome: False by default, if set
        to True, then active players observe the full joint action and outcome,
        otherwise they observe only their own actions and rewards description.
        Inactive players always observe the full joint action and outcome.
      name: name of this component e.g. Possessions, Account, Property, etc
      verbose: whether to print the full update chain of thought or not
    
concordia/components/game_master/deprecated/schelling_diagram_payoffs.py