Python models.Coin类代码示例

    def test_frenzy_loss(self):
        """
         If user loses while affected by frenzy he should lose frenzy.percents more points
        """
        initial_points = 100
        loss_points = -10
        warranty_points = -3

        player_frenzy = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_frenzy, 'points', initial_points)

        formula = Formula.get('chall-lost')
        formula.expression = 'points=' + str(loss_points)
        formula.save()

        formula = Formula.get('chall-warranty')
        formula.expression = 'points=' + str(warranty_points)
        formula.save()

        # Apply frenzy
        frenzy = Spell.objects.create(name='challenge-affect-scoring', available=True, price=25, percents=66, type='o')
        obs = PlayerSpellDue.objects.create(player=player_frenzy, source=player_frenzy, spell=frenzy, due=datetime.now() + timedelta(days=1))

        # Win challenge with dummy player to see the amount of points lost by the player affected with frenzy
        chall = Challenge.create(user_from=player_frenzy, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_dummy)

        # Player should lose frenzy.percents more points with frenzy applied
        target_points = initial_points + loss_points + frenzy.percents / 100.0 * loss_points + warranty_points

        self.assertEqual(player_frenzy.player_ptr.points, target_points)

    def test_charge(self):
        """
         Test for Charge spell
        """
        initial_points = 10

        player = self._get_player()
        player2 = self._get_player(2)
        chall_user = player.get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(chall_user, 'points', initial_points)
        self.assertEqual(player.points, initial_points)

        # Points won before Charge is applied
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)
        points_no_charge = player.points

        # Apply Charge
        charge = Spell.objects.create(name='challenge-affect-scoring', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=charge, due=datetime.now() + timedelta(days=1))
        self.assertTrue(chall_user.magic.has_modifier('challenge-affect-scoring'))

        player.points = initial_points
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)

        # Player should have 33% more points with charge applied
        self.assertEqual(player.points, points_no_charge + 0.33 * (points_no_charge - initial_points))

    def test_charge(self):
        """
         Test for Charge spell
        """
        initial_points = 100
        win_points = 10

        player_charge = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_charge, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player_charge, source=player_charge, spell=charge, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player_charge, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_charge)

        # Player should win weakness.percents more points with charge applied
        target_points = initial_points + win_points + charge.percents / 100.0 * win_points
        self.assertEqual(player_charge.player_ptr.points, target_points)

    def test_weakness(self):
        """
         Test for weakness
        """

        initial_points = 10

        player = self._get_player()
        player2 = self._get_player(2)
        chall_user = player.get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(chall_user, 'points', initial_points)
        self.assertEqual(player.points, initial_points)

        # Points won before Weakness is applied
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)
        points_no_weakness = player.points

        # Applying Weakness
        weakness = Spell.objects.create(name='challenge-affect-scoring', available=True, price=10, percents=-66, type='n')
        obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=weakness, due=datetime.now() + timedelta(days=1))
        self.assertTrue(chall_user.magic.has_modifier('challenge-affect-scoring'))

        player.points = initial_points
        chall = Challenge.create(user_from=chall_user, user_to=player2, ignore_questions=True)
        chall.set_won_by_player(chall_user)

        # Player should win 66% less points with weakness applied
        self.assertEqual(player.points, points_no_weakness - 0.66 * (points_no_weakness - initial_points))

    def test_weakness_and_charge(self):
        """
         If both Weakness and Charge are active, a player should win weakness.percents + charge.percents less/more points
         after winning a challenge
        """
        initial_points = 100
        win_points = 10

        player = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=charge, due=datetime.now() + timedelta(days=1))

        # Apply weakness
        weakness = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=-66, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=weakness, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player)

        percents = (charge.percents + weakness.percents) / 100.0
        target_points = initial_points + win_points + percents * win_points

        self.assertEqual(player.player_ptr.points, target_points)

def coin_amount(amount, coin=None):
    if coin is None:
        coin = Coin.get('points')
    else:
        coin = Coin.get(coin)

    if coin is None:
        return '%f (not setup)' % amount

    return '<div class="coin-amount coin-%s" title="%s">%s</div>' % (coin.name, coin.name, amount)

 def testUpdatePoints(self):
     Coin.add("points")
     Coin.add("gold")
     Formula.objects.create(id="level-gold", formula="gold=10*{level}", owner=None)
     player = self._get_player()
     player.points = 420
     player.level_no = 1
     player.save()
     update_points(player, None)
     coins = History.user_coins(player.user)
     self.assertIn("gold", coins)
     self.assertEqual(coins["gold"], 60)

