libervia-backend: plugins/plugin_misc

comparison plugins/plugin_misc_tarot.py @ 94:1eb5ccead43c

Tarot game: basic trick - plugin tarot: it's now possible to make a basic game until the end \o/. Score are calculated but not sent to players yet.

author	Goffi <goffi@goffi.org>
date	Tue, 01 Jun 2010 18:16:15 +0930
parents	2f87651a5ad8
children	be206a3d1a9b

comparison

equal deleted inserted replaced

-:2f87651a5ad8
+:1eb5ccead43c
 "dependencies": ["XEP_0045"],
 "main": "Tarot",
 "handler": "yes",
 "description": _("""Implementation of Tarot card game""")
 }
+suits_order = ['pique', 'coeur', 'trefle', 'carreau', 'atout'] #I have swith the usual order 'trefle' and 'carreau' because card are more easy to see if suit colour change (black, red, black, red)
+values_order = map(str,range(1,11))+["valet","cavalier","dame","roi"]
+class Card():
+"""This class is used to represent a car logically"""
+#TODO: move this in a library in tools, and share this with frontends (e.g. card_game in wix use the same class)
+def __init__(self, tuple_card):
+"""@param tuple_card: tuple (suit, value)"""
+self.suit, self.value = tuple_card
+self.bout = True if self.suit=="atout" and self.value in ["1","21","excuse"] else False
+if self.bout or self.value == "roi":
+self.points = 4.5
+elif self.value == "dame":
+self.points = 3.5
+elif self.value == "cavalier":
+self.points = 2.5
+elif self.value == "valet":
+self.points = 1.5
+else:
+self.points = 0.5
+def get_tuple(self):
+return (self.suit,self.value)
+@staticmethod
+def from_tuples(tuple_list):
+result = []
+for card_tuple in tuple_list:
+result.append(Card(card_tuple))
+return result
+def __cmp__(self, other):
+if other == None:
+return 1
+if self.suit != other.suit:
+idx1 = suits_order.index(self.suit)
+idx2 = suits_order.index(other.suit)
+return idx1.__cmp__(idx2)
+if self.suit == 'atout':
+if self.value == other.value == 'excuse':
+return 0
+if self.value == 'excuse':
+return -1
+if other.value == 'excuse':
+return 1
+return int(self.value).__cmp__(int(other.value))
+#at this point we have the same suit which is not 'atout'
+idx1 = values_order.index(self.value)
+idx2 = values_order.index(other.value)
+return idx1.__cmp__(idx2)
+def __str__(self):
+return "[%s,%s]" % (self.suit, self.value)
 class Tarot():
 def __init__(self, host):
 info(_("Plugin Tarot initialization"))
 field = data_form.Field('list-single', 'contrat', options=map(data_form.Option, self.contrats), required=True)
 form.addField(field)
 contrat_elt.addChild(form.toElement())
 return contrat_elt
