from otree.api import *
c = cu

doc = "Here instead of swiping boxes, the subject taps left or right side buttons to 'open and continue' or 'stop'"
class C(BaseConstants):
    # built-in constants
    NAME_IN_URL = 'columbiacardtask_none'
    PLAYERS_PER_GROUP = None
    NUM_ROUNDS = 56
    # user-defined constants
    BASELINEROUNDS = 0
    BOXES = 32
    LOSSCARDS = (1, 2, 3)
    GAINAMOUNTS = (10, 10, 10, 20, 20, 20, 30, 30, 30)
    LOSSAMOUNTS = (250, 250, 250, 250, 250, 250, 250, 250, 250, 500, 500, 500, 500, 500, 500, 500, 500, 500, 750, 750, 750, 750, 750, 750, 750, 750, 750)
    NFCLONG = 0
    ICECREAMLENGTH = 5
class Subsession(BaseSubsession):
    pass
def creating_session(subsession: Subsession):
    session = subsession.session
    # https://otree.readthedocs.io/en/latest/treatments.html#creating-session
    if subsession.round_number == 1:
    
        import itertools
        import random
    
        # create 5 different random orderings (minus 2 because there are 2 extra practice rounds)
        indices1 = [i for i in range(1,C.NUM_ROUNDS-2-C.BASELINEROUNDS+1)]
        random.shuffle(indices1)
        indices2 = [i for i in range(1,C.NUM_ROUNDS-2-C.BASELINEROUNDS+1)]
        random.shuffle(indices2)
        indices3 = [i for i in range(1,C.NUM_ROUNDS-2-C.BASELINEROUNDS+1)]
        random.shuffle(indices3)
        indices4 = [i for i in range(1,C.NUM_ROUNDS-2-C.BASELINEROUNDS+1)]
        random.shuffle(indices4)
        indices5 = [i for i in range(1,C.NUM_ROUNDS-2-C.BASELINEROUNDS+1)]
        random.shuffle(indices5)
    
        # cycle the players between the random orderings
        index_cycle = itertools.cycle([indices1,indices2,indices3,indices4,indices5])
    
        for player in subsession.get_players():
            participant = player.participant
            participant.indexlist = next(index_cycle)
class Group(BaseGroup):
    pass
class Player(BasePlayer):
    chosencard = models.IntegerField(initial=0)
    endedinloss = models.BooleanField()
    stopped = models.IntegerField(initial=0)
    profit = models.IntegerField()
    roundlosscards = models.IntegerField()
    firstlosscard = models.IntegerField()
    roundgain = models.IntegerField()
    roundloss = models.IntegerField()
    losscardlist = models.StringField()
    dectimes = models.StringField(initial='')
    computer_randomround1 = models.IntegerField()
    computer_randomround2 = models.IntegerField()
    randomprofit1 = models.IntegerField()
    randomprofit2 = models.IntegerField()
    reward = models.FloatField()
    dohmen = models.IntegerField(choices=[[1, '1 = not at all willing to take risks'], [2, '2'], [3, '3'], [4, '4'], [5, '5'], [6, '6'], [7, '7'], [8, '8'], [9, '9'], [10, '10 = very willing to take risks']], widget=widgets.RadioSelect)
    nfcscore = models.IntegerField()
    nfcall = models.StringField()
    ace1 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Emotional abuse', widget=widgets.RadioSelect)
    ace2 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Physical abuse', widget=widgets.RadioSelect)
    ace3 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Sexual abuse', widget=widgets.RadioSelect)
    ace4 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Physical neglect', widget=widgets.RadioSelect)
    ace5 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Emotional neglect', widget=widgets.RadioSelect)
    ace6 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Household mental illness', widget=widgets.RadioSelect)
    ace7 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Prison', widget=widgets.RadioSelect)
    ace8 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Divorce', widget=widgets.RadioSelect)
    ace9 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Parents always arguing', widget=widgets.RadioSelect)
    ace10 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Drugs', widget=widgets.RadioSelect)
    affectbased = models.IntegerField(choices=[[1, '1 = Strongly disagree'], [2, '2 = Moderately disagree'], [3, '3 = Slightly disagree'], [4, '4 = Slightly agree'], [5, '5 = Moderately agree'], [6, '6 = Strongly agree']], label='<p>I solved the task on a gut level</p>', widget=widgets.RadioSelect)
    deliberative = models.IntegerField(choices=[[1, '1 = Strongly disagree'], [2, '2 = Moderately disagree'], [3, '3 = Slightly disagree'], [4, '4 = Slightly agree'], [5, '5 = Moderately agree'], [6, '6 = Strongly agree']], label='<p>I tried to solve the task mathematically</p>', widget=widgets.RadioSelect)
    checkup1 = models.StringField(choices=[['1', 'Points earned from two randomly chosen rounds'], ['3', 'Points earned from half of the rounds'], ['2', 'Points earned from all rounds']], label='<p>My bonus payments for the study consist of ...</p>', widget=widgets.RadioSelect)
    checkup2 = models.StringField(choices=[['1', 'True'], ['2', 'False']], label='<p>The number of loss boxes changes from round to another</p> ', widget=widgets.RadioSelect)
    checkup3 = models.StringField(choices=[['2', 'Changes from round to round'], ['1', 'Always 32'], ['3', 'Depends on the number of loss boxes']], label='<p>How many boxes in total are there in a round?</p>', widget=widgets.RadioSelect)
    prolificcode = models.StringField(blank=True)
    handedness = models.StringField(choices=[['Right hand', 'Right hand'], ['Left hand', 'Left hand']], label='<p>Which hand do you typically use to browse your mobile device? </p>', widget=widgets.RadioSelect)
