Python scoring.score函数代码示例

def bonus(request, player_id):
    player = get_object_or_404(Player, pk=player_id)

    if request.method == 'POST':
        form = BonusForm(request.POST)
        if form.is_valid():
            coin, amount = form.cleaned_data['coin'], form.cleaned_data['amount']
            formula = Formula.get('bonus-%s' % coin.name)
            if formula is None:
                messages.error(request, 'No such formula, bonus-%s' % coin.name)
            else:
                scoring.score(player, None, formula, external_id=request.user.get_profile().id, **{coin.name: amount})
                if form.cleaned_data['reason']:
                    add_activity(player, _('received {amount} {coin} bonus for {reason}'), amount=amount, coin=coin, reason=form.cleaned_data['reason'])
                messages.info(request, 'Successfully given bonus')
            return redirect('player_profile', id=player.id)
    else:
        form = BonusForm()

    bonuses = scoring.History.objects.filter(user=player, formula__name__startswith='bonus-').order_by('-timestamp')
    penalties = scoring.History.objects.filter(user=player, formula__name__startswith='penalty-').order_by('-timestamp')

    return render_to_response('cpanel/bonus.html', {'target_player': player, 'form': form, 'bonuses': bonuses, 'penalties': penalties},
        context_instance=RequestContext(request)
    )

def infraction_recheck(request):
    """ Rerun an infraction check on the current challenge history

        The view should allow for other infraction additions. """
    try:
        inf_list = History.objects.filter(coin__name='penalty',
                                          formula__name='chall-was-set-up-infraction').delete()
    except:
        pass

    all_participants = Participant.objects.filter(seconds_took__lt=15).exclude(
        seconds_took=None)
    formula = Formula.objects.get(name='chall-was-set-up-infraction')
    for p in all_participants:
        id = None
        if p.user_from.count():
            if p.user_from.all()[0].status == 'P' and p.user_from.all()[
                0].winner.id != p.user.id:
                user = p.user.player_ptr
                id = p.user_from.all()[0].id
        if p.user_to.count():
            if p.user_to.all()[0].status == 'P' and p.user_to.all()[
                0].winner.id != p.user.id:
                user = p.user.player_ptr
                id = p.user_to.all()[0].id
        if id:
            scoring.score(user=user, game=None, formula=formula, external_id=id)
    return HttpResponseRedirect(reverse('wouso.interface.cpanel.views.players'))

    def check_answer(self, user, answer):
        if user.current_quest != self:
            user.finish_quest()
            user.set_current(self)
            return False

        try:
            question = self.levels[user.current_level]
        except IndexError:
            logging.error("No such question")

        user_hash = hashlib.sha1(
            '%s%s%s' % (user.last_name[::-1], question.answers.all()[0].text, user.first_name)
        )
        if not user.current_level == self.count and \
                answer.lower() == user_hash.hexdigest():
            # score current progress
            scoring.score(user, QuestGame, self.get_formula('quest-ok'), level=(user.current_level + 1))
            user.current_level += 1
            if user.current_level == self.count:
                user.finish_quest()
                # score finishing
                scoring.score(user, QuestGame, self.get_formula('quest-finish-ok'))
            user.save()
            return True
        return False

    def create(self, request, coin, tocoin):
        try:
            coin = Coin.objects.get(id=coin)
            tocoin = Coin.objects.get(id=tocoin)
        except Coin.DoesNotExist:
            return {'success': False, 'error': 'Invalid coin'}

        attrs = self.flatten_dict(request.POST)
        if 'amount' not in attrs.keys():
            return {'success': False, 'error': 'Amount not provided'}

        player = request.user.get_profile()
        try:
            amount = int(attrs['amount'])
            assert amount > 0
        except (ValueError, AssertionError):
            return {'success': False, 'error': 'Invalid Amount'}

        if player.coins[coin.id] < amount:
            return {'success': False, 'error': 'Insufficient amount'}

        # TODO: change me
        if coin.id == 'points':
            scoring.score(player, None, 'points-gold-rate', points=amount)
        elif coin.id == 'gold':
            scoring.score(player, None, 'gold-points-rate', gold=amount)

        return {'success': True, 'coins': player.coins}

def question_switch(request, id):
    """ Accept a proposed question
    """
    question = get_object_or_404(Question, pk=id)

    # qproposal - endorse part
    proposed_cat = Category.objects.filter(name='proposed')[0]
    if question.category == proposed_cat:
        if not question.endorsed_by:
            player = question.proposed_by.get_profile()
            staff_user = request.user
            question.endorsed_by = staff_user
            question.save()
            amount = 0
            for tag in question.tags.all():
                if tag.name == 'qotd':
                    amount = QOTD_GOLD
                elif tag.name == 'challenge':
                    amount = CHALLENGE_GOLD
                elif tag.name == 'quest':
                    amount = QUEST_GOLD
            scoring.score(player, None, 'bonus-gold', external_id=staff_user.id,
                          gold=amount)

    # regular activation of question
    else:
        question.active = not question.active
        question.save()

    go_back = request.META.get('HTTP_REFERER', None)
    if not go_back:
        go_back = reverse('wouso.interface.cpanel.views.qpool_home')

    return HttpResponseRedirect(go_back)

