Hi everyone,

Sorry for the long post but I really need your help on this. 

I want participants in different groups to have different/same payoffs in each round depending upon their choices.
So, I have two teams playing against each other, let us suppose, each team has two players.

Now, who wins the round depends upon the group's choice. How do I set up different payoffs for participants in two different groups when they have the same choices? or different choices? The payoffs are determined on the group level, meaning, participants in the same team get the same payoffs. In my experiment, we switch participants randomly after some rounds for which the code is ready and set. I need help with setting up payoffs....which is at the end of the code below. 

For example:
Two teams A and B select prices of 20 each.
For team A, the payoff while selecting 20 is 31, and for team B, the payoff while selecting 20 is 29. How do I do this? Also, I need to do this for choices starting from 0 to 49, there's a matrix of payoff and your payoff depends on your choice as well as the other team's choice (if a price between 21 and 49 is selected). If a price below 21 is selected, Team A and Team B's payoffs do not depend on each other's choices, but there are predefined payoffs, which are different and depend on which team you are on.

Also, how can I set up a profit calculator on the screen where subjects can input their choice and assume another team's choice and see what their payoffs could look like based on this payoff matrix? Please look at the attached image for the payoff matrix. 


How my code looks:
 PLAYERS_PER_GROUP = None
 NUM_ROUNDS = 50
 PRICE_MIN = cu(0)
 PRICE_MAX = cu(49)
 COLORS = ['A', 'B']
 
 class Subsession(BaseSubsession):
    winning_price = models.IntegerField()
 
 def creating_session(subsession: Subsession):
    session = subsession.session
    if subsession.round_number == 1:
        from random import shuffle

        session = subsession.session
        players_per_group = session.config['players_per_group']
        num_firms = session.config['num_firms']
        num_participants = session.num_participants
        if num_participants != num_firms * players_per_group:
            raise ValueError(f'Number of participants in the session must be {num_firms} * {players_per_group}')

        players = subsession.get_players()
        shuffle(players)
        for p in players:
            p.participant.moved = False

        group_matrix = [players[n: n + players_per_group] for n in range(0, len(players), players_per_group)]

        for n, s in enumerate(subsession.in_rounds(1, C.ROUND_NUMBER_SWITCH - 1)):
            # set group matrix for all rounds up to the switch round (excluded)
            s.set_group_matrix(group_matrix)
            if n == 0:
                for i, g in enumerate(s.get_groups()):
                    color = C.COLORS[i]
                    g.color = color
                    for p in g.get_players():
                        p.participant.uuid = f'{color} {p.id_in_group}'
            else:
                for i, g in enumerate(s.get_groups()):
                    g.color = C.COLORS[i]

        # From each original group extract a randomly selected employee using pop() with a random index
        from random import randint
        employees_to_switch = [g.pop(randint(0, players_per_group - 1)) for g in group_matrix]
        for e in employees_to_switch:
            e.participant.moved = True
            e.moved = True
            e.group.moved_player_id = e.id_in_group

        # Change the list order of the employees to re-assign
        employees_to_switch.append(employees_to_switch.pop(0))

        for n, p in enumerate(employees_to_switch):
            # Reassign each employee to the new group
            group_matrix[n].append(p)

        for s in subsession.in_rounds(C.ROUND_NUMBER_SWITCH, C.NUM_ROUNDS):
            # Set group matrix for all rounds from the switch round (included)
            s.set_group_matrix(group_matrix)

            for i, g in enumerate(s.get_groups()):
                g.color = C.COLORS[i]
 
def set_payoffs(subsession: Subsession):
    session = subsession.session
    groups = subsession.get_groups()
    for g in groups:
        set_price(g)

    winning_price = min([g.price for g in groups])
    subsession.winning_price = winning_price
    num_winners = len([g for g in groups if g.price == winning_price])
    for g in groups:
        g.win = g.price == winning_price
        if g.win:
            for p in g.get_players():
                if g.price in [0, 1]:
                    p.payoff = 0
                elif g.price == 2:
                    p.payoff = 1
                elif g.price == 3:
                    p.payoff = 2
                elif g.price == 4:
                    p.payoff = 3
 
I need help setting payoffs. I'm sure there is a better way to do this. As of now, my code doesn't give different payoffs for two different teams. However, what I want is different payoffs for Team A and B, when their choices are between 0 and 21; and payoffs based on the matrix in the attached image when the choices are between 21 and 49.

Thank you for going through all this and for your help in advance.