libervia-backend: plugins/plugin_misc

comparison plugins/plugin_misc_tarot.py @ 95:be206a3d1a9b

Tarot game: score calculation - plugin tarot: score validity is now checked (some of attackers and defender must equal 91) - plugin tarot: new signal tarotGameScore to give the scores and winners/loosers - wix: score are now displayed at the end of the game - xml_tools: 'fixed' type is now managed in dataForm2xml

author	Goffi <goffi@goffi.org>
date	Wed, 02 Jun 2010 15:57:23 +0930
parents	1eb5ccead43c
children	c8518b9a8025

comparison

equal deleted inserted replaced

-:1eb5ccead43c
+:be206a3d1a9b
 host.bridge.addSignal("tarotGameNew", ".communication", signature='sa(ss)s') #args: room_jid, hand, profile
 host.bridge.addSignal("tarotGameChooseContrat", ".communication", signature='sss') #args: room_jid, xml_data, profile
 host.bridge.addSignal("tarotGameShowCards", ".communication", signature='ssa(ss)a{ss}s') #args: room_jid, type ["chien", "poignée",...], cards, data[dict], profile
 host.bridge.addSignal("tarotGameCardsPlayed", ".communication", signature='ssa(ss)s') #args: room_jid, player, type ["chien", "poignée",...], cards, data[dict], profile
 host.bridge.addSignal("tarotGameYourTurn", ".communication", signature='ss') #args: room_jid, profile
+host.bridge.addSignal("tarotGameScore", ".communication", signature='ssasass') #args: room_jid, xml_data, winners (list of nicks), loosers (list of nicks), profile
 self.deck_ordered = []
 for value in ['excuse']+map(str,range(1,22)):
 self.deck_ordered.append(("atout",value))
 for suit in ["pique", "coeur", "carreau", "trefle"]:
 for value in map(str,range(1,11))+["valet","cavalier","dame","roi"]:
 form = data_form.Form('form', title=_('contrat selection'))
 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 __give_scores(self, scores, winners, loosers):
+"""Create an element to give scores
+@param scores: unicode (can contain line feed)
+@param winners: list of unicode nicks of winners
+@param loosers: list of unicode nicks of loosers"""
+score_elt = domish.Element(('','score'))
+form = data_form.Form('form', title=_('scores'))
+for line in scores.split('\n'):
+field = data_form.Field('fixed', value = line)
+form.addField(field)
+score_elt.addChild(form.toElement())
+for winner in winners:
+winner_elt = domish.Element(('','winner'))
+winner_elt.addContent(winner)
+score_elt.addChild(winner_elt)
+for looser in loosers:
+looser_elt = domish.Element(('','looser'))
+looser_elt.addContent(looser)
+score_elt.addChild(looser_elt)
+return score_elt
 def __next_player(self, game_data, next_pl = None):
 """Increment player number & return player name
 @param next_pl: if given, then next_player is forced to this one
 """
 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)
+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"""
+"""give a low card to other team and keep excuse if trick is lost
+@param game_data: data of the game
+@param played: cards currently on the table
+@param winner: nick of the trick winner"""
 #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"))
+#we first check if the Excuse was already player
+#and if somebody is waiting for a card
 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
 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
 return
 if not excuse in played:
+#the Excuse is not on the table, nothing to do
 return
-excuse_player = None
+excuse_player = None #Who has played the Excuse ?
 for player in game_data['players']:
 if players_data[player]['played'] == excuse:
 excuse_player = player
 break
 #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
+#We look backward in cards won by the Excuse owner to
+#find a low value card
 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)
 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 :)"""
+"""The game is finished, time to know who won :)
+@param game_data: data of the game
+@return: tuple with (string victory message, list of winners, list of loosers)"""
 players_data = game_data['players_data']
 levees = players_data[game_data['attaquant']]['levees']
 score = 0
 nb_bouts = 0
+bouts = []
 for card in levees:
 if card.bout:
 nb_bouts +=1
+bouts.append(card.value)
 score += card.points
+#We now check if there is no bug in score calculation
+check_score = 0
+defenseurs = game_data['players'][:]
+defenseurs.remove(game_data['attaquant'])
+for defenseur in defenseurs:
+for card in players_data[defenseur]['levees']:
+check_score+=card.points
+assert (score + check_score == 91)
 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
+if game_data['contrat'] == 'Petite':
+contrat_mult = 1
+elif game_data['contrat'] == 'Garde':
+contrat_mult = 2
+elif game_data['contrat'] == 'Garde Sans':
+contrat_mult = 4
+elif game_data['contrat'] == 'Garde Contre':
+contrat_mult = 6
+else:
+error(_('Internal error: contrat not managed (mispelled ?)'))
 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'})