-def __next_player(self, game_data):
+def __next_player(self, game_data, next_pl = None):
-"""It's next player turn
+"""Increment player number & return player name
-Increment player number & return player name"""
+@param next_pl: if given, then next_player is forced to this one
-pl_idx = game_data['current_player'] = (game_data['current_player'] + 1) % len(game_data['players'])
+"""
-return game_data['players'][pl_idx]
+if next_pl:
+game_data['current_player'] = game_data['players'].index(next_pl)
+return next_pl
+else:
+pl_idx = game_data['current_player'] = (game_data['current_player'] + 1) % len(game_data['players'])
+return game_data['players'][pl_idx]
+def __winner(self, game_data):
+"""give the nick of the player who win this trick"""
+players_data = game_data['players_data']
+first = game_data['first_player']
+first_idx = game_data['players'].index(first)
+suit_asked = None
+strongest = None
+winner = None
+for idx in [(first_idx + i) % 4 for i in range(4)]:
+player = game_data['players'][idx]
+card = players_data[player]['played']
+if card.value == "excuse":
+continue
+if suit_asked == None:
+suit_asked = card.suit
+if (card.suit == suit_asked or card.suit == "atout") and card > strongest:
+strongest = card
+winner = player
+assert (winner)
+return winner
+def __excuse_hack(self, game_data, played, winner):
+"""give a low card to other team and keep excuse if trick is lost"""
+#TODO: manage the case where excuse is played on the last trick (and lost)
+#TODO: gof: manage excuse (fool)
+players_data = game_data['players_data']
+excuse = Card(("atout","excuse"))
+for player in game_data['players']:
+if players_data[player]['wait_for_low']:
+#the excuse owner has to give a card to somebody
+if winner == player:
+#the excuse owner win the trick, we check if we have something to give
+for card in played:
+if card.points == 0.5:
+pl_waiting = players_data[player]['wait_for_low']
+played.remove(card)
+players_data[pl_waiting]['levees'].append(card)
+debug (_('Player %(excuse_owner)s give %(card_waited)s to %(player_waiting)s for Excuse compensation') % {"excuse_owner":player, "card_waited": card, "player_waiting":pl_waiting})
+break
+return
+if not excuse in played:
+return
+excuse_player = None
+for player in game_data['players']:
+if players_data[player]['played'] == excuse:
+excuse_player = player
+break
+if excuse_player == winner:
+return #the excuse player win the trick, nothing to do
+#first we remove the excuse from played cards
+played.remove(excuse)
+#then we give it back to the original owner
+owner_levees = players_data[excuse_player]['levees']
+owner_levees.append(excuse)
+#finally we give a low card to the trick winner
+low_card = None
+for card_idx in range(len(owner_levees)-1, -1, -1):
+if owner_levees[card_idx].points == 0.5:
+low_card = owner_levees[card_idx]
+del owner_levees[card_idx]
+players_data[winner]['levees'].append(low_card)
+debug (_('Player %(excuse_owner)s give %(card_waited)s to %(player_waiting)s for Excuse compensation') % {"excuse_owner":excuse_player, "card_waited": low_card, "player_waiting":winner})
+break
+if not low_card: #The player has no low card yet
+#TODO: manage case when player never win a trick with low card
+players_data[excuse_player]['wait_for_low'] = winner
+debug(_("%(excuse_owner)s keep the Excuse but has not card to give, %(winner)s is waiting for one") % {'excuse_owner':excuse_player, 'winner':winner})
+def __calculate_scores(self, game_data):
+"""The game is finished, time to know who won :)"""
+players_data = game_data['players_data']
+levees = players_data[game_data['attaquant']]['levees']
+score = 0
+nb_bouts = 0
+for card in levees:
+if card.bout:
+nb_bouts +=1
+score += card.points
+point_limit = None
+if nb_bouts == 3:
+point_limit = 36
+elif nb_bouts == 2:
+point_limit = 41
+elif nb_bouts == 1:
+point_limit = 51
+else:
+point_limit = 56
+victory = (score >= point_limit)
+debug (_('The attacker make %(points)i and need to make %(point_limit)i (%(nb_bouts)s oulder%(plural)s): he %(victory)s') % {'points':score, 'point_limit':point_limit, 'nb_bouts': nb_bouts, 'plural': 's' if nb_bouts>1 else '', 'victory': 'won' if victory else 'lost'})
+#pdb.set_trace()
 def createGame(self, room_jid_param, players, profile_key='@DEFAULT@'):
 """Create a new game"""
 debug (_("Creating Tarot game"))
 room_jid = jid.JID(room_jid_param)
 game_data = self.games[room_jid.userhost()]
 players = game_data['players']
 players_data = game_data['players_data']
 current_player = game_data['current_player']
 game_data['stage'] = "init"
+game_data['first_player'] = None #first player for the current trick
 hand = game_data['hand'] = {}
 hand_size = game_data['hand_size']
 chien = game_data['chien'] = []
 for i in range(4): #TODO: distribute according to real Tarot rules (3 by 3 counter-clockwise, 1 card at once to chien)
 hand[players[i]] = deck[0:hand_size]
 mess = self.createGameElt(to_jid)
 mess.firstChildElement().addChild(self.__list_to_xml(hand[player], 'hand'))
 self.host.profiles[profile].xmlstream.send(mess)
 players_data[player]['contrat'] = None
 players_data[player]['levees'] = [] #cards won
+players_data[player]['played'] = None #card on the table
+players_data[player]['wait_for_low'] = None #Used when a player wait for a low card because of excuse
 pl_idx = game_data['current_player'] = (game_data['init_player'] + 1) % len(players) #the player after the dealer start
 player = players[pl_idx]
 to_jid = jid.JID(room_jid.userhost()+"/"+player) #FIXME: gof:
 mess = self.createGameElt(to_jid)
 to_jid = jid.JID(room_jid.userhost()+"/"+player) #FIXME: gof:
 mess = self.createGameElt(to_jid)
 mess.firstChildElement().addChild(self.__ask_contrat())
 self.host.profiles[profile].xmlstream.send(mess)
 else:
