def new_game(request):
"""
Creates a new game.
player_id should already be stored inside cookie.
"""
private = (request.POST['isPrivate'] == 'on' if 'isPrivate' in request.POST
else False)
game_type = request.POST['gameType']
player_id = sessions.get_player_id(request.session)
player = Player.get_by_id(Player.get_model_id(player_id))
game = Game(game_type=game_type,
creator=player,
private=private,
current_turn=player)
game.save()
game_id = Game.get_game_id(game.id)
game.game_id = game_id
game.save()
text = 'Game created'
entry = GameLogEntry(game=game, text=text)
entry.save()
# Send a ws message to the lobby group
Group('lobby').send({'text': json.dumps(Game.get_all_games_list())})
return HttpResponseRedirect(reverse('games:game', args=(game.id,)))
def test_saves_retrieves_games(self):
a_player = Player()
a_player.save()
first_game = Game()
first_game.text = "a_score : a_player"
first_game.player = a_player
first_game.save()
second_game = Game()
second_game.text = "b_score : b_player"
second_game.player = a_player
second_game.save()
saved_player = Player.objects.first()
self.assertEqual(saved_player, a_player)
saved_games = Game.objects.all()
self.assertEqual(saved_games.count(), 2)
first_saved_game = saved_games[0]
second_saved_game = saved_games[1]
self.assertEqual(first_saved_game.text, "a_score : a_player")
self.assertEqual(second_saved_game.text, "b_score : b_player")
self.assertEqual(first_saved_game.player, a_player)
self.assertEqual(second_saved_game.player, a_player)
def connect(self, message, **kwargs):
player_id = sessions.get_player_id(message.http_session)
message.channel_session['player_id'] = player_id
print('Player %s connected to lobby' % player_id)
player = Player.get_by_id(Player.get_model_id(player_id))
data = Game.get_all_games_list()
Group('lobby').send({'text': json.dumps(data)})
def receive(self, content, **kwargs):
"""
Handle web socket message.
Can be:
1) New, valid move received. Add game log entry and update clients.
or 2) Chat message.
"""
game_id = kwargs['game_id']
print('game-%s content: %s' % (game_id, content))
game = Game.get_by_id(game_id)
if content['message_type'] == 'new_move':
# content contains keys 'move', 'board', and 'game_over', 'next_player'
board_text = json.dumps(content['board'])
game.board = board_text
if 'extra_state' in content:
game.extra_state = json.dumps(content['extra_state'])
next_player = Player.get_by_id(
Player.get_model_id(content['next_player']))
game.current_turn = next_player
if content['game_over']:
game.completed = now()
game.save()
text = content['move']
entry = GameLogEntry(game=game, text=text)
entry.save()
game_log = GameLogEntry.get_game_log_entries_for_game(game)
serialized_data = GameLogEntry.serialize_entries(game_log)
extra_state = json.loads(
game.extra_state) if game.extra_state else ''
data = {
'message_type': 'new_move',
'board': json.loads(game.board),
'extra_state': extra_state,
'move_text': content['move'],
'current_turn': Player.get_player_id(game.current_turn.id),
'game_log': serialized_data,
'completed': Game.serialize_games([game])[0]['completed'],
}
Group('game-%s' % game_id).send({'text': json.dumps(data)})
elif content['message_type'] == 'chat':
player_id = content['player']
player = Player.get_by_id(Player.get_model_id(player_id))
new_chat_entry = ChatEntry(game=game,
player=player,
text=content['text'])
new_chat_entry.save()
chat_entries = ChatEntry.get_chat_entries_for_game(game)
data = {
'message_type': 'new_chat',
'chat': ChatEntry.serialize_entries(chat_entries)
}
Group('game-%s' % game_id).send({'text': json.dumps(data)})
else:
print('Unknown message_type for %s' % game_id)
def new_player(request):
if request.method == "POST":
new_player_form = PlayerForm(request.POST)
if new_player_form.is_valid():
user = Player()
user.name = new_player_form.cleaned_data.get('name')
user.save()
return HttpResponseRedirect('/games/')
else:
form = PlayerForm
context = {'form': PlayerForm}
return render(request, 'new_player.html', context=context)
def game_creator(request, game_id):
"""
Respond with the game creator's player_id.
"""
game = get_object_or_404(Game, pk=int(game_id))
player_id = Player.get_player_id(game.creator.id)
return HttpResponse(player_id)
def get_or_create_player_id(session):
player_id = session.get('player_id', None)
if player_id is None:
player = Player()
player.save()
player.player_id = Player.get_player_id(player.id)
player_id = player.player_id
player.save()
session['player_id'] = player_id
return player_id
def game(request, game_id):
"""
Tries to send the user to a game.
Cookie might not have player_id yet.
"""
bots = ['facebookexternal', 'whatsapp']
for bot in bots:
if bot in request.META['HTTP_USER_AGENT'].lower():
return HttpResponse('Hello bot')
game = get_object_or_404(Game, pk=int(game_id))
player_id = sessions.get_or_create_player_id(request.session)
player = Player.get_by_id(Player.get_model_id(player_id))
if game.game_type == 'ttt':
template = 'games/ttt.html'
elif game.game_type == 'reversi':
template = 'games/reversi.html'
else:
template = 'games/chess.html'
if game.creator == player or game.opponent == player:
print('Game creator or opponent is (re)joining game.')
return render(request,
template,
{'player_id': player_id, 'game_id': game_id})
elif game.opponent is None:
print('New player is joining game')
game.opponent = player
game.save()
# Send a ws message to the lobby group
Group('lobby').send({'text': json.dumps(Game.get_all_games_list())})
return render(request,
template,
{'player_id': player_id, 'game_id': game_id})
else:
return HttpResponse('Sorry, player %s, but game %s is full'
% (player_id, game_id))
def connect(self, message, **kwargs):
game_id = kwargs['game_id']
game = Game.get_by_id(game_id)
player_id = sessions.get_player_id(message.http_session)
message.channel_session['player_id'] = player_id
latest_gle = GameLogEntry.get_latest_gle_for_game(game)
# Send the full game log to the everyone in the game.
text = '%s joined the game' % player_id
entry = GameLogEntry(game=game, text=text)
entry.save()
game_log = GameLogEntry.get_game_log_entries_for_game(game)
serialized_data = GameLogEntry.serialize_entries(game_log)
opponent = (Player.get_player_id(game.opponent.id) if
(game.opponent is not None) else '')
player_joined_data = {
'message_type': 'player_joined',
'game_log': serialized_data,
'opponent': opponent,
'current_turn': Player.get_player_id(game.current_turn.id),
}
Group('game-%s' % game_id).send(
{'text': json.dumps(player_joined_data)})
# Send the full game data to the client who just connected.
chat_entries = ChatEntry.get_chat_entries_for_game(game)
board = json.loads(game.board) if game.board else ''
extra_state = json.loads(game.extra_state) if game.extra_state else ''
extra_state
all_game_data = {
'message_type': 'full_game',
'board': board,
'extra_state': extra_state,
'opponent': opponent,
'current_turn': Player.get_player_id(game.current_turn.id),
'chat': ChatEntry.serialize_entries(chat_entries),
'completed': Game.serialize_games([game])[0]['completed']
}
message.reply_channel.send({'text': json.dumps(all_game_data)})
def _create_players(self):
print "Populating players"
emails_fname = "games/management/commands/data/emails.txt"
with open(emails_fname) as f:
emails = f.read().splitlines()
for email in emails:
player = Player()
player.paypal = email
player.save()
# The play has played n-sequences in different games
n = random.randint(1,10)
for i in range(n):
sequence = self._create_sequence()
player.sequences.add(sequence)
# Add the player to the current sequence
sequence.players.add(player)
sequence.save()
# Generate payments
for i in range(random.randint(0, 5)):
payment = self._create_payment()
player.payments.add(payment)
player.save()
print "SUCCESS"
def post(self, request, **kwargs):
game = self.get_object()
body = request.body
if not body.decode('UTF-8'):
return Response(status=status.HTTP_400_BAD_REQUEST)
body = json.loads(body)
user_id = body.get("user_id")
if not user_id:
return Response("user_id field is needed", status=status.HTTP_400_BAD_REQUEST)
player_name = body.get("player_name")
if not player_name:
return Response("player_name field is needed", status=status.HTTP_400_BAD_REQUEST)
if len(player_name) > 20:
return Response("Player name to long, the app should have handled this case, why are you getting this response?", status=status.HTTP_400_BAD_REQUEST)
name_exists = game.players.filter(player_name=player_name)
if name_exists:
return Response("That name has been taken, try a different name", status=status.HTTP_400_BAD_REQUEST)
if is_valid_uuid(user_id):
user = get_object_or_404(User, id=user_id)
new_player = Player(player_name=player_name, user=user)
else:
new_player = Player(player_name=player_name, user=None)
new_player.save()
game.players.add(new_player)
game.save()
return Response(PlayersSerializer(new_player).data, status=status.HTTP_201_CREATED)
def create_player(self) -> Player:
return Player(**self.cleaned_data)