def manage_player_set(request, player_id, task_id):
    player = get_object_or_404(SpecialQuestUser, id=player_id)
    task = get_object_or_404(SpecialQuestTask, id=task_id)

    if task not in player.done_tasks.all():
        if player.group:
            members = player.group.members
            player.group.set_task_done(task)
        else:
            members = (player,)

        for member in members:
            if task not in member.done_tasks.all():
                member.done_tasks.add(task)
                scoring.score(member, SpecialQuestGame, 'specialquest-passed',external_id=task.id, value=task.value)

                signal_msg = ugettext_noop('completed special quest {task_name} and earned {value} gold')
                action_msg = 'specialq-ok-gold'
                signals.addActivity.send(sender=None, user_from=member, \
                                         user_to=member, \
                                         message=signal_msg,
                                         arguments=dict(task_name=task.name, value=task.value), \
                                         game=SpecialQuestGame.get_instance(),
                                         action=action_msg)

    return HttpResponseRedirect(reverse('specialquest_manage', args=(player.id,)))

def manage_player(request, player_id):
    player = get_object_or_404(Player, pk=player_id)
    player = player.get_extension(SpecialQuestUser)
    tasks_not_done = SpecialQuestTask.objects.exclude(id__in=player.done_tasks.all().values('id')).all()

    # TODO: use smth like django-flash for this
    message, error = '', ''

    if request.method == "POST":
        # do bonuses
        try:
            amount = int(request.POST.get('gold', 0))
        except ValueError:
            amount = 0
        if amount > 0:
            scoring.score(player, None, 'bonus-gold', external_id=request.user.get_profile().id, gold=amount)
            message = 'Successfully given bonus'
        else:
            error = 'Invalid amount'

    bonuses = scoring.History.objects.filter(user=player, formula__id='bonus-gold')

    return render_to_response('specialquest/cpanel_manage.html',
                    dict(mplayer=player, tasks_not_done=tasks_not_done, message=message, error=error, bonuses=bonuses),
                    context_instance=RequestContext(request))

def user_post_save(sender, instance, **kwargs):
    profile, new = Player.objects.get_or_create(user=instance)
    if new:
        # add in default group
        from wouso.core.config.models import ChoicesSetting
        try:
            default_group = PlayerGroup.objects.get(pk=int(ChoicesSetting.get('default_group').get_value()))
        except (PlayerGroup.DoesNotExist, ValueError):
            pass
        else:
            profile.groups.add(default_group)
 
        try:
            default_series = PlayerGroup.objects.get(pk=int(ChoicesSetting.get('default_series').get_value()))
        except (PlayerGroup.DoesNotExist, ValueError):
            pass
        else:
            profile.groups.add(default_series)
        # kick some activity
        signal_msg = ugettext_noop('has joined the game.')

        signals.addActivity.send(sender=None, user_from=profile,
                                 user_to=profile,
                                 message=signal_msg,
                                 game=None)
        # give 15 bonus points
        from wouso.core.scoring import score
        from wouso.settings import STARTING_POINTS
        try:
            score(profile, None, 'bonus-points', points=STARTING_POINTS)
        except: pass # This might fail when formulas are not set-up, i.e. superuser syncdb profile creation

def karma_group_view(request, group):
    group_id = group
    group = get_object_or_404(PlayerGroup, pk=group)
    players = group.players.all()
    if request.method == 'POST':
        form = KarmaBonusForm(request.POST, players=players)
        if form.is_valid():
            formula = Formula.get('bonus-karma')
            if formula is None:
                messages.error(request, 'No such formula, bonus-karma')
            else:
                for player, entry in zip(players, form.fields):
                    # get amount of karma points for current player
                    karma_points = form.cleaned_data[entry]
                    # if karma points are zero then skip
                    if karma_points == 0:
                        continue
                    # compute formula and calculate amount of bonus given
                    amount = eval(formula.expression.format(**{'karma_points': karma_points}).split('=')[1])
                    # apply scoring
                    scoring.score(player, None, formula, external_id=request.user.get_profile().id, **{'karma_points': karma_points})
                    # add activity (parse formula expression to get the coin from formula)
                    add_activity(player, _(
                        'received {amount} {coin} bonus for {karma_points} Karma Points'),
                                amount=amount, coin=formula.expression.split('=')[0], karma_points=karma_points,
                                reason='Bonus for Karma')
                    messages.info(request, 'Successfully given bonus')
            return redirect('karma_group', **{'group': group_id})
    else:
        form = KarmaBonusForm(players=players)
    return render_to_response('cpanel/karma_group.html',
                              {'form':form, 'group':group},
                              context_instance=RequestContext(request))

    def create(user_from, user_to, ignore_questions = False):
        """ Assigns questions, and returns the number of assigned q """

        questions = [q for q in get_questions_with_category('challenge')]
        if (len(questions) < 5) and not ignore_questions:
            raise ChallengeException('Too few questions')
        shuffle(questions)

        uf, ut = Participant(user=user_from), Participant(user=user_to)
        uf.save(), ut.save()

        c = Challenge(user_from=uf, user_to=ut, date=datetime.now())
        c.save()

        # TODO: better question selection
        #limit = 5
        for q in questions[:Challenge.LIMIT]:
            c.questions.add(q)

        # set last_launched
        user_from.last_launched = datetime.now()
        user_from.save()

        # take 3 points from user_from
        scoring.score(user_from, ChallengeGame, 'chall-warranty', external_id=c.id)
        return c