-#TODO: manage "everybody pass" case
+#TODO: gof: manage "everybody pass" case
 best_contrat = [None, "Passe"]
 for player in game_data['players']:
 contrat = players_data[player]['contrat']
 idx_best = self.contrats.index(best_contrat[1])
 idx_pl = self.contrats.index(contrat)
 del game_data['chien'][:]
 elif elt.name == 'chien': #we have received the chien
 debug (_("tarot: chien received"))
 data = {"attaquant":elt['attaquant']}
-players_data = game_data['players_data']
 game_data['stage'] = "ecart"
 game_data['attaquant'] = elt['attaquant']
 self.host.bridge.tarotGameShowCards(room_jid.userhost(), "chien", self.__xml_to_list(elt), data, profile)
 elif elt.name == 'cards_played':
 if game_data['stage'] == "ecart":
 #TODO: check validity of écart (no king, no oulder, cards must be in player hand)
 #TODO: show atouts (trumps) if player put some in écart
 assert (game_data['attaquant'] == elt['player']) #TODO: throw an xml error here
-players_data[elt['player']]['levees'].extend(self.__xml_to_list(elt))
+players_data[elt['player']]['levees'].extend(Card.from_tuples(self.__xml_to_list(elt)))
 game_data['stage'] = "play"
 next_player_idx = game_data['current_player'] = (game_data['init_player'] + 1) % len(game_data['players']) #the player after the dealer start
-next_player = game_data['players'][next_player_idx]
+game_data['first_player'] = next_player = game_data['players'][next_player_idx]
 to_jid = jid.JID(room_jid.userhost()+"/"+next_player) #FIXME: gof:
 mess = self.createGameElt(to_jid)
 yourturn_elt = mess.firstChildElement().addElement('your_turn')
 self.host.profiles[profile].xmlstream.send(mess)
 elif game_data['stage'] == "play":
 current_player = game_data['players'][game_data['current_player']]
 #assert (elt['player'] == current_player) #TODO: throw xml error here
 cards = self.__xml_to_list(elt)
-#TODO: check card validity and send error mess if necessary
-if mess_elt['type'] != 'groupchat':
+if mess_elt['type'] == 'groupchat':
+self.host.bridge.tarotGameCardsPlayed(room_jid.userhost(), elt['player'], self.__xml_to_list(elt), profile)
+else:
+#TODO: check card validity and send error mess if necessary
 #the card played is ok, we forward it to everybody
-#first we remove it from the hand
+#first we remove it from the hand and put in on the table
 game_data['hand'][current_player].remove(cards[0])
+players_data[current_player]['played'] = Card(cards[0])
 #then we forward the message
 mess = self.createGameElt(room_jid)
 playcard_elt = mess.firstChildElement().addChild(elt)
 self.host.profiles[profile].xmlstream.send(mess)
+#Did everybody played ?
+played = [players_data[player]['played'] for player in game_data['players']]
+if not played.count(None):
+#everybody played
+winner = self.__winner(game_data)
+debug (_('The winner of this trick is %s') % winner)
+#the winner win the trick
+self.__excuse_hack(game_data, played, winner)
+players_data[elt['player']]['levees'].extend(played)
+#nothing left on the table
+for player in game_data['players']:
+players_data[player]['played'] = None
+if len(game_data['hand'][current_player]) == 0:
+#no card lef: the game is finished
+self.__calculate_scores(game_data)
+return
+#next player is the winner
+next_player = game_data['first_player'] = self.__next_player(game_data, winner)
+else:
+next_player = self.__next_player(game_data)
 #finally, we tell to the next player to play
-next_player = self.__next_player(game_data)
 to_jid = jid.JID(room_jid.userhost()+"/"+next_player) #FIXME: gof:
 mess = self.createGameElt(to_jid)
 yourturn_elt = mess.firstChildElement().addElement('your_turn')
 self.host.profiles[profile].xmlstream.send(mess)
-else:
-self.host.bridge.tarotGameCardsPlayed(room_jid.userhost(), elt['player'], self.__xml_to_list(elt), profile)
 elif elt.name == 'your_turn':
 self.host.bridge.tarotGameYourTurn(room_jid.userhost(), profile)
 def getHandler(self, profile):

Mercurial > libervia-backend

comparison plugins/plugin_misc_tarot.py @ 94:1eb5ccead43c