class Player(BasePlayer): early_finish = models.BooleanField( doc='if decided to abandon the waiting page clickin Finish the study') wp_timer_start = djmodels.DateTimeField(null=True, blank=True) sec_spent = models.IntegerField( doc='number of seconds spent on waiting page') sec_earned = models.FloatField(doc='dollars earned for waiting') decision_order = models.IntegerField(initial=10 ^ 10) current_ball = models.StringField( ) # the color of the ball a player will draw choice_of_urn = models.StringField( # the guess by the player choices=['A', 'B'], widget=widgets.RadioSelectHorizontal()) def set_payoffs(self): if self.choice_of_urn == self.subsession.storyline: self.payoff = Constants.bonus else: self.payoff = 0
class Group(BaseGroup): allocation_bureau = models.CurrencyField( verbose_name='How much do you want to allocate?') allocation_pol = models.CurrencyField( choices=currency_range(c(0), c(100), 1), verbose_name='How much do you want to allocate?') public_payoff = models.CurrencyField(initial=c(0)) citizen_payoff = models.CurrencyField(initial=c(0)) is_elected = models.BooleanField( verbose_name= 'Do you want to re-elect the politician for another 4 rounds?') # def set_budget(self): # p2 = self.get_player_by_role('Bureaucrat') # p1 = self.get_player_by_role('Politician') # p2.bureau_budget= p1.allocation_pol def set_payoffs(self): politician = self.get_player_by_role('Politician') bureaucrat = self.get_player_by_role('Bureaucrat') citizen = self.get_player_by_role('Citizen') waiting = self.get_player_by_role('Waiting') for player in [politician, bureaucrat]: if (self.round_number == self.session.vars['paying_round']): player.payoff = sum([ p.public_payoff for p in self.player.in_all_rounds() ]) * (Constants.multiplication_factor / Constants.players_per_round) for player in [citizen]: if (self.round_number == self.session.vars['paying_round']): player.payoff = sum([ p.public_payoff for p in self.player.in_all_rounds() ]) * (Constants.multiplication_factor / Constants.players_per_round) + sum([ p.citizen_payoff for p in self.player.in_all_rounds() ])
class Group(BaseGroup): group_account = models.IntegerField(initial=0) num_giver = models.IntegerField(initial=0) # boolean that shows if there is a majority in voting majority = models.BooleanField(initial=False) # 1:Keeper 2:Giver 3:No one , if None there is no majority majority_type = models.IntegerField() def set_num_giver(self): count_givers = 0 for player in self.get_players(): if player.binary_choice == 2: count_givers += 1 self.num_giver = count_givers def set_group_account(self): self.group_account = self.num_giver * Constants.ini_privat # TODO: note: this function depends on 3 voting decisions, is not flexible to change in game design # TODO: it is also not flexible against the number of players per group # check for majority and determine who gets bonus def define_bonus(self): # votes coding according to player vars: 1: keeper, 2:giver , 3:no one votesdic = {1: 0, 2: 0, 3: 0} for player in self.get_players(): votesdic[player.vote] += 1 # check for majority for dec in votesdic.keys(): if votesdic[dec] > 1: #TODO only works for 3 players per group self.majority = True self.majority_type = dec break # determine which of the players will get no bonus (per default all get bonus) if self.majority and self.majority_type != 3: for player in self.get_players(): if player.binary_choice == self.majority_type: player.gets_bonus = False player.bonus_amount = 0
class Decision(Model ): # our custom model inherits from Django's base class "Model" REASONS = ( ('dont_know', "Don't know"), ('example_reason', "Example reason"), ('another_example_reason', "Another example reason"), ) value = models.IntegerField() # will be randomly generated player_decision = models.BooleanField() reason = models.CharField(choices=REASONS) player = ForeignKey( Player ) # creates 1:m relation -> this decision was made by a certain player def __str__(self): return 'decision #%d for player %d (participant %d) - value %d'\ % (self.pk, self.player.pk, self.player.participant.id_in_session, self.value)
class Player(BasePlayer): question_id = models.IntegerField() question = models.StringField() solution = models.IntegerField() solution_text = models.StringField() submitted_answer_text = models.StringField() submitted_answer = models.IntegerField() is_correct = models.BooleanField(initial=False, choices=[[True, _('Yes')], [False, _('No')]]) explanation = models.StringField() n_try = models.IntegerField(initial=1) def current_question(self): return self.session.vars['quiz_file_list'][self.round_number - 1] def check_correct(self): self.is_correct = (self.submitted_answer == self.solution) self.submitted_answer_text = str(self.submitted_answer) if not self.is_correct: self.n_try = self.n_try + 1
class Appreciation( Model): # our custom model inherits from Django's base class "Model" player = ForeignKey( Player, null=True, blank=True ) # creates 1:m relation -> this appreciation was made by a certain player proposition = ForeignKey( Proposition, null=True, blank=True ) # creates 1:m relation -> this appreciation is related to a certain proposition app_player_ID_ingroup = models.IntegerField() note = models.IntegerField(min=Constants.c_min_note, max=Constants.c_max_note) reaction = models.CharField() related_version = models.PositiveIntegerField(initial=999) up_to_date = models.BooleanField(initial=False) def __str__(self): return "Appreciation n°{id}: {reaction}".format(id=self.pk, reaction=self.reaction)
class Player(BasePlayer): item_value_estimate = models.CurrencyField( doc="""Estimate of the common value, may be different for each player""" ) bid_amount = models.CurrencyField(min=Constants.min_allowable_bid, max=Constants.max_allowable_bid, doc="""Amount bidded by the player""") is_winner = models.BooleanField( initial=False, doc="""Indicates whether the player is the winner""") def set_payoff(self): if self.is_winner: self.payoff = self.group.item_value - self.bid_amount if self.payoff < 0: self.payoff = 0 else: self.payoff = 0
class Player(BasePlayer): age = models.IntegerField(min=18, max=99, label="What is your age?") gender = models.StringField( choices=['Male', 'Female', 'Other', 'I don\'t want to say it'], label='What is your gender?') math_grade = models.FloatField(blank=True, min=1, max=6, label='What was your last math grade?') falk_time = models.IntegerField( choices=list(range(11)), widget=widgets.RadioSelectHorizontal, label= "How willing are you to give up something that is beneficial for you today in order to benefit more from that in the future?" ) # Additional field to check if the participant wants to revise the answer revise_question = models.BooleanField( label="Do you want to change your answers?")
class Player(BasePlayer): waiting_period = models.IntegerField() treatment_method = models.StringField() sooner_period = models.StringField() comprehend_correct = models.BooleanField() switch_point = models.StringField( label='Silakan pilih "situasi" Anda', widget=widgets.RadioSelect, ) def switch_point_choices(self): options_part1 = OptionOfGetMoney.formatted_option(self) options_1 = options_part1 + " " options_2 = " token, " + str( self.waiting_period) + " " + OptionOfGetMoney.part3 return [ #['test', str(type(Constants.spaces))], ['1', options_1 + '110' + options_2], ['2', options_1 + '120' + options_2], ['3', options_1 + '130' + options_2], ['4', options_1 + '140' + options_2], ['5', options_1 + '150' + options_2], ['6', options_1 + '160' + options_2], ['7', options_1 + '170' + options_2], ['8', options_1 + '180' + options_2], ['9', options_1 + '190' + options_2], ['10', 'Saya menolak untuk menunggu.'], ] comprehend = models.StringField( label='Berdasarkan pilihan anda, opsi manakah yang benar dibawah ini?', widget=widgets.RadioSelect, ) def comprehend_choices(self): return [ ['a', 'Anda akan menerima 100 token hari ini.'], ['b', 'Anda akan menerima 100 token 3 minggu kemudian.'], ['c', 'Anda akan menerima 150 token hari ini.'], ['d', 'Anda akan menerima 150 token 3 minggu kemudian.'], ]
class Group(BaseGroup): amount_offered = models.CurrencyField() offer_accepted = models.BooleanField(doc="if offered amount is accepted", widget=widgets.RadioSelectHorizontal, choices=( (True, 'Accept'), (False, 'Reject'), )) def set_payoffs(self): proposer = self.get_player_by_role('proposer') responder = self.get_player_by_role('responder') if self.offer_accepted: proposer.payoff = Constants.endowment - self.amount_offered responder.payoff = Constants.endowment + self.amount_offered else: proposer.payoff = Constants.payoff_if_rejected responder.payoff = Constants.payoff_if_rejected
class Player(BasePlayer): count = models.IntegerField(min=0, label='How many ones are in the table?') correct_counts = models.IntegerField(initial=0) counts_submitted = models.IntegerField(initial=0) pay_for_round = models.CurrencyField(initial=c(0)) claimed_earnings = models.CurrencyField( label='Please announce your income in the box, then click next', min=c(0)) tax_audit = models.BooleanField() tax_message = models.StringField() tax_on_claimed = models.CurrencyField(initial=c(0)) post_tax_earnings = models.CurrencyField(initial=c(0)) final_earnings = models.CurrencyField(initial=c(0)) def check_answer(self): self.counts_submitted += 1 if self.count == self.participant.vars['next_correct_answer']: self.correct_counts += 1 self.pay_for_round += Constants.table_pay def update_iterator(self): self.participant.vars['i'] += 1 if self.participant.vars['i'] >= Constants.max_tables_in_round: self.participant.vars['i'] = 0 def handle_taxes(self): self.tax_audit = choice([True, False], p=[0.2, 0.8]) self.tax_on_claimed = self.claimed_earnings * Constants.tax_rate self.post_tax_earnings = self.pay_for_round - self.tax_on_claimed if self.tax_audit: self.tax_message = 'You have been reviewed. ' if self.claimed_earnings >= self.pay_for_round: self.tax_message = self.tax_message + 'However, you announced all of your earnings, so don\'t face any deductions.' self.final_earnings = self.post_tax_earnings else: not_claimed = self.pay_for_round - self.claimed_earnings extra_tax = not_claimed * 2 * Constants.tax_rate self.tax_message = self.tax_message + f'You did not announce {not_claimed} ECU of your earnings. You are deducted {extra_tax} ECU.' self.final_earnings = self.post_tax_earnings - extra_tax else: self.tax_message = 'You have not been reviewed this round.' self.final_earnings = self.post_tax_earnings self.participant.vars['payoff'] += self.final_earnings
class Player(BasePlayer): donation = models.CurrencyField( min=0, max=Constants.endowment, doc="donation in EUR", verbose_name='How much do you want to donate?') treatment = models.CharField(choices=Constants.treatment_specifications) claimed_content = models.CharField( choices=Constants.treatment_specifications + Constants.additional_specifications, doc="Claimed content of the picture", verbose_name="What do you see in the picture on the previous page?") claimed_content_correct = models.BooleanField() def check_claim(self): self.claimed_content_correct = self.treatment == self.claimed_content def calculate_payoff(self): self.payoff = Constants.endowment - self.donation
class Player(BasePlayer): item_value_estimate = models.CurrencyField( doc="""Aproximado del valor común, puede diferir entre jugadores""") bid_amount = models.CurrencyField( min=Constants.min_allowable_bid, max=Constants.max_allowable_bid, doc="""Cantidad ofertada por el jugador""") is_winner = models.BooleanField(initial=False, doc="""Indica si el jugador ha ganado""") def set_payoff(self): if self.is_winner: self.payoff = self.group.item_value - self.bid_amount if self.payoff < 0: self.payoff = 0 else: self.payoff = 0
class Group(BaseGroup): total_contribution = models.CurrencyField() individual_share = models.CurrencyField() round_num = models.IntegerField() current_share = models.FloatField() # p1 = models.IntegerField() # p2 = models.IntegerField() # p3 = models.IntegerField() # p1_payoff = models.CurrencyField() # p2_payoff = models.CurrencyField() # p3_payoff = models.CurrencyField() global_contribution = models.CurrencyField() success = models.BooleanField() # glob_cont=models.CurrencyField() # def __init__(self): # self.group = None def round_number(self): return self.subsession.round_number def set_payoffs(self): self.total_contribution = sum( [p.contribution for p in self.get_players()]) self.individual_share = self.total_contribution * Constants.efficiency_factor / Constants.players_per_group self.global_contribution = sum( [p.total_contribution for p in self.in_all_rounds()]) self.current_share = self.global_contribution * 100 / Constants.threshold # if Group.flood<self.current_share: # self.success = 1 # else: # self.success = 0 for p in self.get_players(): p.payoff = Constants.endowment - p.contribution # + self.individual_share # p1 = self.get_player_by_id(1) # p2 = self.get_player_by_id(2) # p3 = self.get_player_by_id(3) # p1_payoff = sum([p.payoff for p in self.in_previous_rounds() if p.p1 == 1]) # p2_payoff = sum([p.payoff for p in self.in_previous_rounds() if p.p2 == 2]) # p3_payoff = sum([p.payoff for p in self.in_previous_rounds() if p.p3 == 3]) # in_all_rounds print('p.payoff_is', p.payoff)
class Player(BasePlayer): numStage = models.IntegerField() # whether bomb is collected or not # store as integer because it's easier for interop with JS bomb = models.IntegerField() # location of bomb bomb_row = models.PositiveIntegerField() bomb_col = models.PositiveIntegerField() # number of collected boxes boxes_collected = models.IntegerField() # --- set round results and player's payoff # ------------------------------------------------------------------------------------------------------------------ pay_this_round = models.BooleanField() round_result = models.FloatField() def set_payoff(self): # determine round_result as (potential) payoff per round if self.bomb: self.round_result = 0 else: self.round_result = self.boxes_collected * Constants.box_value # set payoffs if <random_payoff = True> to round_result of randomly chosen round # randomly determine round to pay on player level if self.subsession.round_number == 1: self.participant.vars['round_to_pay'] = random.randint(1,Constants.num_rounds) if Constants.random_payoff: if self.subsession.round_number == self.participant.vars['round_to_pay']: self.pay_this_round = True self.payoff = self.round_result else: self.pay_this_round = False self.payoff = 0 # set payoffs to round_result if <random_payoff = False> else: self.payoff = self.round_result
class Group(BaseGroup): total_contribution = models.IntegerField() total_payoff = models.IntegerField() #Add additional variables to this sequence if you want more players payout_from_manager_1 = models.FloatField(min=0) payout_from_manager_2 = models.FloatField(min=0) payout_from_manager_3 = models.FloatField(min=0) payout_from_manager_4 = models.FloatField(min=0) equally_distributed = models.BooleanField(blank=True) def set_poll(self): self.total_contribution = sum( [p.contribution for p in self.get_players()]) self.total_payoff = self.total_contribution * Constants.multiplier self.set_fairly_distributed_amount() def set_fairly_distributed_amount(self): for p in self.get_players(): p.fairly_distributed_amount() def set_payoffs(self): residuals = (self.total_payoff - (self.payout_from_manager_1 + self.payout_from_manager_2 + self.payout_from_manager_3 + self.payout_from_manager_4) ) / Constants.players_per_group # Add additional elif statements to this sequence if you want more players for p in self.get_players(): if p.id_in_group == 1: p.earnings = self.payout_from_manager_1 p.payoff = self.payout_from_manager_1 + residuals elif p.id_in_group == 2: p.earnings = self.payout_from_manager_2 p.payoff = self.payout_from_manager_2 + residuals elif p.id_in_group == 3: p.earnings = self.payout_from_manager_3 p.payoff = self.payout_from_manager_3 + residuals elif p.id_in_group == 4: p.earnings = self.payout_from_manager_4 p.payoff = self.payout_from_manager_4 + residuals
class Subsession(BaseSubsession): utility_slider = models.IntegerField() is_peak = models.BooleanField() peak_mean = models.IntegerField() offpeak_mean = models.IntegerField() alpha = models.IntegerField() def creating_session(self): if self.round_number % Constants.repeat_span != 1: self.group_randomly(fixed_id_in_group=True) self.peak_mean = self.in_round( self.round_number - 1 ).peak_mean if self.round_number % Constants.repeat_span != 1 else Constants.peak_mean_base + np.random.randint( 2) self.offpeak_mean = self.in_round( self.round_number - 1 ).offpeak_mean if self.round_number % Constants.repeat_span != 1 else Constants.offpeak_mean_base + np.random.randint( 2) self.alpha = self.in_round( self.round_number - 1 ).alpha if self.round_number % Constants.repeat_span != 1 else np.round( Constants.alpha_base + np.random.randn() * Constants.alpha_amplifier) self.set_is_peak() self.update_utility() def update_utility(self): self.utility_slider = self.peak_mean if self.is_peak else self.offpeak_mean self.utility_slider += np.round(np.random.randn()) def utility(self, x): return np.round(self.alpha / (1 + np.exp(self.utility_slider - x))) def set_is_peak(self): if self.round_number % Constants.repeat_span == 1: self.is_peak = False elif self.round_number % Constants.repeat_span == 2: self.is_peak = True else: self.is_peak = np.random.rand() > .2
class Player(BasePlayer): endowment = models.IntegerField() bid = models.CurrencyField( min=0, max=20, initial=0, blank=True) # min will be set in Bid template to current price stop = models.BooleanField() accepted_bids = models.IntegerField() total_payoff = models.CurrencyField() def vars_for_template(self): if self.subsession.round_number % self.session.config[ "rounds_per_session"] == 0: round_in_session = 3 # else it would return 0 else: round_in_session = self.subsession.round_number % self.session.config[ "rounds_per_session"] return dict( endowment=self.participant.vars["endowment"], land=self.participant.vars["land"], num_land=len(self.participant.vars["land"]), player_accepted_bids=self.participant.vars["accepted_bids"], price=self.session.vars["price"], num_stopped=self.session.vars["players_stopped"], round_in_session=round_in_session, total_endowments=self.session.vars["total_num_endowments"], payoff=self.participant.vars["payoff"], rounds_per_session=self.session.config["rounds_per_session"]) def calculate_payoffs(self): net_units = self.participant.vars["endowment"] - self.participant.vars[ "accepted_bids"] cash_change = self.session.vars["price"] * net_units profit_irrigated = sum(self.participant.vars["land"] [:self.participant.vars["accepted_bids"]]) profit_dry = len(self.participant.vars["land"] ) - self.participant.vars["accepted_bids"] profit_land = profit_irrigated + profit_dry profit = profit_land + cash_change self.participant.vars["payoff"] += profit def store_payoffs(self): self.total_payoff = self.participant.vars["payoff"]
class Subsession(BaseSubsession): storyline = models.StringField() room_busy = models.BooleanField(initial=False) pay_per_min = models.FloatField( doc='how much to pay per minute of waiting. Set to 0 to pay nothing') wait_before_leave = models.IntegerField( doc='how many seconds to wait. Set to negative number ' 'to switch off the option. Set to 0 to show immediately') def creating_session(self): self.storyline = random.choice(Constants.urns) self.pay_per_min = self.session.config.get('pay_per_min', Constants.pay_per_min) self.wait_before_leave = self.session.config.get( 'wait_before_leave', Constants.wait_before_leave) for p in self.get_players(): if self.storyline == 'A': p.current_ball = random.choice(Constants.urn_A) else: p.current_ball = random.choice(Constants.urn_B)
class Player(BasePlayer): answer = models.IntegerField(choices=[1, 2, 3, 4, 5, 6, 7, 8]) ans_correct = models.BooleanField() #Cognitive bat = models.IntegerField(min=0, max=110) machines = models.IntegerField(min=0, max=300) lake = models.IntegerField(min=0, max=48) # Demographics age = models.IntegerField(label='What is your age?', min=13, max=125) gender = models.StringField(choices=['Male', 'Female', 'Other'], label='What is your gender?', widget=widgets.RadioSelect) income = models.IntegerField( label='What is the annual income of your family in USD?', min=100, max=3000000)
class Player(BasePlayer): pay_round = models.IntegerField() choice = models.StringField() win = models.BooleanField() sur_q01 = make_survey_field(1) sur_q02 = make_survey_field(2) sur_q03 = make_survey_field(3) sur_q04 = make_survey_field(4) sur_q05 = make_survey_field(5) sur_q06 = make_survey_field(6) sur_q07 = make_survey_field(7) sur_q08 = make_survey_field(8)
class Player(BasePlayer): player_role = models.IntegerField() tn = models.StringField(blank=False) accept_info = models.BooleanField(blank=False, widget=widgets.CheckboxInput) accept_1 = models.BooleanField(blank=False, widget=widgets.CheckboxInput) accept_2 = models.BooleanField(blank=False, widget=widgets.CheckboxInput) accept_3 = models.BooleanField(blank=False, widget=widgets.CheckboxInput) pay_this_round = models.BooleanField() round_result = models.CurrencyField() extension = models.IntegerField() Instr1 = models.IntegerField(blank=False, choices=[[1, 'True'], [2, 'False']], widget=widgets.RadioSelect) Instr2 = models.IntegerField(blank=False, choices=[[1, 'True'], [2, 'False']], widget=widgets.RadioSelect) Instr3 = models.IntegerField(blank=False, choices=[[1, 'True'], [2, 'False']], widget=widgets.RadioSelect) Instr4 = models.IntegerField(blank=False, choices=[[1, 'True'], [2, 'False']], widget=widgets.RadioSelect) round_start = models.BooleanField(blank=False, widget=widgets.CheckboxInput) def define_condition_player(self): self.extension = self.participant.vars.get('extension') def set_final_payoff(self): if self.subsession.round_number == 1: self.participant.vars['round_to_pay'] = random.randint( 1, Constants.num_rounds) if self.subsession.round_number == self.participant.vars[ 'round_to_pay']: self.pay_this_round = True self.payoff = self.round_result self.participant.vars['payoff_lira'] = self.round_result self.participant.vars[ 'payoff_eur'] = self.round_result.to_real_world_currency( self.session) else: self.pay_this_round = False self.payoff = c(0)
class Player(BasePlayer): # Variable para saber si alguien tiene o no el bien x (True lo tiene, False no) bien_x = models.BooleanField() dotacion_A = models.CurrencyField(initial=Constants.dotacion_inicial_A) dotacion_B = models.CurrencyField(initial=Constants.dotacion_inicial_B) extraccion = models.CurrencyField(max=Constants.dotacion_inicial_A, min=0, initial=0) # Pago ronda anterior pago_anterior = models.CurrencyField(initial=0) def role(self): if self.id_in_group == 1: return 'A' else: return 'B' def extraccion_max(self): return self.dotacion
class Player(BasePlayer): investment = models.CurrencyField( verbose_name="How much do you want to invest?") lottery_payoff = models.CurrencyField() lottery_won = models.BooleanField() selected_round = models.PositiveIntegerField() def play_lottery(self): if random() >= Constants.winning_probability: self.lottery_won = False self.lottery_payoff = Constants.endowment - self.investment else: self.lottery_won = True self.lottery_payoff = Constants.endowment + self.investment * ( 1 + Constants.winning_return) def pick_round(self): self.selected_round = randint(1, Constants.num_rounds) correct_player = self.in_round(self.selected_round) self.payoff = correct_player.lottery_payoff
class Player(BasePlayer): amount_risky = models.CurrencyField(max=Constants.endowment, min=0) project_success = models.BooleanField() return_from_investment = models.CurrencyField(initial=0) def set_payoffs(self): import random random_number = random.random() print(random_number) self.payoff = Constants.endowment - self.amount_risky if random_number > Constants.p_success: self.project_success = False else: self.project_success = True self.return_from_investment = self.amount_risky * Constants.multiplier self.payoff = self.payoff + self.return_from_investment print('amount invested:', self.amount_risky) print('project success:', self.project_success) print('return from investment:', self.return_from_investment) print('payoff:', self.payoff)
class Group(BaseGroup): peak_pricing = models.IntegerField(min=Constants.minimum_price) offpeak_pricing = models.IntegerField(min=Constants.minimum_price) is_blackout = models.BooleanField() total_consumption = models.CurrencyField() def pricing(self): n = (self.subsession.round_number - 1) // Constants.repeat_span * Constants.repeat_span + 1 return self.in_round( n).peak_pricing if self.subsession.is_peak else self.in_round( n).offpeak_pricing def set_payoffs(self): self.total_consumption = sum([ p.consumption for p in self.get_players() if p.role() == 'Consumer' ]) self.is_blackout = self.total_consumption >= Constants.blackout_criteria for p in self.get_players(): if p.role() == 'Producer': p.payoff = Constants.profit_per_kw * self.total_consumption if self.total_consumption in range( *Constants.bonus_consumption_range): p.payoff += Constants.consumption_bonus elif self.total_consumption not in range( *Constants.penalty_consumption_range): p.payoff += Constants.consumption_penalty else: p.payoff = Constants.blackout_penalty if self.is_blackout else self.subsession.utility( p.consumption) if self.subsession.round_number % Constants.repeat_span == 0: repeat_span_idx = self.subsession.round_number // Constants.repeat_span p.payoff -= sum([ self.in_round(i).pricing() * p.in_round(i).consumption for i in range((repeat_span_idx - 1) * Constants.repeat_span + 1, repeat_span_idx * Constants.repeat_span + 1) ])
class Player(BasePlayer): dump_tasks = models.LongStringField() qs_not_available = models.BooleanField( initial=False ) # When this is true the user asnwers all questions correctly. @property def total_attempts(self): """We get all tasks associated to the current user, to which he provided any answers.""" return self.tasks.filter(answer__isnull=False).count() @property def correct_answers(self): """We get all tasks associated to the current user, to which he provided correct answers.""" return self.tasks.filter(answer=F('question__solution')).count() @property def available_qs(self): """Here we check for all questions that already correctly answered by a user.""" correct_qs_ids = self.tasks.filter( answer=F('question__solution')).values_list('question__id', flat=True) return Q.objects.exclude(id__in=correct_qs_ids) def get_random_question(self): """We pick a random question from the list of available ones. NB: If the list of questions is huge it should be done differently. """ available_qs = self.available_qs if available_qs.exists(): return random.choice(available_qs) def get_or_create_task(self): """We check whether there is unfinished task, if there is we return it. If there is not, we create a new one.""" unfinished_tasks = self.tasks.filter(answer__isnull=True) if unfinished_tasks.exists(): return unfinished_tasks.latest() else: q = self.get_random_question() if q: task = self.tasks.create(question=q) return task
class Group(BaseGroup): offer = models.PositiveIntegerField( max=Constants.pot_size, min=0, widget=widgets.SliderInput(attrs={'step': '1'}), verbose_name= "Please decide about the quantity to share with the other player") accepted = models.BooleanField( choices=[(True, 'Yes'), (False, 'No')], verbose_name="Please decide about the other player's offer", doc="response choice") def calc_payoff(self): proposer = self.get_player_by_role('proposer') responder = self.get_player_by_role('responder') if self.accepted: proposer.payoff = Constants.pot_size - self.offer responder.payoff = self.offer else: proposer.payoff = c(0) responder.payoff = c(0)
class Player(BasePlayer): question_id = models.IntegerField() question = models.StringField() choice_1 = models.StringField() choice_2 = models.StringField() choice_3 = models.StringField() choice_4 = models.StringField() solution = models.StringField() current_score = models.IntegerField(min=0, max=5, initial=0) submitted_answer = models.StringField(widget=widgets.RadioSelect) is_correct = models.BooleanField() def current_question(self): return self.participant.vars['questions'][self.round_number - 1] def check_correct(self): self.is_correct = (self.submitted_answer == self.solution) def calc_current_score(self): player_in_all_rounds = self.in_all_rounds() self.current_score = sum([p.is_correct for p in player_in_all_rounds])
class Risk(djmodels.Model): player = models.ForeignKey(Player, related_name="risks") left_col = models.IntegerField() right_col = models.IntegerField() answer = models.BooleanField(null=True, doc='False - option A, True - option B', widget=widgets.RadioSelectHorizontal) def __str__(self): answer_to_str = None if self.answer == True: answer_to_str = 'Option B' elif self.answer == False: answer_to_str = 'Option A' return 'choosing between option A({}) and B({}) with the probs {}/{} {} was chosen'.format( Constants.risk_choices_A, Constants.risk_choices_B, self.left_col, self.right_col, answer_to_str, )