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_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_scoring_loss(self):
initial_points = 10
winner = self._get_player(1).get_extension(ChallengeUser)
loser = self._get_player(2).get_extension(ChallengeUser)
# Setup scoring
scoring.setup_scoring()
Coin.add('points')
# Give initial points
scoring.score_simple(winner, 'points', initial_points)
scoring.score_simple(loser, 'points', initial_points)
# Set formula
loss_points = -2
formula = Formula.get('chall-lost')
formula.expression = 'points=' + str(loss_points)
formula.save()
# Play challenge
chall = Challenge.create(user_from=winner,
user_to=loser,
ignore_questions=True)
chall.set_won_by_player(winner)
self.assertEqual(loser.player_ptr.points, initial_points +
loss_points) # loss_points is negative
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 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_disguise_expire_on_dispell(self):
player = self._get_player()
Coin.add('points')
scoring.score_simple(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.assertEqual(player.points, 15)
dispell = Spell.objects.create(name='dispell',
available=True,
price=10)
player.magic.add_spell(dispell)
player.magic.cast_spell(dispell, player)
self.assertFalse(player.magic.has_modifier('top-disguise'))
player = Player.objects.get(pk=player.pk)
self.assertEqual(player.points, 10)
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 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 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 test_evade(self):
"""
Test for Evade spell
"""
player = self._get_player()
player2 = self._get_player(2)
initial_points = 10
scoring.setup_scoring()
Coin.add('points')
scoring.score_simple(player, 'points', initial_points)
self.assertEqual(player.points, initial_points)
# Create and apply evade
evade = Spell.objects.create(name='challenge-evade',
available=True,
price=25,
percents=100,
type='p')
obs = PlayerSpellDue.objects.create(player=player,
source=player,
spell=evade,
due=datetime.now() +
timedelta(days=1))
self.assertTrue(player.magic.has_modifier('challenge-evade'))
# Get 'chall-lost' expression. By default you still win 2 points when losing a challenge
formulas = ChallengeGame.get_formulas()
exp = formulas[1]['expression'] # this will be 'points=XX'
index = exp.find('=') + 1 # get position of '='
points = int(
exp[index:]) # get XX (nr of points won when losing challenge)
# Create challenge and make first player lose it
chall = Challenge.create(user_from=player2,
user_to=player,
ignore_questions=True)
chall.set_won_by_player(player2)
# If evade spell worked losing player should have initial_points + 'chall-lost' points
# Evade has 20% chance of activation so play challenge in loop while it activates
while player.points != initial_points + points:
player.points = initial_points
chall.set_expired()
chall = Challenge.create(user_from=player2,
user_to=player,
ignore_questions=True)
chall.set_won_by_player(player2)
# Check if final score is ok
self.assertEqual(player.points, initial_points + points)
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 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 '(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 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='******')
# 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 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 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 penalise(cls, player, formula, external_id=None):
coins = Coin.get('penalty')
if not coins is None:
score(user=player,
game=None,
formula=formula,
external_id=external_id)
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_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 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 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_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_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='******')
# 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_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 test_buy_spell(self):
Coin.add('gold')
Formula.add('buy-spell', expression="gold=-{price}")
spell = Spell.objects.create(name='test-spell', available=True, price=10)
player = User.objects.create_user('test', '*****@*****.**', password='******').get_profile()
scoring.score_simple(player, 'gold', 100)
self.assertEqual(player.coins['gold'], 100)
response = self.client.get(reverse('bazaar_home'))
self.assertTrue('test-spell' in response.content)
self.client.login(username='******', password='******')
response = self.client.get(reverse('bazaar_buy', kwargs={'spell': spell.id}))
self.assertFalse('error' in response.content)
player = Player.objects.get(user__username='******')
self.assertEqual(player.coins['gold'], 90)
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)
def test_buy_spell(self):
Coin.add("gold")
Formula.add("buy-spell", definition="gold=-{price}")
spell = Spell.objects.create(name="test-spell", available=True, price=10)
player = User.objects.create_user("test", "*****@*****.**", password="******").get_profile()
scoring.score_simple(player, "gold", 100)
self.assertEqual(player.coins["gold"], 100)
# TODO: interface test should not be here
response = self.client.get(reverse("bazaar_home"))
self.assertTrue("test-spell" in response.content)
self.client.login(username="******", password="******")
response = self.client.get(reverse("bazaar_buy", kwargs={"spell": spell.id}))
self.assertFalse("error" in response.content)
player = Player.objects.get(user__username="******")
self.assertEqual(player.coins["gold"], 90)
def sync_user(player):
""" Synchronise user points with database
"""
coin = Coin.get('points')
points = real_points(player)
if player.points != points and not player.magic.has_modifier('top-disguise'):
logging.debug('%s had %d instead of %d points' % (player, player.points, points))
player.points = points
player.level_no = God.get_level_for_points(player.points)
player.save()
def setup():
""" Prepare database for Scoring """
for cc in CORE_POINTS:
if not Coin.get(cc):
Coin.add(cc, name=cc)
# special case, gold is integer
gold = Coin.get('gold')
gold.integer = True
gold.save()
# iterate through games and register formulas
for game in get_games():
for formula in game.get_formulas():
if not Formula.get(formula.id):
Formula.add(formula)
# add wouso formulas
for formula in God.get_system_formulas():
if not Formula.get(formula.id):
Formula.add(formula)
def test_user_points(self):
coin = Coin.add("points")
player = self._get_player()
scoring.score_simple(player, "points", 10)
up = History.user_points(player.user)
self.assertTrue(up.has_key("wouso"))
self.assertTrue(up["wouso"].has_key(coin))
self.assertEqual(up["wouso"][coin], 10)
def test_user_points(self):
coin = Coin.add('points')
player = self._get_player()
scoring.score_simple(player, 'points', 10)
up = History.user_points(player.user)
self.assertTrue(up.has_key('wouso'))
self.assertTrue(up['wouso'].has_key(coin))
self.assertEqual(up['wouso'][coin], 10)
def test_user_points(self):
coin = Coin.add('points')
player = self._get_player()
scoring.score_simple(player, 'points', 10)
up = History.user_points(player.user)
self.assertTrue(up.has_key('wouso'))
self.assertTrue(up['wouso'].has_key(coin))
self.assertEqual(up['wouso'][coin], 10)
def test_buy_spell(self):
Coin.add('gold')
Formula.add('buy-spell', expression="gold=-{price}")
spell = Spell.objects.create(name='test-spell', available=True, price=10)
player = User.objects.create_user('test', '*****@*****.**', password='******').get_profile()
scoring.score_simple(player, 'gold', 100)
self.assertEqual(player.coins['gold'], 100)
# TODO: interface test should not be here
response = self.client.get(reverse('bazaar_home'))
self.assertTrue('test-spell' in response.content)
self.client.login(username='******', password='******')
response = self.client.get(reverse('bazaar_buy', kwargs={'spell': spell.id}))
self.assertFalse('error' in response.content)
player = Player.objects.get(user__username='******')
self.assertEqual(player.coins['gold'], 90)
def setup():
""" Prepare database for Scoring """
for cc in CORE_POINTS:
if not Coin.get(cc):
Coin.add(cc, name=cc)
# special case, gold is integer
gold = Coin.get('gold')
gold.integer = True
gold.save()
# iterate through games and register formulas
for game in get_games():
for formula in game.get_formulas():
if not Formula.get(formula.id):
Formula.add(formula)
# add wouso formulas
for formula in God.get_system_formulas():
if not Formula.get(formula.id):
Formula.add(formula)
def test_gold_amount_ach(self):
Artifact.objects.create(group=None, name='ach-gold-300')
player = self._get_player()
coin = Coin.add('gold')
scoring.score_simple(player, coin, amount=500)
signals.addActivity.send(sender=None, user_from=player,
user_to=player, action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-gold-300'))
def test_disguise_expire_on_dispell(self):
player = self._get_player()
Coin.add('points')
scoring.score_simple(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.assertEqual(player.points, 15)
dispell = Spell.objects.create(name='dispell', available=True, price=10)
player.magic.add_spell(dispell)
player.magic.cast_spell(dispell, player)
self.assertFalse(player.magic.has_modifier('top-disguise'))
player = Player.objects.get(pk=player.pk)
self.assertEqual(player.points, 10)
def sync_user(player):
""" Synchronise user points with database
"""
coin = Coin.get('points')
result = History.objects.filter(user=player.user,coin=coin).aggregate(total=models.Sum('amount'))
points = result['total'] if result['total'] is not None else 0
if player.points != points:
logging.debug('%s had %d instead of %d points' % (player, player.points, points))
player.points = points
player.level_no = God.get_level_for_points(player.points)
player.save()
def sync_user(player):
""" Synchronise user points with database
"""
coin = Coin.get("points")
result = History.objects.filter(user=player.user, coin=coin).aggregate(total=models.Sum("amount"))
points = result["total"] if result["total"] is not None else 0
if player.points != points and not player.magic.has_modifier("top-disguise"):
logging.debug("%s had %d instead of %d points" % (player, player.points, points))
player.points = points
player.level_no = God.get_level_for_points(player.points)
player.save()
def test_evade(self):
"""
Test for Evade spell
"""
player = self._get_player()
player2 = self._get_player(2)
initial_points = 10
scoring.setup_scoring()
Coin.add('points')
scoring.score_simple(player, 'points', initial_points)
self.assertEqual(player.points, initial_points)
# Create and apply evade
evade = Spell.objects.create(name='challenge-evade', available=True, price=25, percents=100, type='p')
obs = PlayerSpellDue.objects.create(player=player, source=player, spell=evade, due=datetime.now() + timedelta(days=1))
self.assertTrue(player.magic.has_modifier('challenge-evade'))
# Get 'chall-lost' expression. By default you still win 2 points when losing a challenge
formulas = ChallengeGame.get_formulas()
exp = formulas[1]['expression'] # this will be 'points=XX'
index = exp.find('=') + 1 # get position of '='
points = int(exp[index:]) # get XX (nr of points won when losing challenge)
# Create challenge and make first player lose it
chall = Challenge.create(user_from=player2, user_to=player, ignore_questions=True)
chall.set_won_by_player(player2)
# If evade spell worked losing player should have initial_points + 'chall-lost' points
# Evade has 20% chance of activation so play challenge in loop while it activates
while player.points != initial_points + points:
player.points = initial_points
chall.set_expired()
chall = Challenge.create(user_from=player2, user_to=player, ignore_questions=True)
chall.set_won_by_player(player2)
# Check if final score is ok
self.assertEqual(player.points, initial_points + points)
def test_gold_amount_ach(self):
Artifact.objects.create(group=None, name='ach-gold-300')
player = self._get_player()
coin = Coin.add('gold')
scoring.score_simple(player, coin, amount=500)
signals.addActivity.send(sender=None,
user_from=player,
user_to=player,
action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-gold-300'))
def sync_user(player):
""" Synchronise user points with database
"""
coin = Coin.get('points')
result = History.objects.filter(
user=player.user, coin=coin).aggregate(total=models.Sum('amount'))
points = result['total'] if result['total'] is not None else 0
if player.points != points:
logging.debug('%s had %d instead of %d points' %
(player, player.points, points))
player.points = points
player.level_no = God.get_level_for_points(player.points)
player.save()
def test_weakness(self):
"""
Test for Weakness spell
"""
initial_points = 100
win_points = 10
player_weakness = 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_weakness, 'points', initial_points)
formula = Formula.get('chall-won')
formula.expression = 'points=' + str(win_points)
formula.save()
# Apply weakness
weakness = Spell.objects.create(name='challenge-affect-scoring-lost',
available=True,
price=10,
percents=-66,
type='n')
obs = PlayerSpellDue.objects.create(player=player_weakness,
source=player_weakness,
spell=weakness,
due=datetime.now() +
timedelta(days=1))
# Win challenge with player_weakness
chall = Challenge.create(user_from=player_weakness,
user_to=player_dummy,
ignore_questions=True)
chall.set_won_by_player(player_weakness)
# Player should win weakness.percents less points with weakness applied
target_points = initial_points + win_points + weakness.percents / 100.0 * win_points
self.assertEqual(player_weakness.player_ptr.points, target_points)
def test_sync_methods(self):
player = self._get_player()
coin = Coin.add('points')
History.objects.create(user=player.user, coin=coin, amount=10)
self.assertEqual(player.points, 0)
scoring.sync_user(player)
self.assertEqual(player.points, 10)
History.objects.create(user=player.user, coin=coin, amount=10)
self.assertEqual(player.points, 10)
scoring.sync_all_user_points()
player = Player.objects.get(pk=player.pk)
self.assertEqual(player.points, 20)
def test_sync_methods(self):
player = self._get_player()
coin = Coin.add('points')
History.objects.create(user=player.user, coin=coin, amount=10)
self.assertEqual(player.points, 0)
scoring.sync_user(player)
self.assertEqual(player.points, 10)
History.objects.create(user=player.user, coin=coin, amount=10)
self.assertEqual(player.points, 10)
scoring.sync_all_user_points()
player = Player.objects.get(pk=player.pk)
self.assertEqual(player.points, 20)
def test_scoring_loss(self):
initial_points = 10
winner = self._get_player(1).get_extension(ChallengeUser)
loser = self._get_player(2).get_extension(ChallengeUser)
# Setup scoring
scoring.setup_scoring()
Coin.add('points')
# Give initial points
scoring.score_simple(winner, 'points', initial_points)
scoring.score_simple(loser, 'points', initial_points)
# Set formula
loss_points = -2
formula = Formula.get('chall-lost')
formula.expression = 'points=' + str(loss_points)
formula.save()
# Play challenge
chall = Challenge.create(user_from=winner, user_to=loser, ignore_questions=True)
chall.set_won_by_player(winner)
self.assertEqual(loser.player_ptr.points, initial_points + loss_points) # loss_points is negative
def test_level_ach(self):
Artifact.objects.create(group=None, name='ach-level-5')
Artifact.objects.create(group=None, name='ach-level-10')
coin = Coin.add('gold')
player = self._get_player()
player.level_no = 5
player.save()
signals.addActivity.send(sender=None, user_from=player,
user_to=player, action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-level-5'))
player.level_no = 10
player.save()
signals.addActivity.send(sender=None, user_from=player,
user_to=player, action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-level-10'))
def history_for(user, game, external_id=None, formula=None, coin=None):
""" Return all history entries for given (user, game) pair.
"""
# TODO: check usage
fltr = {}
if external_id:
fltr['external_id'] = external_id
if formula:
fltr['formula'] = Formula.get(formula)
if coin:
fltr['coin'] = Coin.get(coin)
if not isinstance(game, Game):
game = game.get_instance()
if not isinstance(user, User):
user = user.user
try:
return History.objects.filter(user=user, game=game, **fltr)
except History.DoesNotExist:
return None
def history_for(user, game, external_id=None, formula=None, coin=None):
""" Return all history entries for given (user, game) pair.
"""
# TODO: check usage
fltr = {}
if external_id:
fltr["external_id"] = external_id
if formula:
fltr["formula"] = Formula.get(formula)
if coin:
fltr["coin"] = Coin.get(coin)
if not isinstance(game, Game):
game = game.get_instance()
if not isinstance(user, User):
user = user.user
try:
return History.objects.filter(user=user, game=game, **fltr)
except History.DoesNotExist:
return None
def test_level_ach(self):
Artifact.objects.create(group=None, name='ach-level-5')
Artifact.objects.create(group=None, name='ach-level-10')
coin = Coin.add('gold')
player = self._get_player()
player.level_no = 5
player.save()
signals.addActivity.send(sender=None,
user_from=player,
user_to=player,
action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-level-5'))
player.level_no = 10
player.save()
signals.addActivity.send(sender=None,
user_from=player,
user_to=player,
action='gold-won',
game=None)
self.assertTrue(player.magic.has_modifier('ach-level-10'))
def real_points(player):
coin = Coin.get('points')
result = History.objects.filter(
user=player.user, coin=coin).aggregate(total=models.Sum('amount'))
return result['total'] if result['total'] is not None else 0
def test_setup(self):
for c in CORE_POINTS:
self.assertFalse(Coin.get(c))
setup_scoring()
for c in CORE_POINTS:
self.assertTrue(Coin.get(c))
def test_user_coins(self):
Coin.add('points')
Coin.add('gold')
player = self._get_player()
self.assertIn('points', History.user_coins(player.user))
def check_setup():
""" Check if the module has been setup """
if Coin.get('points') is None:
return False
return True