def bazaar_buy(request, spell):
    spell = get_object_or_404(Spell, pk=spell)

    player = request.user.get_profile()
    error, message = '',''

    if Bazaar.disabled():
        error = _("Magic is disabled")
    elif spell.price > player.coins.get('gold', 0):
        error = _("Insufficient gold amount")
    elif spell.available == False:
        error = _("Spell is not available")
    elif spell.level_required > player.level_no:
        error = _("Level {level} is required to buy this spell").format(level=spell.level_required)
    else:
        player.magic.add_spell(spell)
        scoring.score(player, None, 'buy-spell', external_id=spell.id,
                      price=spell.price)
        signal_msg = ugettext_noop('bought a spell')
        action_msg = 'spell-buy'
        signals.addActivity.send(sender=None, user_from=player,
                        user_to=player,
                        message=signal_msg,
                        game=None,
                        action=action_msg,
                        public=False)
        SpellHistory.bought(player, spell)
        message = _("Successfully aquired")

    return bazaar(request, message=message, error=error)

def quest_bonus(request, quest):
    quest = get_object_or_404(Quest, pk=quest)

    # TODO: move logic to models
    for i, r in enumerate(quest.top_results()):
        player = r.user.get_extension(Player)
        scoring.score(player, QuestGame, 'quest-finish-bonus', position=i + 1, external_id=quest.id)

    return redirect('quest_home')

def manage_player(request, player_id):
    player = get_object_or_404(Player, pk=player_id)
    player = player.get_extension(SpecialQuestUser)
    tasks_not_done = SpecialQuestTask.objects.exclude(id__in=player.done_tasks.all().values("id")).all()

    # TODO: use smth like django-flash for this
    message, error = "", ""

    if request.method == "POST":
        # do bonuses
        if request.POST.get("gold", False):
            try:
                amount = int(request.POST.get("gold", 0))
            except ValueError:
                amount = 0
            if amount > 0:
                scoring.score(player, None, "bonus-gold", external_id=request.user.get_profile().id, gold=amount)
                message = "Successfully given bonus"
                if request.POST.get("comment", None):
                    signal_msg = ugettext_noop("received {gold} gold bonus for {comment}")
                    signals.addActivity.send(
                        sender=None,
                        user_from=player,
                        user_to=player,
                        message=signal_msg,
                        arguments=dict(gold=amount, comment=request.POST["comment"]),
                        game=SpecialQuestGame.get_instance(),
                    )
            else:
                error = "Invalid amount"
        elif request.POST.get("points", False):
            try:
                amount = int(request.POST.get("points", 0))
                # assert amount > 0
            except (ValueError, AssertionError):
                error = "Invalid amount"
            else:
                scoring.score(player, None, "penalty-points", external_id=request.user.get_profile().id, points=amount)
                message = "Successfully punished"

    bonuses = scoring.History.objects.filter(user=player, formula__id="bonus-gold").order_by("-timestamp")
    penalties = scoring.History.objects.filter(user=player, formula__id="penalty-points").order_by("-timestamp")

    return render_to_response(
        "specialquest/cpanel_manage.html",
        dict(
            mplayer=player,
            tasks_not_done=tasks_not_done,
            message=message,
            error=error,
            bonuses=bonuses,
            penalties=penalties,
        ),
        context_instance=RequestContext(request),
    )

    def answered(user, question, choice):
        correct = False
        for i, a in enumerate(question.answers):
            if a.id == choice:
                if a.correct:
                    correct = True
                break

        user.set_answered(choice, correct) # answer id

        if correct:
            scoring.score(user, QotdGame, 'qotd-ok')

    def give_level_bonus(self):
        for level in xrange(len(self.levels)):
            users = QuestUser.objects.filter(current_level=level)

            for user in users:
                scoring.score(
                        user,
                        QuestGame,
                        self.get_formula('finalquest-ok'),
                        level=level,
                        level_users=users.count()
                )