def coin_amount(amount, coin=None):
    if coin is None:
        coin = Coin.get('points')
    else:
        coin = Coin.get(coin)

    if coin is None:
        return '(not setup)'

    if isinstance(amount, Player):
        amount = amount.coins.get(coin.name, 0)

    return '<div class="coin-amount coin-%s" title="%s">%s</div>' % (coin.name, coin.name, amount)

    def test_first_login_points(self):
        f = Formula.add('start-points', formula='points=10')
        Coin.add('points')
        player = self._get_player()

        self.assertEqual(player.points, 0)

        # this won't work, since the activity is sent in our custom view
        #self.client.login(username=player.user.username, password='test')
        # using this instead
        signals.addActivity.send(sender=None, user_from=player, action="login", game = None, public=False)

        player = Player.objects.get(pk=player.pk)
        self.assertEqual(player.points, 10)

    def test_gold_amount(self):
        player = self._get_player()
        coin = Coin.add('gold')

        scoring.score_simple(player, coin, amount=100)

        self.assertEqual(gold_amount(player), 100)

def score_simple(player, coin, amount, game=None, formula=None,
    external_id=None, percents=100):
    """ Give amount of coin to the player.
    """
    if not isinstance(game, Game) and game is not None:
        game = game.get_instance()

    if not isinstance(player, Player):
        raise InvalidScoreCall()

    user = player.user

    coin = Coin.get(coin)
    formula = Formula.get(formula)

    computed_amount = 1.0 * amount * percents / 100
    hs = History.objects.create(user=user, coin=coin, amount=computed_amount,
        game=game, formula=formula, external_id=external_id, percents=percents)

    # update user.points asap
    if coin.id == 'points':
        player.points += computed_amount
        player.save()
        update_points(player, game)

    logging.debug("Scored %s with %f %s" % (user, computed_amount, coin))
    return hs

def score_simple(player, coin, amount, game=None, formula=None,
    external_id=None, percents=100):
    """ Give amount of coin to the player.
    """
    if not isinstance(game, Game) and game is not None:
        game = game.get_instance()

    if not isinstance(player, Player):
        raise InvalidScoreCall()

    user = player.user
    player = user.get_profile()
    user = player.user

    coin = Coin.get(coin)
    formula = Formula.get(formula)

    computed_amount = 1.0 * amount * percents / 100
    hs = History.add(user=user, coin=coin, amount=computed_amount,
            game=game, formula=formula, external_id=external_id, percents=percents)

    # update user.points asap
    if coin.name == 'points':
        if player.magic.has_modifier('top-disguise'):
            computed_amount = 1.0 * computed_amount * player.magic.modifier_percents('top-disguise') / 100

        player.points += computed_amount
        player.save()
        update_points(player, game)

    logging.debug("Scored %s with %f %s" % (user, computed_amount, coin))
    return hs

    def test_disguise_simple(self):
        """
         Test if top-disguise spell works
        """
        player = self._get_player()
        Coin.add('points')
        scoring.score_simple(player, 'points', 10)

        self.assertEqual(player.points, 10)

        disguise = Spell.objects.create(name='top-disguise', available=True, price=10, percents=50, type='s')
        player.magic.add_spell(disguise)
        player.magic.cast_spell(disguise, player, datetime.now() + timedelta(days=1))

        self.assertTrue(player.magic.has_modifier('top-disguise'))

        self.assertEqual(player.points, 15)

    def test_bazaar_buy_ok(self):
        spell = Spell.objects.create(price=0)
        f = Formula.add('buy-spell')
        f.expression = 'points=0'
        f.save()
        Coin.add('points')

        response = self.client.post('/api/bazaar/buy/', {'spell': spell.id})

        self.assertEqual(response.status_code, 200)
        data = json.loads(response.content)

        self.assertTrue(data)
        self.assertTrue(data['success'])

        player = self.user.get_profile()

        self.assertTrue(spell in [s.spell for s in player.magic.spells_available])

 def testUpdatePoints(self):
     Coin.add('points')
     Coin.add('gold')
     Formula.objects.create(id='level-gold', formula='gold=10*{level}', owner=None)
     player = self._get_player()
     player.points = 82
     player.level_no = 1
     player.save()
     update_points(player, None)
     coins = History.user_coins(player.user)
     self.assertIn('gold', coins)
     self.assertEqual(coins['gold'], 20)
     player.points = 10
     player.save()
     update_points(player, None)
     coins = History.user_coins(player.user)
     self.assertIn('gold', coins)
     self.assertEqual(coins['gold'], 0)