def test_doesnt_find_winner(self):
board = pickle.dumps(['', '', '', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2,
board=board)
winner = game.get_winner()
self.assertEqual(winner, None)
def accept_invite(request, key):
try:
invite = GameInvite.objects.get(invite_key=key, is_active=True)
except GameInvite.DoesNotExist:
raise Http404
if not request.user == invite.inviter:
coin_toss = random.choice([0, 1])
if coin_toss == 0:
game = Game(player1=invite.inviter, player2=request.user)
else:
game = Game(player1=request.user, player2=invite.inviter)
game.save()
red = redis.StrictRedis(REDIS_HOST)
red.publish('%d' % invite.inviter.id, ['game_started', game.id, str(request.user.username)])
# No reason to keep the invites around
invite.delete()
return redirect('view_game', game_id=game.id)
raise Http404
def test_finds_winner(self):
"""
Tests that getting a winner works properly
"""
board = pickle.dumps(['X', 'X', 'X', '', '', '', '', '', ''])
game = Game(board=board)
winner = game.get_winner()
self.assertEqual(winner, 'X')
def switch_to_vote_results(game: Game):
game.phase = GamePhase.VOTE_RESULTS.value
game.save()
send_event(
"game-%s" % game.uuid.hex,
"message",
VoteResultsStartsMessage(game).serialize(),
)
def test_doesnt_gets_valid_moves(self):
"""
Tests that getting valid moves works properly
"""
board = pickle.dumps(['X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'])
game = Game(board=board)
moves = game.get_valid_moves()
self.assertEqual(len(moves), 0)
def test_doesnt_gets_valid_moves(self):
"""
Tests that getting valid moves works properly
"""
board = pickle.dumps(['X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'])
game = Game(player1=self.player1, player2=self.player2, board=board)
moves = game.get_valid_moves()
self.assertEqual(len(moves), 0)
def test_finds_winner(self):
"""
Tests that getting a winner works properly
"""
board = pickle.dumps(['X', 'X', 'X', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2, board=board)
winner = game.get_winner()
self.assertEqual(winner, 'X')
def test_gets_valid_moves(self):
"""
Tests that getting valid moves works properly
"""
board = pickle.dumps(['', '', '', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2,
board=board)
moves = game.get_valid_moves()
self.assertEqual(len(moves), 9)
def test_two_over_one(self):
game = Game(user1=self.user_one, user2=self.user_two, status=Game.STATUS_TURN_TWO,
grid=[2, 0, 2, 2, 1, 2, 1, 2, 1])
game.save()
self.set_authentication(self.user_two)
response = self.client.post(reverse('game-detail', args=[game.pk]) + 'set/',
{'square': 5}, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.content)
def start_debrief(game: Game):
game.phase = GamePhase.DEBRIEF.value
game.current_round = None
game.pads_done = 0
game.save()
send_event(
"game-%s" % game.uuid.hex,
"message",
DebriefStartsMessage(game).serialize(),
)
def test_find_tie(self):
"""
Tests that you get a tie when the board is full
"""
board = pickle.dumps(['X', 'X', 'O', 'O', 'O', 'X', 'X', 'O', 'X'])
game = Game(player1=self.player1, player2=self.player2, board=board)
winner = game.get_winner()
self.assertEqual(winner, '')
def test_defend_special(self):
'''
tests first of the special cases
'''
board = pickle.dumps({0: 'X', 1: '', 2: '',
3: '', 4: 'O', 5: '',
6: '', 7: '', 8: 'X'})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 1)
def test_block_el_6(self):
'''
checks a random additional el pattern
'''
board = pickle.dumps({0: 'X', 1: '', 2: '',
3: '', 4: 'O', 5: '',
6: '', 7: 'X', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 6)
def new_game(request):
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
stack = int(request.POST['stack_amount'])
blinds = int(stack // 75)
user = User.objects.create_user(username=username,
email=email,
password=password)
login(request, user)
newDeck = Deck()
newDeck.save()
#new deck
cardTuples = [(i, j) for i in range(2, 15) for j in range(1, 5)]
random.shuffle(cardTuples)
for (i, j) in cardTuples:
newCard = Card(value=i, suit=j)
newCard.save()
newDeck.cards.add(newCard)
x1, x2 = newDeck.deal(), newDeck.deal()
y1, y2 = newDeck.deal(), newDeck.deal()
#deal players new hand
playerHand = Hand()
playerHand.save()
playerHand.cards.add(x1)
playerHand.cards.add(x2)
botHand = Hand()
botHand.save()
botHand.cards.add(y1)
botHand.cards.add(y2)
board = Board(player=request.user)
board.save()
boardCards = [newDeck.deal() for i in range(5)]
for bc in boardCards:
board.cards.add(bc)
newGame = Game(player_name=request.user.username, player=request.user,\
player_stack=stack, bot_stack=stack, player_hand=playerHand, \
bot_hand=botHand, board=board, street=0, blinds=blinds)
newGame.save()
#start a new hand
return redirect('/newhand')
def test_defend_center(self):
"""
Tests that first choice is center if no other issues
to be taken care of
"""
board = pickle.dumps({0: 'X', 1: '', 2: '',
3: '', 4: '', 5: '',
6: '', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 4)
def test_defend_corner(self):
"""
Tests that first choice is corner if center is taken
and no other issues.
"""
board = pickle.dumps({0: 'X', 1: '', 2: '',
3: '', 4: 'O', 5: 'X',
6: '', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 2)
def test_make_move(self):
"""
Tests that you can make moves
"""
board = pickle.dumps(['', '', '', '', '', '', '', '', ''])
game = Game(board=board)
game.make_move('X', 0)
board = pickle.dumps(['X', '', '', '', '', '', '', '', ''])
self.assertEqual(board, game.board)
def test_win_two(self):
game = Game(user1=self.user_one, user2=self.user_two, status=Game.STATUS_TURN_TWO,
grid=[2, 0, 2, 2, 1, 2, 1, 2, 1])
game.save()
self.set_authentication(self.user_two)
response = self.client.post(reverse('game-detail', args=[game.pk]) + 'set/',
{'square': 1}, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)
game_obj = json.loads(response.content)
self.assertEqual(game_obj['status'], Game.STATUS_WIN_TWO)
def test_find_tie(self):
"""
Tests that you get a tie when the board is full
"""
board = pickle.dumps(['X', 'X', 'O',
'O', 'O', 'X',
'X', 'O', 'X'])
game = Game(board=board)
winner = game.get_winner()
self.assertEqual(winner, '')
def test_make_move(self):
"""
Tests that you can make moves
"""
board = pickle.dumps(['', '', '', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2, board=board)
game.make_move('X', 0)
board = pickle.dumps(['X', '', '', '', '', '', '', '', ''])
self.assertEqual(board, game.board)
self.assertEqual('X', game.last_move)
def setUp(self):
self.player1 = User.objects.create(username='******')
self.player1.set_password('test')
self.player2 = User.objects.create(username='******')
self.player1.save()
self.player2.save()
self.game = Game(player1=self.player1, player2=self.player2)
self.game.save()
self.client = Client()
self.client.login(username='******', password='******')
def test_win(self):
'''
tests that winning is first choice
'''
board = pickle.dumps({0: 'X', 1: '', 2: 'O',
3: '', 4: '', 5: '',
6: 'X', 7: '', 8: 'O'})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 5)
board = pickle.dumps({0: 'X', 1: 'O', 2: 'X',
3: '', 4: 'O', 5: '',
6: 'O', 7: '', 8: 'X'})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 7)
board = pickle.dumps({0: 'X', 1: 'O', 2: 'X',
3: '', 4: 'O', 5: '',
6: 'X', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 7)
board = pickle.dumps({0: 'X', 1: '', 2: 'X',
3: '', 4: 'O', 5: '',
6: '', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 1)
def test_can_be_synced(self):
game = Game(publish_date=AN_IRRELEVANT_YEAR, name="an_irrelevant_name")
game.save()
fetched_game = FetchedGame(publish_date=AN_IRRELEVANT_YEAR,
name="an_irrelevant_name")
fetched_game.fg_game = game
fetched_game.save()
self.assertFalse(fetched_game.is_sync)
fetched_game.mark_as_synchronized()
fetched_game.save()
self.assertTrue(fetched_game.is_sync)
def switch_to_rounds(game: Game):
game.phase = GamePhase.ROUNDS.value
game.current_round = 0
game.pads_done = 0
game.save()
for pad in game.pads.all():
step = pad.steps.get(round_number=game.current_round)
step.sentence = pad.sentence
step.save()
send_event(
"game-%s" % game.uuid.hex,
"message",
RoundStartsMessage(game, 0).serialize(),
)
def test_becomes_unsync_when_modified(self):
game = Game(publish_date=AN_IRRELEVANT_YEAR, name="an_irrelevant_name")
game.save()
fetched_game = FetchedGame(publish_date=AN_IRRELEVANT_YEAR,
name="an_irrelevant_name")
fetched_game.fg_game = game
# As it is a new entity, upon saving its modified date will change, so need to sync afterwards
fetched_game.save()
fetched_game.mark_as_synchronized()
fetched_game.save()
self.assertTrue(fetched_game.is_sync)
fetched_game.name = "another_irrelevant_name"
fetched_game.save()
self.assertFalse(fetched_game.is_sync)
def _use_commit(self, team):
# You can't simply add to balance, as there may be some constraints (e.g. licences)
with Transaction() as t:
t.add(team, self.entity, self.value)
self.used_by = team
self.used_time = Game.game_time()
self.save()
def test_game_unicode_output(self):
"""
Tests that we are returning a human readable string
"""
board = pickle.dumps(['X', 'X', 'X', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2, board=board)
self.assertEqual("X vs O (['X', 'X', 'X', '', '', '', '', '', ''])",
str(game))
def get_queryset(self) -> Optional[QuerySet]:
if not self.q:
return None
queryset = Game.objects.filter(
name_for_search__contains=Game.clean_name_for_search(self.q))
queryset = queryset.order_by(Length("name"), Lower("name"))
return queryset
def public_connected(message):
print("New connection on public channel from %s" % message.user)
Group('public').add(message.reply_channel)
game = Game.get_active()
for i in game.productionstat_set.order_by('-time'):
i.broadcast(request=message)
for i in game.consumptionstat_set.order_by('-time'):
i.broadcast(request=message)
def create_computer_game(request):
bot = _get_computer()
coin_toss = random.choice([0, 1])
if coin_toss == 0:
game = Game(player1=request.user, player2=bot)
else:
game = Game(player1=bot, player2=request.user)
game.save()
if coin_toss == 1:
board = game.get_board()
move, board = _create_computer_move(game, board)
GameMove(game=game, player=bot, move=move).save()
return redirect('view_game', game_id=game.id)
def test_keeps_synced_if_not_modified(self):
name = "an_irrelevant_name"
publish_date = AN_IRRELEVANT_YEAR
game = Game(publish_date=publish_date, name=name)
game.save()
fetched_game = FetchedGame(publish_date=publish_date, name=name)
fetched_game.fg_game = game
# As it is a new entity, upon saving its modified date will change, so need to sync afterwards
fetched_game.save()
fetched_game.mark_as_synchronized()
fetched_game.save()
self.assertTrue(fetched_game.is_sync)
fetched_game.name = name
fetched_game.save()
self.assertTrue(fetched_game.is_sync)
fetched_game.publish_date = publish_date
fetched_game.save()
self.assertTrue(fetched_game.is_sync)
def start_next_round(game: Game, new_round: int):
round_count = get_round_count(game)
if new_round >= round_count:
return start_debrief(game)
game.current_round = new_round
game.pads_done = 0
game.save()
for pad in game.pads.all():
previous_step = pad.steps.get(round_number=new_round - 1)
step = pad.steps.get(round_number=new_round)
if new_round % 2 == 0:
step.sentence = previous_step.sentence
else:
step.drawing = previous_step.drawing
step.save()
send_event(
"game-%s" % game.uuid.hex,
"message",
RoundStartsMessage(game, round_number=new_round).serialize(),
)
def accept_invite(request, key):
try:
invite = GameInvite.objects.get(invite_key=key, is_active=True)
except GameInvite.DoesNotExist:
raise Http404
if not request.user == invite.inviter:
coin_toss = random.choice([0, 1])
if coin_toss == 0:
game = Game(player1=invite.inviter, player2=request.user)
else:
game = Game(player1=request.user, player2=invite.inviter)
game.save()
red = redis.StrictRedis(REDIS_HOST)
red.publish('%d' % invite.inviter.id, ['game_started', game.id, str(request.user.username)])
# No reason to keep the invites around
invite.delete()
return redirect('view_game', game_id=game.id)
raise Http404
def setUp(self):
self.player1 = User.objects.create(username='******')
self.player1.set_password('test')
self.player2 = User.objects.create(username='******')
self.player1.save()
self.player2.save()
self.game = Game(player1=self.player1, player2=self.player2)
self.game.save()
self.client = Client()
self.client.login(username='******', password='******')
def _create_game(fake, prefix, group, tags):
"""Generate and save a tag object."""
game_dict = {
"name": ' '.join(fake.sentence().split(' ')[:2]).title(),
"description": fake.paragraph(),
"image": None,
"group": group,
"event_name": fake.word().capitalize()
}
g = Game(**game_dict)
g.save()
g.tags = tags
g.date_published = fake.date_time()
g.save()
return g
def process(games, params):
id = int(params[0])
date = get_date(params[1])
player1_name = normalize_name(params[2])
score1 = int(params[3])
player2_name = normalize_name(params[4])
score2 = int(params[5])
# get cached players
player1 = player_cache.get(unique=player1_name)
player2 = player_cache.get(unique=player2_name)
# get cached statistics
stat1 = statistic_cache.get(unique=player1.pk)
stat2 = statistic_cache.get(unique=player2.pk)
this_game = Game(player1=player1,
score1=score1,
elo1=player1.elo,
player2=player2,
score2=score2,
elo2=player2.elo,
verified=True,
date=date)
this_game.calculate()
games.append(this_game)
# update ratings and stats
player1.elo += this_game.change
player2.elo -= this_game.change
stat1.games += 1
stat2.games += 1
if this_game.player1_win():
stat1.wins += 1
else:
stat2.wins += 1
def handle(self, *args, **options):
for g in Game.objects.all():
g.delete()
for s in Statistics.objects.all():
s.delete()
with open(options['la_liga_csv']) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
line_count += 1
else:
local_team = Statistics(
team=Team.objects.get(name=row[3]),
half_time_goals=row[8],
full_time_goals=row[5],
shots=row[11],
shots_on_target=row[13],
corners=row[17],
fouls_committed=row[15],
yellow_cards=row[19],
red_cards=row[21]
)
away_team = Statistics(
team=Team.objects.get(name=row[4]),
half_time_goals=row[9],
full_time_goals=row[6],
shots=row[12],
shots_on_target=row[14],
corners=row[18],
fouls_committed=row[16],
yellow_cards=row[20],
red_cards=row[22]
)
local_team.save()
away_team.save()
Game(
local_team=Team.objects.get(name=row[3]),
away_team=Team.objects.get(name=row[4]),
date=datetime.strptime(row[1], '%d/%m/%Y'),
local_team_statistics=local_team,
away_team_statistics=away_team,
).save()
line_count += 1
print(f'Processed {line_count} lines.')
def get_queryset(self) -> Optional[QuerySet]:
# if in the future used from other places, remove the username present requirement
username = self.forwarded.get("username")
if not self.q or not username:
return None
# Not a Game, but not worth duplicating or abstracting logic just for this cleaning
query = Game.clean_name_for_search(self.q)
queryset = Platform.objects.filter(
shortname__contains=query) | Platform.objects.filter(
name__contains=query)
# comes from PlatformFilterform
filter_type = self.forwarded.get("filter_type", "")
if filter_type == constants.PLATFORM_FILTER_WISHLISTED:
queryset = queryset.filter(
id__in=WishlistedUserGame.objects.filter(
user__username=username).values_list("platform__id",
flat=True).distinct())
elif filter_type == constants.PLATFORM_FILTER_FINISHED:
queryset = queryset.filter(id__in=UserGame.objects.filter(
user__username=username, year_finished__isnull=False
).values_list("platform__id", flat=True).distinct())
elif filter_type == constants.PLATFORM_FILTER_PENDING:
queryset = queryset.filter(id__in=UserGame.objects.filter(
user__username=username).exclude(
year_finished__isnull=False).exclude(
abandoned=True).values_list("platform__id",
flat=True).distinct())
elif filter_type == constants.PLATFORM_FILTER_ABANDONED:
queryset = queryset.filter(id__in=UserGame.objects.filter(
user__username=username, abandoned=True).values_list(
"platform__id", flat=True).distinct())
elif filter_type == constants.PLATFORM_FILTER_CURRENTLY_PLAYING:
queryset = queryset.filter(id__in=UserGame.objects.filter(
user__username=username, currently_playing=True).values_list(
"platform__id", flat=True).distinct())
queryset = queryset.only("id",
"shortname").order_by(Length("shortname"),
Lower("shortname"))
return queryset
def event_received(event):
if event.event == event.EVENT_PLAYER_JOINED:
update_stats()
elif event.event == event.EVENT_PLAYER_LEFT:
update_stats()
elif event.event == event.EVENT_ROCKET_LAUNCHED:
# See if we have a winner
servers = Server.objects.all()
active_game = Game.get_active()
if not active_game.game_over:
active_game.game_over = True
active_game.save()
for server in servers:
if server == event.server: # This is the winning server
server.message(PACK_WIN)
else:
server.message(PACK_LOSE) # This is the losing server
def create_computer_game(request):
bot = _get_computer()
coin_toss = random.choice([0, 1])
if coin_toss == 0:
game = Game(player1=request.user, player2=bot)
else:
game = Game(player1=bot, player2=request.user)
game.save()
if coin_toss == 1:
board = game.get_board()
move, board = _create_computer_move(game, board)
GameMove(game=game, player=bot, move=move).save()
return redirect('view_game', game_id=game.id)
def test_block_el_8(self):
'''
checks all three possibilities of lower right corner el
'''
board = pickle.dumps({0: '', 1: '', 2: '',
3: '', 4: 'O', 5: 'X',
6: '', 7: 'X', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 8)
board = pickle.dumps({0: '', 1: '', 2: 'X',
3: '', 4: 'O', 5: '',
6: '', 7: 'X', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 8)
board = pickle.dumps({0: '', 1: '', 2: '',
3: '', 4: 'O', 5: 'X',
6: 'X', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 8)
def test_defend(self):
"""
random defence tests
"""
board = pickle.dumps({0: 'X', 1: '', 2: 'X',
3: '', 4: 'O', 5: '',
6: '', 7: '', 8: ''})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 1)
board = pickle.dumps({0: 'X', 1: '', 2: 'O',
3: '', 4: 'O', 5: '',
6: '', 7: '', 8: 'X'})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 6)
board = pickle.dumps({0: 'X', 1: 'O', 2: 'X',
3: '', 4: 'O', 5: '',
6: 'O', 7: 'X', 8: 'X'})
game = Game(board=board)
d = game.defend()
self.assertEqual(d, 5)
def test_doesnt_find_winner(self):
board = pickle.dumps(['', '', '', '', '', '', '', '', ''])
game = Game(player1=self.player1, player2=self.player2, board=board)
winner = game.get_winner()
self.assertEqual(winner, None)
def get_qualification_url(game, tournament):
return Game.get_qualification_url(game, tournament)
class TestGameViews(TestCase):
def setUp(self):
self.player1 = User.objects.create(username='******')
self.player1.set_password('test')
self.player2 = User.objects.create(username='******')
self.player1.save()
self.player2.save()
self.game = Game(player1=self.player1, player2=self.player2)
self.game.save()
self.client = Client()
self.client.login(username='******', password='******')
def test_create_move_publishes_to_redis(self):
"""
Tests that we are publishing to redis when we create moves
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
self.game.board = pickle.dumps(['X', '', '',
'', 'X', '',
'', '', ''])
self.game.save()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 8
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{
'move': move
}
)
redis.publish.assert_called_with(self.player2.id,
['game_over', self.game.id, player])
_pop_last_call(redis.publish)
redis.publish.assert_called_with(self.player1.id,
['game_over', self.game.id, player])
_pop_last_call(redis.publish)
redis.publish.assert_called_with(self.player2.id,
['opponent_moved', self.game.id, player, move])
def test_winning_move_publishes_to_redis(self):
"""
Tests that we are publishing to redis when we create moves
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 0
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{
'move': move
}
)
redis.publish.assert_called_once_with(self.player2.id,
['opponent_moved', self.game.id, player, move])
def test_create_move_makes_move(self):
"""
Tests that we are creating moves in the db when we call create_move
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 0
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{
'move': move
}
)
game = Game.objects.get(pk=self.game.id)
board = game.get_board()
self.assertEqual(board[0], player)
def test_make_move_wins(self):
pass
def wrapped_view(request, *args, **kwargs):
if Game.is_running():
return view_func(request, *args, **kwargs)
return redirect_to_login(request.build_absolute_uri(), reverse("wait"))
def update_stats():
# Send Production stats
servers = Server.objects.all()
active_game = Game.get_active()
data_list = {}
for server in servers:
data_list[server.pk] = {'players-online': str(server.players_online)}
for key in PACK_DICT:
try:
data_list[server.pk][key] = ConsumptionStat.objects \
.filter(server=server.id) \
.filter(key=key) \
.filter(game=active_game) \
.order_by('-id')[0].value
except IndexError:
data_list[server.pk][key] = 0
pack = {'namespace': 'scores', 'data': data_list}
for server in servers:
server.message(pack)
lead_table = {}
# Update lead tables
for key in PACK_DICT:
try:
lead_table[key] = ScenarioData.objects.get(key='leader-%s' % key,
game=active_game)
except ScenarioData.DoesNotExist:
lead_table[key] = ScenarioData.objects.create(
key='leader-%s' % key,
value=0,
game=active_game)
new_leaders = {}
for key in PACK_DICT:
# Find highest server for key
highest = 0
highest_server = None
for server in servers:
if int(data_list[server.pk][key]) > int(lead_table[key].value):
if int(data_list[server.pk][key]) > highest:
highest = data_list[server.pk][key]
highest_server = server
if highest_server is not None:
new_leaders[key] = highest_server
for key in PACK_DICT:
if key not in new_leaders:
continue
if lead_table[key].server is None or \
new_leaders[key].pk != lead_table[key].server.pk:
# Save new leader
for server in servers:
if server is new_leaders[key]:
pack = {
"namespace": "chat",
"data": {
"msg": "You have taken the lead in {:s}"
.format(PACK_DICT[key])}}
server.message(pack)
else:
pack = {
"namespace": "chat",
"data": {
"msg": "{:s} have taken the lead in {:s}"
.format(new_leaders[key].name, PACK_DICT[key])}}
server.message(pack)
lead_table[key].server = new_leaders[key]
lead_table[key].value = data_list[new_leaders[key].pk][key]
lead_table[key].save()
class TestGameViews(TestCase):
def setUp(self):
self.player1 = User.objects.create(username='******')
self.player1.set_password('test')
self.player2 = User.objects.create(username='******')
self.player1.save()
self.player2.save()
self.game = Game(player1=self.player1, player2=self.player2)
self.game.save()
self.client = Client()
self.client.login(username='******', password='******')
def test_create_move_publishes_to_redis(self):
"""
Tests that we are publishing to redis when we create moves
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
self.game.board = pickle.dumps(['X', '', '', '', 'X', '', '', '', ''])
self.game.save()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 8
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{'move': move})
redis.publish.assert_called_with(
self.player2.id, ['game_over', self.game.id, player])
_pop_last_call(redis.publish)
redis.publish.assert_called_with(
self.player1.id, ['game_over', self.game.id, player])
_pop_last_call(redis.publish)
redis.publish.assert_called_with(
self.player2.id,
['opponent_moved', self.game.id, player, move])
def test_winning_move_publishes_to_redis(self):
"""
Tests that we are publishing to redis when we create moves
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 0
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{'move': move})
redis.publish.assert_called_once_with(
self.player2.id,
['opponent_moved', self.game.id, player, move])
def test_create_move_makes_move(self):
"""
Tests that we are creating moves in the db when we call create_move
"""
request = Mock(name='request')
request.user = self.player1
redis = Mock(name='redis')
redis.publish = Mock()
with patch('core.views.Redis') as mock_redis:
mock_redis.return_value = redis
move = 0
player = 'X'
response = self.client.post('/create_move/%d/' % self.game.id,
{'move': move})
game = Game.objects.get(pk=self.game.id)
board = game.get_board()
self.assertEqual(board[0], player)
def test_make_move_wins(self):
pass
def handle(self, *args, **kwargs):
start_time = time.time()
player_cache = Cacher()
statistic_cache = Cacher()
names = "Sol Fred Patricia Hettie Luana Shonda Gabriele Antionette Joaquin Elroy Cyrstal Lamonica Esperanza Blanch Yong Mazie Charla Gwen Torrie Katherin".split(
)
pks = []
strengths = []
name_count = len(names)
for name in names:
user = User.objects.create_user(username=name, password="******")
player = Player.objects.create(user=user, name=name)
stat = Statistic.objects.create(player=player)
pks.append(player.pk)
strengths.append(randint(1, 100))
player_cache.create(pk=player.pk, item=player, unique=player.name)
statistic_cache.create(pk=stat.pk, item=stat, unique=player.pk)
game_bulk = []
for x in range(kwargs["games"]):
pk_1 = randint(0, name_count - 1)
pk_2 = pk_1
while pk_1 == pk_2:
pk_2 = randint(0, name_count - 1)
p1 = player_cache.get(pk=pks[pk_1])
p2 = player_cache.get(pk=pks[pk_2])
score1 = 0
score2 = 0
for _ in range(7):
if random() <= strengths[pk_1] / (strengths[pk_1] +
strengths[pk_2]):
score1 += 1
else:
score2 += 1
game = Game(player1=p1,
elo1=p1.elo,
player2=p2,
elo2=p2.elo,
score1=score1,
score2=score2,
verified=True,
date=timezone.now())
game.calculate()
# update cache
p1.elo += game.change
p2.elo -= game.change
s1 = statistic_cache.get(unique=p1.pk)
s2 = statistic_cache.get(unique=p2.pk)
s1.games += 1
s2.games += 2
if game.player1_win():
s1.wins += 1
else:
s2.wins += 1
# cache done
game_bulk.append(game)
print("Done", x)
# save all players
for pk, item in player_cache.data.items():
item.save()
# save all stats
for pk, item in statistic_cache.data.items():
item.save()
# create all games
Game.objects.bulk_create(game_bulk)
end_time = time.time()
print('Done in {:.3f} ms'.format((end_time - start_time) * 1000.0))
def new_game(request):
game = Game()
game.save()
return render(
request, "new_game.html", {"x_uuid": game.x_uuid, "o_uuid": game.o_uuid}
)
def import_fetched_game(
platforms: List[int],
fetched_game_id: int,
name: Optional[str] = None,
publish_date_string: Optional[str] = None,
dlc_or_expansion: Optional[bool] = None,
cover: Optional[str] = None,
game_id: Optional[int] = None,
parent_game_id: Optional[int] = None,
source_display_name: Optional[str] = None,
source_url: Optional[str] = None,
update_fields_filter: Optional[List[str]] = None,
) -> None:
if game_id:
game = Game.objects.filter(id=game_id).get()
else:
game = Game()
include_all_fields = not game_id or update_fields_filter is None
# cast is like a NOP outside type checking
if include_all_fields or "name" in cast(List[str],
update_fields_filter):
if not name:
raise GameImportSaveError("Name field missing")
game.name = clean_string_field(name)
if include_all_fields or "publish_date" in cast(
List[str], update_fields_filter):
if not publish_date_string:
raise GameImportSaveError("Publish Date field missing")
game.publish_date = publish_date_string
if include_all_fields or "dlc_or_expansion" in cast(
List[str], update_fields_filter):
if dlc_or_expansion is None:
raise GameImportSaveError("DLC field missing")
game.dlc_or_expansion = dlc_or_expansion
if include_all_fields or "parent_game" in cast(List[str],
update_fields_filter):
if parent_game_id:
game.parent_game_id = parent_game_id
else:
game.parent_game = None
if include_all_fields or "cover" in cast(List[str],
update_fields_filter):
# do not error if 'cover' empty (source import might not have it)
# Remark: only sets cover if not had one, never updates it
if game.cover is None and cover:
try:
source_path = os.path.join(settings.COVERS_IMPORT_PATH,
cover + ".png")
destination_path = os.path.join(settings.COVERS_PATH,
cover + ".png")
copyfile(source_path, destination_path)
except Exception as error:
raise GameImportSaveError(str(error))
game.cover = cover
# update always the url for this source
if source_display_name and source_url:
game.upsert_url(display_name=source_display_name, url=source_url)
try:
game.save()
except Exception as error:
raise GameImportSaveError(str(error))
# many to many need an id to be set, so platforms added after initial save
if include_all_fields or "platforms" in cast(List[str],
update_fields_filter):
try:
platforms = Platform.objects.filter(id__in=platforms)
# Add new platforms if proceed, not removing existing ones (and if already added, nothing happens).
# Also, because one catalog source might only include a subset of the platforms for a game.
game.platforms.add(*platforms)
game.save()
except Exception as error:
raise GameImportSaveError(str(error))
# Update always linked game
fetched_game = FetchedGame.objects.filter(id=fetched_game_id).get()
fetched_game.fg_game_id = game.id
fetched_game.mark_as_synchronized()
fetched_game.save(update_fields=["fg_game_id", "last_sync_date"])