def live_open(player: Player, data):
    group = player.group
    time = data['time'] # this is a single timestamp indicating when the message was sent to server
    starttime = data['starttime'] # this is a timestamp recorded on page, indicating when box moving started
    opened = data['opened'] # this is zero if swiped right
    player.chosencard += opened
    player.dectimes += str(int(time) - int(starttime)) + ';'
    
    response = {'openedcards': player.chosencard} # how many cards have been opened so far
    
    return {player.id_in_group: response} # using 0: response is an error, broadcasts to the whole group!!!
def checkup1_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: as the instructions state, two blocks will be randomly selected at the end of the study and the points from these blocks paid to you."
def checkup2_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: there can be 1, 2, or 3 loss boxes within a round and this is randomised from round to another."
def checkup3_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: the total number of boxes remains constant, only the number of loss boxes and gain boxes changes from round to another."
class MobileCheck(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( pilot = session.config['pilot'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
class Welcome(Page):
    form_model = 'player'
    form_fields = ['prolificcode']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == 1 and session.config['pilot'] == 0
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
class Instructions(Page):
    form_model = 'player'
    form_fields = ['checkup1', 'checkup2', 'checkup3']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        if session.config['icons'] == 'smileys':
            return player.round_number <= 3
        else:
            return (player.round_number-1) % C.ICECREAMLENGTH == 0
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( checkupround = 3,
                     practiceround2 = player.round_number == 2,
                     roundi = player.round_number,
                     rounds = C.NUM_ROUNDS - C.BASELINEROUNDS,
                     icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        return dict(boxes = C.BOXES,
                    icons = session.config['icons'])
class RoundStart(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number <= C.NUM_ROUNDS - C.BASELINEROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        participant = player.participant
        # THE FOLLOWING VARIABLES ARE SET ONLY AT THE START OF THE ROUND 
        # FIRST 2 ROUNDS ARE PRACTICE ROUNDS WITH "FIXED FEEDBACK"
        # use factorisation only for non-practice rounds
        if player.round_number == 1:
            player.roundlosscards = 2
            player.roundgain = 10
            player.roundloss = 250
            player.firstlosscard = 21
            player.losscardlist = '[21,25]'
        elif player.round_number == 2:
            player.roundlosscards = 3
            player.roundgain = 20
            player.roundloss = 500
            player.firstlosscard = 7
            player.losscardlist = '[7,30,32]'
        else:
        # determine the amount of loss cards, gainamount, and lossamount
            trialnumber = participant.indexlist[player.round_number-2-1]
            # vector of how many loss cards in each round [1,2,3,1,2,3,1,2,3,...]
            losscardsvec = int((C.NUM_ROUNDS-2) / len(C.LOSSCARDS)) * C.LOSSCARDS
            # how many loss cards in this specific round
            player.roundlosscards = losscardsvec[trialnumber - 1]
            # which specific card numbers are loss cards in this block
            import random
            numbs = list(range(1,C.BOXES+1)) #[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32]
            losscardlist = []
            num1 = random.choice(numbs)
            losscardlist.append(num1)
            numbs.remove(num1)
            if (player.roundlosscards >= 2):
                num2 = random.choice(numbs)
                losscardlist.append(num2)
                numbs.remove(num2)
            if (player.roundlosscards == 3):
                num3 = random.choice(numbs)
                losscardlist.append(num3)
            # which one is the first loss card because the block ends in this card
            player.firstlosscard = min(losscardlist)
            player.losscardlist = str(losscardlist)
            # gain amount in this block based on trialnumber (excel file) 10,10,10,20,20,20,30,30,30,10,10,10,...
            gainsvec = int((C.NUM_ROUNDS-2-C.BASELINEROUNDS) / len(C.GAINAMOUNTS)) * C.GAINAMOUNTS
            player.roundgain = gainsvec[trialnumber - 1]
            # loss amount in this block based on trialnumber (excel file) 250,250,250,250,250,250,250,250,250,500,500,...
            lossvec = int((C.NUM_ROUNDS-2-C.BASELINEROUNDS) / len(C.LOSSAMOUNTS)) * C.LOSSAMOUNTS
            player.roundloss = lossvec[trialnumber - 1]
        
        
        # results from previous rounds (moved here from RoundEnd)
        tabledata = ""
        for j in range(1,player.round_number):
            j_player = player.in_round(j)
            if session.config['icons'] == 'smileys':
                tabledata += ''
                tabledata += "<tr><td class=roundendtable>" + str(j_player.round_number) + "</td><td class=roundendtable>" + str(j_player.chosencard) + "</td><td class=roundendtable>" + str(format(j_player.profit, '.0f')) + "</td></tr>"
            else:
                if j_player.endedinloss == 1: 
                    icecreams = '0'
                else: 
                    icecreams = str(j_player.chosencard)
                if j > (player.round_number-(player.round_number % C.ICECREAMLENGTH)):
                    tabledata += "<tr><td class=roundendtable>" + str((j_player.round_number - 1) % C.ICECREAMLENGTH + 1) + "</td><td class=roundendtable>" + icecreams + "</td></tr>"
                if player.round_number % C.ICECREAMLENGTH == 0 and j > player.round_number - 5:
                    tabledata += "<tr><td class=roundendtable>" + str((j_player.round_number - 1) % C.ICECREAMLENGTH + 1) + "</td><td class=roundendtable>" + icecreams + "</td></tr>"
        
        return dict( tabledata = tabledata,
                     rounds = C.NUM_ROUNDS - C.BASELINEROUNDS,
                     example1 = player.roundgain*6, 
                     example2 = max(player.roundgain*6 - player.roundloss, 0), 
                     pilot = session.config['pilot'], 
                     icons = session.config['icons'],
                     icecreamround = (player.round_number - 1) % C.ICECREAMLENGTH + 1,
                     displaytable = player.round_number % C.ICECREAMLENGTH != 1 # for ice creams
        )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
class Decision(Page):
    form_model = 'player'
    form_fields = ['stopped']
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number <= C.NUM_ROUNDS - C.BASELINEROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        # create the number of boxes opened for js_vars (same as blockround in the old app)
        # ???
        
        return dict( gainvalue = player.roundgain,
                     openedcards = player.chosencard, # this is only used to display the initial row of cards
                     firstlosscard = player.firstlosscard,
                     boxes = C.BOXES,
                     icons = session.config['icons'], 
                     losscards = player.roundlosscards )
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        if player.chosencard == player.firstlosscard: # if round ended in turning over loss card
            player.endedinloss = True
            player.chosencard -= 1                    # subtract one card from the record of chosen cards
            player.profit = max(0,player.chosencard * player.roundgain - player.roundloss)
        else: # if round ended in stopping
            player.endedinloss = False
            player.profit = player.chosencard * player.roundgain
    live_method = 'live_open'
class RoundEnd(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number <= C.NUM_ROUNDS - C.BASELINEROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( practiceround = player.round_number < 3,
                     afterfirstround = player.round_number > 1,
                     gains = player.roundgain * player.chosencard, 
                     icons = session.config['icons'])
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        losscardlist = player.losscardlist
        losscardlist = losscardlist[1:]
        losscardlist = losscardlist[:-1]
        losscardlist = losscardlist.split(',')
        
        return dict(chosencard = player.chosencard,
                    boxes = C.BOXES,
                    endedinloss = player.endedinloss,
                    losscardlist = losscardlist,
                    firstlosscard = player.firstlosscard,
                    icons = session.config['icons'])
class RiskReport(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number % C.ICECREAMLENGTH == 0 and session.config['icons'] != 'smileys'
    @staticmethod
    def vars_for_template(player: Player):
        icecreams = 0
        for i in range(player.round_number):
            icecreams += player.in_round(i+1).chosencard
        
        average = icecreams/player.round_number
        populationaverage = 4.4
        sd = 1.01
        if average < populationaverage-sd:
            text = 'less risk taking than'
        elif average > populationaverage+sd:
            text = 'more risk taking than'
        else:
            text = 'equally risk taking as'
        
        return dict( average = round(average, 2),
                     populationaverage = populationaverage,
                     sd = sd,
                     text = text,
                     firstgame = player.round_number == C.ICECREAMLENGTH,
                     display = player.round_number >= C.ICECREAMLENGTH*3
                   )
class NFC(Page):
    form_model = 'player'
    form_fields = ['dohmen', 'nfcscore', 'nfcall', 'affectbased', 'deliberative', 'handedness']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        if session.config['icons'] == 'smileys':
            return player.round_number == C.NUM_ROUNDS
        else:
            return player.round_number == C.ICECREAMLENGTH
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        group = player.group
        import random
        nfcorder = [
            ['nfc1','I think that having clear rules and order at work is essential for success.'],
            ['nfc2','Even after I have made up my mind about something, I am always eager to consider a different opinion.'],
            ['nfc3','I do not like situations that are uncertain.'],
            ['nfc4','I dislike questions which could be answered in many different ways.'],
            ['nfc5','I like to have friends who are unpredictable.'],
            ['nfc6','I find that a well ordered life with regular hours suits my temperament.'],
            ['nfc7','When dining out, I like to go to places where I have been before so that I know what to expect.'],
            ['nfc8','I feel uncomfortable when I do not understand the reason why an event occurred in my life.'],
            ['nfc9','I feel irritated when one person disagrees with what everyone else in a group believes.'],
            ['nfc10','I hate to change my plans at the last minute.'],
            ['nfc11','I do not like to go into a situation without knowing what I can expect from it.'],
            ['nfc12','When I have made a decision, I feel relieved.'],
            ['nfc13','When I am confronted with a problem, I''m dying to reach a solution very quickly.'],
            ['nfc14','When I am confused about an important issue, I feel very upset.'],
            ['nfc15','I would quickly become impatient and irritated if I would not find a solution to a problem immediately.'],
            ['nfc16','I would rather make a decision quickly than sleep over it.'],
            ['nfc17','Even if I get a lot of time to make a decision, I still feel compelled to decide quickly.'],
            ['nfc18','I think it is fun to change my plans at the last moment.'],
            ['nfc19','I enjoy the uncertainty of going into a new situation without knowing what might happen.'],
            ['nfc20','My personal space is usually messy and disorganised.'],
            ['nfc21','In most social conflicts, I can easily see which side is right and which is wrong.'],
            ['nfc22','I almost always feel hurried to reach a decision, even when there is no reason to do so.'],
            ['nfc23','I believe that orderliness and organisation are among the most important characteristics of a good student.'],
            ['nfc24','When considering most conflict situations, I can usually see how both sides could be right.'],
            ['nfc25','I do not like to be with people who are capable of unexpected actions.'],
            ['nfc26','I prefer to socialise with familiar friends because I know what to expect from them.'],
            ['nfc27','I think that I would learn best in a class that lacks clearly stated objectives and requirements.'],
            ['nfc28','When thinking about a problem, I consider as many different opinions on the issue as possible.'],
            ['nfc29','I like to know what people are thinking all the time.'],
            ['nfc30','I dislike it when a person''s statement could mean many different things.'],
            ['nfc31','It is annoying to listen to someone who cannot seem to make up his or her mind.'],
            ['nfc32','I find that establishing a consistent routine enables me to enjoy life more.'],
            ['nfc33','I enjoy having a clear and structured mode of life.'],
            ['nfc34','I prefer interacting with people whose opinions are very different from my own.'],
            ['nfc35','I like to have a place for everything and everything in its place.'],
            ['nfc36','I feel uncomfortable when someone''s meaning or intention is unclear to me.'],
            ['nfc37','I always see many possible solutions to problems I face.'],
            ['nfc38','I would rather know bad news than stay in a state of uncertainty.'],
            ['nfc39','I do not usually consult many different opinions before forming my own view.'],
            ['nfc40','I dislike unpredictable situations.'],
            ['nfc41','I dislike the routine aspects of my work (studies).']
        ]
        
        random.shuffle(nfcorder)
        
        # NFC Short includes nfc3, nfc4, nfc6, nfc8, nfc9, nfc11, nfc12, nfc13, nfc15, nfc25, nfc30, nfc32, nfc33, nfc39, nfc40
        
        # N = not reversed, R = reversed
        reversedscoring = ['N','R','N','N','R','N','N','N','N','N','N','N','N','N','N','N','N','R','R','R','N','N','N','R','N','N','R','R','N','N','N','N','N','R','N','N','R','N','N','N','R']
        
        # the variable player.nfcall returns the list of answers in the order nfc1, nfc2, nfc3, ... so with reverse scoring included
        
        # subscales a,b,c,d,e
        subscales = ['a','e','d','e','b','a','b','d','e','a','b','c','c','d','c','c','c','b','b','a','d','c','a','e','b','b','a','e','d','d','d','a','a','e','a','d','e','d','e','b','a']
        
        responses = [' 1 = Strongly disagree',' 2 = Moderately disagree',' 3 = Slightly disagree',' 4 = Slightly agree', ' 5 = Moderately agree', ' 6 = Strongly agree']
        
        return dict( nfcorder = nfcorder, reversedscoring = reversedscoring, responses = responses, subscales = subscales, nfclong = C.NFCLONG, icons = session.config['icons'] )
class ACE(Page):
    form_model = 'player'
    form_fields = ['ace1', 'ace2', 'ace4', 'ace3', 'ace5', 'ace6', 'ace7', 'ace8', 'ace9', 'ace10']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == C.NUM_ROUNDS and session.config['icons'] == 'smileys'
    @staticmethod
    def vars_for_template(player: Player):
        # this is the 10-item ACE scale presented in e.g. Lloyd 2022; also in original Felitti 1998 study
        # note that the "divorce" question has been revised in newer versions to specify a situation of parental abandonment
        
        ace1 = '<p>Did a parent or an adult in your home ever swear at you, insult you, or put you down?</p>'
        ace2 = '<p>Did a parent or an adult in your home ever hit, beat, kick, or physically hurt you in any way?</p>'
        ace3 = '<p>Did you experience unwanted sexual contact (such as fondling or oral/anal/vaginal intercourse/penetration)?</p>'
        ace4 = '<p>Did you feel that you did not have enough to eat, had to wear dirty clothes, or had no one to protect or take care of you?</p>'
        ace5 = '<p>Did you feel that no one in your family loved you or thought you were special?</p>'
        ace6 = '<p>Did you live with anyone who was depressed, mentally ill, or attempted suicide?</p>'
        ace7 = '<p>Did you live with anyone who went to jail or prison?</p>'
        ace8 = '<p>Did you lose a parent through parental separation or divorce, abandonment, death, or other reason?</p>'
        ace9 = '<p>Did your parents or adults in your home ever hit, punch, beat, or threaten to harm each other?</p>'
        ace10 = '<p>Did you live with anyone who was a problem drinker or alcoholic, or who used street drugs?</p>'
        
        return dict( ace1 = ace1, ace2 = ace2, ace3 = ace3, ace4 = ace4, ace5 = ace5, ace6 = ace6, ace7 = ace7, ace8 = ace8, ace9 = ace9, ace10 = ace10 )
class RewardPage(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == C.NUM_ROUNDS and session.config['icons'] == 'smileys'
    @staticmethod
    def vars_for_template(player: Player):
        import random
        
        if player.field_maybe_none('computer_randomround1') == None and player.field_maybe_none('computer_randomround2') == None:
        
            roundlist = list(range(3, C.NUM_ROUNDS-C.BASELINEROUNDS+1))
            # randomly chosen rounds
            randomround1 = random.choice(roundlist)
            roundlist.remove(randomround1) # make sure that randomround2 is not the same as randomround1
            randomround2 = random.choice(roundlist)
        
            rewardplayer1 = player.in_round(randomround1)
            rewardplayer2 = player.in_round(randomround2)
        
            player.computer_randomround1 = rewardplayer1.round_number
            player.computer_randomround2 = rewardplayer2.round_number
            player.reward = (rewardplayer1.profit + rewardplayer2.profit)/100
            player.randomprofit1 = rewardplayer1.profit
            player.randomprofit2 = rewardplayer2.profit
        
        profitzero = False
        if player.reward == 0:
            profitzero = True
        
        return dict( profitzero = profitzero, 
                     randomround1x = player.computer_randomround1,
                     randomround2x = player.computer_randomround2)
class FinalPage(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == C.NUM_ROUNDS and session.config['icons'] == 'smileys'
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( prolificurl = session.config['prolificurl'],  icons = session.config['icons'] )
page_sequence = [MobileCheck, Welcome, Instructions, RoundStart, Decision, RoundEnd, RiskReport, NFC, ACE, RewardPage, FinalPage]