+margin = score - point_limit
-#pdb.set_trace()
+pdb.set_trace()
+points_defenseur = (-margin + 25) * contrat_mult
+winners = []
+loosers = []
+player_score = {}
+for player in game_data['players']:
+#TODO: adjust this for 3 and 5 players variants
+#TODO: manage bonuses (petit au bout, poignée, chelem)
+player_score[player] = points_defenseur if player != game_data['attaquant'] else points_defenseur * -3
+players_data[player]['score'] += player_score[player] #we add score of this game to the global score
+if player_score[player] > 0:
+winners.append(player)
+else:
+loosers.append(player)
+scores_str = _('The attacker (%(attaquant)s) makes %(points)i and needs to make %(point_limit)i (%(nb_bouts)s oulder%(plural)s: %(bouts)s): he %(victory)s') % {'attaquant':game_data['attaquant'], 'points':score, 'point_limit':point_limit, 'nb_bouts': nb_bouts, 'plural': 's' if nb_bouts>1 else '', 'bouts':','.join(map(str,bouts)), 'victory': 'win' if victory else 'loose'}
+scores_str+='\n'
+for player in game_data['players']:
+scores_str+=_("\n--\n%(player)s:\nscore for this game ==> %(score_game)i\ntotal score ==> %(total_score)i") % {'player':player, 'score_game':player_score[player], 'total_score': players_data[player]['score']}
+debug(scores_str)
+return (scores_str, winners, loosers)
 def createGame(self, room_jid_param, players, profile_key='@DEFAULT@'):
 """Create a new game"""
 debug (_("Creating Tarot game"))
 return
 referee = room_jid.userhost() + '/' + room_nick
 status = {}
 players_data = {}
 for player in players:
-players_data[player] = {}
+players_data[player] = {'score':0}
 status[player] = "init"
-self.games[room_jid.userhost()] = {'referee':referee, 'players':players, 'status':status, 'players_data':players_data, 'hand_size':18, 'init_player':0, 'current_player': None, 'stage': None}
+self.games[room_jid.userhost()] = {'referee':referee, 'players':players, 'status':status, 'players_data':players_data, 'hand_size':18, 'init_player':0, 'current_player': None, 'contrat': None, 'stage': None}
 for player in players:
 mess = self.createGameElt(jid.JID(room_jid.userhost()+'/'+player))
 mess.firstChildElement().addChild(self.__create_started_elt(players))
 self.host.profiles[profile].xmlstream.send(mess)
 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
+game_data['contrat'] = None
 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]
 idx_pl = self.contrats.index(contrat)
 if idx_pl > idx_best:
 best_contrat[0] = player
 best_contrat[1] = contrat
 debug (_("%(player)s win the bid with %(contrat)s") % {'player':best_contrat[0],'contrat':best_contrat[1]})
+game_data['contrat'] = best_contrat[1]
 #Time to show the chien to everybody
 to_jid = jid.JID(room_jid.userhost()) #FIXME: gof:
 mess = self.createGameElt(to_jid)
 chien_elt = mess.firstChildElement().addChild(self.__list_to_xml(game_data['chien'], 'chien'))
 chien_elt['attaquant'] = best_contrat[0]
 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(Card.from_tuples(self.__xml_to_list(elt)))
+list_cards = self.__xml_to_list(elt)
+#FIXME: gof: manage Garde Sans & Garde Contre cases
+players_data[elt['player']]['levees'].extend(Card.from_tuples(list_cards)) #we add the chien to attaquant's levées
+for card in list_cards:
+game_data['hand'][elt['player']].remove(card)
 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
 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)
 if mess_elt['type'] == 'groupchat':
 self.host.bridge.tarotGameCardsPlayed(room_jid.userhost(), elt['player'], self.__xml_to_list(elt), profile)
 else:
 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):
+if all(played):
-#everybody played
+#everybody has 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)
+to_jid = jid.JID(room_jid.userhost()) #FIXME: gof:
+mess = self.createGameElt(to_jid)
+chien_elt = mess.firstChildElement().addChild(self.__give_scores(*self.__calculate_scores(game_data)))
+self.host.profiles[profile].xmlstream.send(mess)
 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)
 self.host.profiles[profile].xmlstream.send(mess)
 elif elt.name == 'your_turn':
 self.host.bridge.tarotGameYourTurn(room_jid.userhost(), profile)
+elif elt.name == 'score':
+form_elt = elt.elements(name='x',uri='jabber:x:data').next()
+winners = []
+loosers = []
+for winner in elt.elements(name='winner', uri=''):
+winners.append(unicode(winner))
+for looser in elt.elements(name='looser', uri=''):
+loosers.append(unicode(looser))
+form = data_form.Form.fromElement(form_elt)
+xml_data = XMLTools.dataForm2xml(form)
+self.host.bridge.tarotGameScore(room_jid.userhost(), xml_data, winners, loosers, profile)
 def getHandler(self, profile):
 return CardGameHandler(self)
 class CardGameHandler (XMPPHandler):
 implements(iwokkel.IDisco)
 def __init__(self, plugin_parent):

Mercurial > libervia-backend

comparison plugins/plugin_misc_tarot.py @ 95:be206a3d1a9b