def try_designate_card(self, player, card_id):
if self.state is not self.WAITING_DESIGNATION:
return error('Not now, moron !')
if self.judge is not player:
return error('Who do you think you are !?')
if card_id is None and len(self.board.played_cards) > 0:
return error('There are cards on the board, pick one !')
if card_id is not None or len(self.board.played_cards) > 0:
# if there are cards on the board
# TODO check exception
try:
card, winner = self.board.played_cards[card_id]
except IndexError:
return error('Invalid card')
winner.inc_score()
# put the cards back in the deck
self.board.recycle_played_cards()
# reset the state of the players
for p in self.players:
if p.get_has_played():
idx = p.receive_card(self.board.pick_white_card())
card_idx = p.cards[idx]
card_desc = self.white_desc[card_idx]
p.send_notification({
'op': 'received_card',
'content': {
'card': {
'id': idx,
'desc': card_desc,
},
},
})
p.set_has_played(False)
self.board.recycle_black_card()
self.judge = None
for p in self.players:
if p is not player:
p.send_notification({'op': 'judge_needed'})
self.state = self.WAITING_NEW_JUDGE
return success(None)
def join_game(self, game_name, lang):
if self.game is not None:
return error('You are already in a game')
if lang is None:
lang = 'en'
game = self.game_manager.join_game(game_name, lang)
# XXX self.game will be assigned by game.try_join()
if game is None:
return error('Invalid language')
return game.try_join(self)
def try_view_black_card(self, player):
card = self.board.current_black_card
if card is not None:
return success(self.black_desc[card])
return error('The black card has not been revealed yet')
def try_collect_cards(self, player):
if self.state is not self.WAITING_COLLECTION:
return error('Do you think it\'s the moment for colletion !?')
if self.judge is not player:
return error('You\'re not the judge, you fool!')
self.board.shuffle_played_cards()
# we prevent the others to play
self.state = self.WAITING_DESIGNATION
for p in self.players:
if p is not player:
p.send_notification({'op': 'cards_collected'})
return self.try_view_played_cards(player)
def message_received_handler(client, server, message):
try:
json_msg = json.loads(message)
except:
res = error('badly formatted json')
else:
op = json_msg['op']
if op == 'join_game':
try:
game_name = json_msg['game_name']
except KeyError:
res = error('field `game_name\' is required')
else:
lang = json_msg.get('lang')
res = client['client'].join_game(game_name, lang)
elif op == 'view_player_cards':
res = client['client'].view_player_cards()
elif op == 'view_black_card':
res = client['client'].view_black_card()
elif op == 'view_played_cards':
res = client['client'].view_played_cards()
elif op == 'pick_black_card':
res = client['client'].pick_black_card()
elif op == 'designate_card':
card_id = None
try:
card_id = int(json_msg['card_id'])
except (KeyError, TypeError):
pass
finally:
res = client['client'].designate_card(card_id)
elif op == 'play_white_card':
try:
card_id = int(json_msg['card_id'])
except KeyError:
res = error('field `card_id\' is required')
else:
res = client['client'].play_white_card(card_id)
elif op == 'collect_cards':
res = client['client'].collect_cards()
else:
res = error('invalid command')
server.send_message(client, res)
def try_view_played_cards(self, player):
if self.state is not self.WAITING_DESIGNATION:
return error('Not now, moron !')
cards = []
for card, unused in self.board.played_cards:
cards.append(self.white_desc[card])
return success(cards)
def try_play_card(self, player, card_id):
if self.state is not self.WAITING_COLLECTION:
return error('Who asked you to play now ?!')
if self.judge is player:
return error('You\'re the judge, you silly')
elif player.get_has_played():
return error('You already played, you dumb ass')
try:
card = player.pop_card(card_id)
except IndexError:
return error('Invalid card id')
player.set_has_played()
self.board.play_card(player, card)
self.judge.send_notification({'op': 'card_played'})
return success({'card_id': card_id})
def try_become_judge(self, player):
if self.state is not self.WAITING_NEW_JUDGE:
# TODO what if the judge has quit ?
return error('Someone is judge already')
self.judge = player
self.board.reveal_black_card()
self.state = self.WAITING_COLLECTION
for p in self.players:
if p is not player:
p.send_notification({'op': 'judge_designed'})
return self.try_view_black_card(player)
def try_join(self, client):
if len(self.players) >= 10:
return error('too many players in this game')
cards = []
try:
for i in range(10):
cards.append(self.board.pick_white_card())
except IndexError:
return error('no enough white cards for player')
player = Player(client)
for card in cards:
player.receive_card(card)
client.set_player(player)
client.set_game(self)
self.players.append(player)
for p in self.players:
if p is not player:
p.send_notification({'op': 'player_joined_game'})
cards = self.__view_player_cards(player)
if self.state is self.WAITING_NEW_JUDGE:
state = 'waiting_judge'
elif self.state is self.WAITING_COLLECTION:
state = 'waiting_collection'
else:
state = 'waiting_designation'
return success({'cards': cards, 'game_state': state})
def view_black_card(self):
if self.game is None:
return error('You have to join a game first')
return self.game.try_view_black_card(self.player)
def designate_card(self, card_id):
if self.game is None:
return error('You have to join a game first')
return self.game.try_designate_card(self.player, card_id)
def collect_cards(self):
if self.game is None:
error('You have to join a game first')
return self.game.try_collect_cards(self.player)
def pick_black_card(self):
if self.game is None:
return error('You have to join a game first')
return self.game.try_become_judge(self.player)
