def test_post_challenge(self):
# create an active challenge, with fake questions
Formula.add('chall-warranty')
Formula.add('chall-timer')
category = Category.add('challenge')
for i in range(Challenge.LIMIT + 1):
q = Question.objects.create(text='text %s' % i, category=category, active=True)
for j in range(5):
Answer.objects.create(correct=j==1, question=q)
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser)
chall.accept()
response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
data = json.loads(response.content)
self.assertTrue(data)
self.assertEqual(data['status'], 'A')
self.assertEqual(data['to'], self.challuser.user.username)
self.assertEqual(len(data['questions']), Challenge.LIMIT)
# attempt post
data = {}
for q in Question.objects.all():
answers = []
for a in q.correct_answers:
answers.append(str(a.id))
data[q.id] = ','.join(answers)
response = self.client.post('/api/challenge/{id}/'.format(id=chall.id), data)
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertTrue(data['success'])
self.assertEqual(data['result']['points'], Challenge.LIMIT * 100)
def test_post_challenge(self):
# create an active challenge, with fake questions
Formula.add('chall-warranty')
Formula.add('chall-timer')
category = Category.add('challenge')
for i in range(Challenge.LIMIT + 1):
q = Question.objects.create(text='text %s' % i, category=category, active=True)
for j in range(5):
Answer.objects.create(correct=j==1, question=q)
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser)
chall.accept()
response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
data = json.loads(response.content)
self.assertTrue(data)
self.assertEqual(data['status'], 'A')
self.assertEqual(data['to'], self.challuser.user.username)
self.assertEqual(len(data['questions']), Challenge.LIMIT)
# attempt post
data = {}
for q in Question.objects.all():
answers = []
for a in q.correct_answers:
answers.append(str(a.id))
data[q.id] = ','.join(answers)
response = self.client.post('/api/challenge/{id}/'.format(id=chall.id), data)
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertTrue(data['success'])
self.assertEqual(data['result']['points'], Challenge.LIMIT * 100)
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_paralyze(self):
"""
Test if Paralyze spell works
"""
Formula.add('chall-warranty')
player = self._get_player()
chall_user = player.get_extension(ChallengeUser)
# Check if player can launch before spell is cast
self.assertTrue(chall_user.can_launch())
# Create and add spell to user
paralyze = Spell.objects.create(name='challenge-cannot-challenge',
available=True,
price=10,
percents=100,
type='n')
obs = PlayerSpellDue.objects.create(player=chall_user,
source=chall_user,
spell=paralyze,
due=datetime.now() +
timedelta(days=1))
# Check if player has the modifier
self.assertTrue(
chall_user.magic.has_modifier('challenge-cannot-challenge'))
# Player should not be able to launch challenge with Paralyze on
self.assertFalse(chall_user.can_launch())
def test_get_challenge(self):
# create an active challenge
Formula.add('chall-warranty')
Formula.add('chall-timer')
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
chall.accept()
response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
data = json.loads(response.content)
self.assertTrue(data)
self.assertEqual(data['status'], 'A')
self.assertEqual(data['to'], self.challuser.user.username)
def test_get_challenge(self):
# create an active challenge
Formula.add('chall-warranty')
Formula.add('chall-timer')
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
chall.accept()
response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
data = json.loads(response.content)
self.assertTrue(data)
self.assertEqual(data['status'], 'A')
self.assertEqual(data['to'], self.challuser.user.username)
def get_formulas(kls):
""" Returns a list of formulas used by qotd """
fs = []
quest_game = kls.get_instance()
fs.append(Formula(id='quest-ok', formula='points={level}',
owner=quest_game.game,
description='Points earned when finishing a level. Arguments: level.')
)
fs.append(Formula(id='quest-finish-ok', formula='points=10',
owner=quest_game.game,
description='Bonus points earned when finishing the entire quest. No arguments.')
)
return fs
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 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 calculate(formula, **params):
""" Calculate formula and return a dictionary of coin and amounts """
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.formula:
return {}
ret = {}
try:
frml = formula.formula.format(**params)
# Apparently, Python does not allow assignments inside eval
# Using this workaround for now
ass = frml.split(";")
for a in ass:
asp = a.split("=")
coin = asp[0].strip()
expr = "=".join(asp[1:])
try:
result = eval(expr)
except ZeroDivisionError as e:
result = 0
ret[coin] = result
except Exception as e:
logging.exception(e)
raise FormulaParsingError(formula)
return ret
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 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_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 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_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_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 calculate(formula, **params):
""" Calculate formula and return a dictionary of coin and amounts """
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
ret = {}
try:
frml = formula.formula.format(**params)
# Apparently, Python does not allow assignments inside eval
# Using this workaround for now
ass = frml.split(';')
for a in ass:
asp = a.split('=')
coin = asp[0].strip()
expr = '='.join(asp[1:])
try:
result = eval(expr)
except ZeroDivisionError as e:
result = 0
ret[coin] = result
except Exception as e:
raise FormulaParsingError(e)
return ret
def test_list_active(self):
response = self.client.get('/api/challenge/list/')
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertFalse(data)
# create an active challenge
Formula.add('chall-warranty')
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
response = self.client.get('/api/challenge/list/')
data = json.loads(response.content)
self.assertTrue(data)
data = data[0]
self.assertEqual(data['id'], chall.id)
def test_list_active(self):
response = self.client.get('/api/challenge/list/')
self.assertEqual(response.status_code, 200)
data = json.loads(response.content)
self.assertFalse(data)
# create an active challenge
Formula.add('chall-warranty')
chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
response = self.client.get('/api/challenge/list/')
data = json.loads(response.content)
self.assertTrue(data)
data = data[0]
self.assertEqual(data['id'], chall.id)
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_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 unset(user, game, formula, external_id=None, **params):
""" Remove all history records by the external_id, formula and game given to the user """
formula = Formula.get(formula)
for history in History.objects.filter(user=user, game=game.get_instance(), formula=formula, external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
update_points(user, game)
def rollback(user, game, formula, external_id=None, **params):
if game != None:
game = game.get_instance()
formula = Formula.get(formula)
for history in History.objects.filter(user=user, game=game, formula=formula, external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
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 get_formulas(kls):
""" Returns a list of formulas used by qotd """
fs = []
qotd_game = kls.get_instance()
fs.append(
Formula(id='qotd-ok',
formula='points=3',
owner=qotd_game.game,
description='Points earned on a correct answer'))
return fs
def unset(user, game, formula, external_id=None, **params):
""" Remove all history records by the external_id, formula and game given to the user """
formula = Formula.get(formula)
user = user.user.get_profile() # make sure you are working on fresh Player
for history in History.objects.filter(user=user, game=game.get_instance(), formula=formula, external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
update_points(user, game)
def get_formulas(kls):
fs = []
quest_game = kls.get_instance()
fs.append(
Formula(id='specialquest-passed',
formula='gold={value}',
owner=quest_game.game,
description=
'Points earned when finishing a task. Arguments: value.'))
return fs
def activity_handler(cls, sender, **kwargs):
action = kwargs.get('action', None)
rules = filter(lambda x : x[2]==action, cls.SECURITY_RULES)
for rule in rules:
# check if rule is not disabled
if not BoolSetting.objects.get(pk__startswith='disable-%s' % rule[0]).get_value():
(guilty, player, external_id) = SecurityInspector.check(rule[0], **kwargs)
if guilty:
formula = Formula.get('%s-infraction' % rule[0], 'general-infraction')
cls.penalise(player, formula, external_id)
def calculate(formula, **params):
""" Calculate formula and return a dictionary of coin and amounts """
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.definition:
return {}
return calculate_definition(formula.definition, formula, **params)
def rollback(user, game, formula, external_id=None, **params):
if game is not None:
game = game.get_instance()
formula = Formula.get(formula)
user = user.user.get_profile() # make sure you are working on fresh Player
for history in History.objects.filter(user=user, game=game, formula=formula, external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
def calculate(formula, **params):
""" Calculate formula and return a dictionary of coin and amounts """
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.expression:
return {}
return calculate_expression(formula.expression, formula, **params)
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 karma_group_view(request, id):
group = get_object_or_404(PlayerGroup, pk=id)
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]
# Skip if there are no karma points
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', id=id)
else:
form = KarmaBonusForm(players=players)
return render_to_response('cpanel/karma_group.html', {
'form': form,
'group': group
},
context_instance=RequestContext(request))
def test_variable_timer(self):
formula = Formula.add('chall-timer')
formula.expression = 'tlimit=10'
formula.save()
self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), 10)
formula.expression = 'tlimit={level}'
formula.save()
self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), self.chall_user.level_no)
def test_variable_timer(self):
formula = Formula.add('chall-timer')
formula.expression = 'tlimit=10'
formula.save()
self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), 10)
formula.expression = 'tlimit={level}'
formula.save()
self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), self.chall_user.level_no)
def rollback(user, game, formula, external_id=None, **params):
if game != None:
game = game.get_instance()
formula = Formula.get(formula)
for history in History.objects.filter(user=user,
game=game,
formula=formula,
external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
def activity_handler(cls, sender, **kwargs):
action = kwargs.get('action', None)
rules = filter(lambda x: x[2] == action, cls.SECURITY_RULES)
for rule in rules:
# check if rule is not disabled
if not BoolSetting.objects.filter(pk__startswith='%s' % rule[0]):
(guilty, player,
external_id) = SecurityInspector.check(rule[0], **kwargs)
if guilty:
formula = Formula.get('%s-infraction' % rule[0],
'general-infraction')
cls.penalise(player, formula, external_id)
def test_paralyze(self):
"""
Test if Paralyze spell works
"""
Formula.add('chall-warranty')
player = self._get_player()
chall_user = player.get_extension(ChallengeUser)
# Check if player can launch before spell is cast
self.assertTrue(chall_user.can_launch())
# Create and add spell to user
paralyze = Spell.objects.create(name='challenge-cannot-challenge', available=True, price=10, percents=100, type='n')
obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=paralyze, due=datetime.now() + timedelta(days=1))
# Check if player has the modifier
self.assertTrue(chall_user.magic.has_modifier('challenge-cannot-challenge'))
# Player should not be able to launch challenge with Paralyze on
self.assertFalse(chall_user.can_launch())
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 rollback(user, game, formula, external_id=None, **params):
if game is not None:
game = game.get_instance()
formula = Formula.get(formula)
user = user.user.get_profile() # make sure you are working on fresh Player
for history in History.objects.filter(user=user,
game=game,
formula=formula,
external_id=external_id):
if history.coin.name == 'points':
user.points -= history.amount
history.delete()
user.save()
def timer(user, game, formula, default=300, **params):
""" Compute a timer value, or return default
"""
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.formula:
return default
values = calculate(formula, **params)
if values.has_key("tlimit"):
return values["tlimit"]
return default
def timer(user, game, formula, default=300, **params):
""" Compute a timer value, or return default
"""
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.definition:
return default
values = calculate(formula, **params)
if values.has_key('tlimit'):
return values['tlimit']
return default
def timer(user, game, formula, default=300, **params):
""" Compute a timer value, or return default
"""
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.expression:
return default
values = calculate(formula, **params)
if 'tlimit' in values:
return values['tlimit']
return default
def timer(user, game, formula, default=300, **params):
""" Compute a timer value, or return default
"""
formula = Formula.get(formula)
if formula is None:
raise InvalidFormula(formula)
if not formula.expression:
return default
values = calculate(formula, **params)
if 'tlimit' in values:
return values['tlimit']
return default
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 get_formulas(kls):
""" Returns a list of formulas used by qotd """
fs = []
chall_game = kls.get_instance()
fs.append(Formula(id='chall-won', formula='points=6+{different_race}+{different_class}',
owner=chall_game.game,
description='Points earned when winning a challenge. Arguments: different_race (int 0,1), different_class (int 0,1)')
)
fs.append(Formula(id='chall-lost', formula='points=2',
owner=chall_game.game,
description='Points earned when losing a challenge')
)
fs.append(Formula(id='chall-draw', formula='points=4',
owner=chall_game.game,
description='Points earned when drawing a challenge')
)
fs.append(Formula(id='chall-warranty', formula='points=-3',
owner=chall_game.game,
description='Points taken as a warranty for challenge'))
fs.append(Formula(id='chall-warranty-return', formula='points=3',
owner=chall_game.game,
description='Points given back as a warranty taken for challenge'))
return fs
def testScoring(self):
chall = Challenge.create(user_from=self.chall_user, user_to=self.chall_user2, ignore_questions=True)
chall.user_from.seconds_took = 10
chall.user_from.score = 100
chall.user_from.save()
chall.user_to.seconds_took = 10
chall.user_to.score = 10
chall.user_to.save()
# TODO: improve usage of formulas inside tests.
formula = Formula.get('chall-won')
formula.expression = 'points=10 + min(10, int(3 * {winner_points}/{loser_points}))'
formula.save()
chall.played()
def testScoring(self):
chall = Challenge.create(user_from=self.chall_user, user_to=self.chall_user2, ignore_questions=True)
chall.user_from.seconds_took = 10
chall.user_from.score = 100
chall.user_from.save()
chall.user_to.seconds_took = 10
chall.user_to.score = 10
chall.user_to.save()
# TODO: improve usage of formulas inside tests.
formula = Formula.get('chall-won')
formula.expression = 'points=10 + min(10, int(3 * {winner_points}/{loser_points}))'
formula.save()
chall.played()
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 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('details_player', pk=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 get_system_formulas(self):
""" Return formulas used by the meta wouso game.
If inherited, should not override super's result, but extend it.
"""
from wouso.core.scoring.models import Formula
fs = []
fs.append(
Formula(id='buy-spell',
formula='gold=-{price}',
owner=None,
description='Gold spent on spells'))
fs.append(
Formula(id='gold-points-rate',
formula='points={gold}*3;gold=-{gold}',
owner=None,
description='Exchange gold in points'))
fs.append(
Formula(id='points-gold-rate',
formula='points=-{points};gold={points}*0.1',
owner=None,
description='Exchange points in gold'))
fs.append(
Formula(id='bonus-gold',
formula='gold={gold}',
owner=None,
description='Give bonus gold to the poor people'))
fs.append(
Formula(id='bonus-points',
formula='points={points}',
owner=None,
description='Give bonus points'))
fs.append(
Formula(id='steal-points',
formula='points={points}',
owner=None,
description='Steal points using spells'))
fs.append(
Formula(id='penalty-points',
formula='points=-{points}',
owner=None,
description='Take back points from user'))
return fs
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_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_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 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)
