view sat/plugins/plugin_misc_tarot.py @ 3330:7b47f48d31f3

plugin XEP-0264: fix orientation of thumbnails: Rotation of thumbnailis is now modified according to EXIF orientation data. Original image is not modified as user may want to keep it, and orientation transformation can modify encoding parameters. Update `pillow` minimum version to the first one with `exif_transpose` implementation.
author Goffi <goffi@goffi.org>
date Thu, 13 Aug 2020 23:46:18 +0200
parents 559a625a236b
children be6d91572633
line wrap: on
line source

#!/usr/bin/env python3


# SAT plugin for managing French Tarot game
# Copyright (C) 2009-2020 Jérôme Poisson (goffi@goffi.org)

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from sat.core.i18n import _
from sat.core.constants import Const as C
from sat.core.log import getLogger

log = getLogger(__name__)
from twisted.words.xish import domish
from twisted.words.protocols.jabber import jid
from twisted.internet import defer
from wokkel import data_form

from sat.memory import memory
from sat.tools import xml_tools
from sat_frontends.tools.games import TarotCard
import random


NS_CG = "http://www.goffi.org/protocol/card_game"
CG_TAG = "card_game"

PLUGIN_INFO = {
    C.PI_NAME: "Tarot cards plugin",
    C.PI_IMPORT_NAME: "Tarot",
    C.PI_TYPE: "Misc",
    C.PI_PROTOCOLS: [],
    C.PI_DEPENDENCIES: ["XEP-0045", "XEP-0249", "ROOM-GAME"],
    C.PI_MAIN: "Tarot",
    C.PI_HANDLER: "yes",
    C.PI_DESCRIPTION: _("""Implementation of Tarot card game"""),
}


class Tarot(object):
    def inheritFromRoomGame(self, host):
        global RoomGame
        RoomGame = host.plugins["ROOM-GAME"].__class__
        self.__class__ = type(
            self.__class__.__name__, (self.__class__, RoomGame, object), {}
        )

    def __init__(self, host):
        log.info(_("Plugin Tarot initialization"))
        self._sessions = memory.Sessions()
        self.inheritFromRoomGame(host)
        RoomGame._init_(
            self,
            host,
            PLUGIN_INFO,
            (NS_CG, CG_TAG),
            game_init={
                "hand_size": 18,
                "init_player": 0,
                "current_player": None,
                "contrat": None,
                "stage": None,
            },
            player_init={"score": 0},
        )
        self.contrats = [
            _("Passe"),
            _("Petite"),
            _("Garde"),
            _("Garde Sans"),
            _("Garde Contre"),
        ]
        host.bridge.addMethod(
            "tarotGameLaunch",
            ".plugin",
            in_sign="asss",
            out_sign="",
            method=self._prepareRoom,
            async_=True,
        )  # args: players, room_jid, profile
        host.bridge.addMethod(
            "tarotGameCreate",
            ".plugin",
            in_sign="sass",
            out_sign="",
            method=self._createGame,
        )  # args: room_jid, players, profile
        host.bridge.addMethod(
            "tarotGameReady",
            ".plugin",
            in_sign="sss",
            out_sign="",
            method=self._playerReady,
        )  # args: player, referee, profile
        host.bridge.addMethod(
            "tarotGamePlayCards",
            ".plugin",
            in_sign="ssa(ss)s",
            out_sign="",
            method=self.play_cards,
        )  # args: player, referee, cards, profile
        host.bridge.addSignal(
            "tarotGamePlayers", ".plugin", signature="ssass"
        )  # args: room_jid, referee, players, profile
        host.bridge.addSignal(
            "tarotGameStarted", ".plugin", signature="ssass"
        )  # args: room_jid, referee, players, profile
        host.bridge.addSignal(
            "tarotGameNew", ".plugin", signature="sa(ss)s"
        )  # args: room_jid, hand, profile
        host.bridge.addSignal(
            "tarotGameChooseContrat", ".plugin", signature="sss"
        )  # args: room_jid, xml_data, profile
        host.bridge.addSignal(
            "tarotGameShowCards", ".plugin", signature="ssa(ss)a{ss}s"
        )  # args: room_jid, type ["chien", "poignée",...], cards, data[dict], profile
        host.bridge.addSignal(
            "tarotGameCardsPlayed", ".plugin", signature="ssa(ss)s"
        )  # args: room_jid, player, type ["chien", "poignée",...], cards, data[dict], profile
        host.bridge.addSignal(
            "tarotGameYourTurn", ".plugin", signature="ss"
        )  # args: room_jid, profile
        host.bridge.addSignal(
            "tarotGameScore", ".plugin", signature="ssasass"
        )  # args: room_jid, xml_data, winners (list of nicks), loosers (list of nicks), profile
        host.bridge.addSignal(
            "tarotGameInvalidCards", ".plugin", signature="ssa(ss)a(ss)s"
        )  # args: room_jid, game phase, played_cards, invalid_cards, profile
        self.deck_ordered = []
        for value in ["excuse"] + list(map(str, list(range(1, 22)))):
            self.deck_ordered.append(TarotCard(("atout", value)))
        for suit in ["pique", "coeur", "carreau", "trefle"]:
            for value in list(map(str, list(range(1, 11)))) + ["valet", "cavalier", "dame", "roi"]:
                self.deck_ordered.append(TarotCard((suit, value)))
        self.__choose_contrat_id = host.registerCallback(
            self._contratChoosed, with_data=True
        )
        self.__score_id = host.registerCallback(self._scoreShowed, with_data=True)

    def __card_list_to_xml(self, cards_list, elt_name):
        """Convert a card list to domish element"""
        cards_list_elt = domish.Element((None, elt_name))
        for card in cards_list:
            card_elt = domish.Element((None, "card"))
            card_elt["suit"] = card.suit
            card_elt["value"] = card.value
            cards_list_elt.addChild(card_elt)
        return cards_list_elt

    def __xml_to_list(self, cards_list_elt):
        """Convert a domish element with cards to a list of tuples"""
        cards_list = []
        for card in cards_list_elt.elements():
            cards_list.append((card["suit"], card["value"]))
        return cards_list

    def __ask_contrat(self):
        """Create a element for asking contrat"""
        contrat_elt = domish.Element((None, "contrat"))
        form = data_form.Form("form", title=_("contrat selection"))
        field = data_form.Field(
            "list-single",
            "contrat",
            options=list(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((None, "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((None, "winner"))
            winner_elt.addContent(winner)
            score_elt.addChild(winner_elt)
        for looser in loosers:
            looser_elt = domish.Element((None, "looser"))
            looser_elt.addContent(looser)
            score_elt.addChild(looser_elt)
        return score_elt

    def __invalid_cards_elt(self, played_cards, invalid_cards, game_phase):
        """Create a element for invalid_cards error
        @param list_cards: list of Card
        @param game_phase: phase of the game ['ecart', 'play']"""
        error_elt = domish.Element((None, "error"))
        played_elt = self.__card_list_to_xml(played_cards, "played")
        invalid_elt = self.__card_list_to_xml(invalid_cards, "invalid")
        error_elt["type"] = "invalid_cards"
        error_elt["phase"] = game_phase
        error_elt.addChild(played_elt)
        error_elt.addChild(invalid_elt)
        return error_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 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 is 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
        @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)
        players_data = game_data["players_data"]
        excuse = TarotCard(("atout", "excuse"))

        # we first check if the Excuse was already played
        # 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
                    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)
                            log.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,
                                }
                            )
                            return
                return

        if excuse not in played:
            # the Excuse is not on the table, nothing to do
            return

        excuse_player = None  # Who has played the Excuse ?
        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
        # 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)
                log.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
            log.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 __draw_game(self, game_data):
        """The game is draw, no score change
        @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"]
        scores_str = _("Draw game")
        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": 0,
                "total_score": players_data[player]["score"],
            }
        log.debug(scores_str)

        return (scores_str, [], [])

    def __calculate_scores(self, game_data):
        """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 do a basic check on 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
        if game_data["contrat"] == "Garde Contre":
            for card in game_data["chien"]:
                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:
            log.error(_("INTERNAL ERROR: contrat not managed (mispelled ?)"))
            assert False

        victory = score >= point_limit
        margin = abs(score - point_limit)
        points_defenseur = (margin + 25) * contrat_mult * (-1 if victory else 1)
        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%(separator)s%(bouts)s): (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 "",
            "separator": ": " if nb_bouts != 0 else "",
            "bouts": ",".join(map(str, bouts)),
            "victory": "wins" if victory else "looses",
        }
        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"],
            }
        log.debug(scores_str)

        return (scores_str, winners, loosers)

    def __invalid_cards(self, game_data, cards):
        """Checks that the player has the right to play what he wants to
        @param game_data: Game data
        @param cards: cards the player want to play
        @return forbidden_cards cards or empty list if cards are ok"""
        forbidden_cards = []
        if game_data["stage"] == "ecart":
            for card in cards:
                if card.bout or card.value == "roi":
                    forbidden_cards.append(card)
                # TODO: manage case where atouts (trumps) are in the dog
        elif game_data["stage"] == "play":
            biggest_atout = None
            suit_asked = None
            players = game_data["players"]
            players_data = game_data["players_data"]
            idx = players.index(game_data["first_player"])
            current_idx = game_data["current_player"]
            current_player = players[current_idx]
            if idx == current_idx:
                # the player is the first to play, he can play what he wants
                return forbidden_cards
            while idx != current_idx:
                player = players[idx]
                played_card = players_data[player]["played"]
                if not suit_asked and played_card.value != "excuse":
                    suit_asked = played_card.suit
                if played_card.suit == "atout" and played_card > biggest_atout:
                    biggest_atout = played_card
                idx = (idx + 1) % len(players)
            has_suit = (
                False
            )  # True if there is one card of the asked suit in the hand of the player
            has_atout = False
            biggest_hand_atout = None

            for hand_card in game_data["hand"][current_player]:
                if hand_card.suit == suit_asked:
                    has_suit = True
                if hand_card.suit == "atout":
                    has_atout = True
                if hand_card.suit == "atout" and hand_card > biggest_hand_atout:
                    biggest_hand_atout = hand_card

            assert len(cards) == 1
            card = cards[0]
            if card.suit != suit_asked and has_suit and card.value != "excuse":
                forbidden_cards.append(card)
                return forbidden_cards
            if card.suit != suit_asked and card.suit != "atout" and has_atout:
                forbidden_cards.append(card)
                return forbidden_cards
            if (
                card.suit == "atout"
                and card < biggest_atout
                and biggest_hand_atout > biggest_atout
                and card.value != "excuse"
            ):
                forbidden_cards.append(card)
        else:
            log.error(_("Internal error: unmanaged game stage"))
        return forbidden_cards

    def __start_play(self, room_jid, game_data, profile):
        """Start the game (tell to the first player after dealer to play"""
        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:
        self.send(to_jid, "your_turn", profile=profile)

    def _contratChoosed(self, raw_data, profile):
        """Will be called when the contrat is selected
        @param raw_data: contains the choosed session id and the chosen contrat
        @param profile_key: profile
        """
        try:
            session_data = self._sessions.profileGet(raw_data["session_id"], profile)
        except KeyError:
            log.warning(_("session id doesn't exist, session has probably expired"))
            # TODO: send error dialog
            return defer.succeed({})

        room_jid = session_data["room_jid"]
        referee_jid = self.games[room_jid]["referee"]
        player = self.host.plugins["XEP-0045"].getRoomNick(room_jid, profile)
        data = xml_tools.XMLUIResult2DataFormResult(raw_data)
        contrat = data["contrat"]
        log.debug(
            _("contrat [%(contrat)s] choosed by %(profile)s")
            % {"contrat": contrat, "profile": profile}
        )
        d = self.send(
            referee_jid,
            ("", "contrat_choosed"),
            {"player": player},
            content=contrat,
            profile=profile,
        )
        d.addCallback(lambda ignore: {})
        del self._sessions[raw_data["session_id"]]
        return d

    def _scoreShowed(self, raw_data, profile):
        """Will be called when the player closes the score dialog
        @param raw_data: nothing to retrieve from here but the session id
        @param profile_key: profile
        """
        try:
            session_data = self._sessions.profileGet(raw_data["session_id"], profile)
        except KeyError:
            log.warning(_("session id doesn't exist, session has probably expired"))
            # TODO: send error dialog
            return defer.succeed({})

        room_jid_s = session_data["room_jid"].userhost()
        # XXX: empty hand means to the frontend "reset the display"...
        self.host.bridge.tarotGameNew(room_jid_s, [], profile)
        del self._sessions[raw_data["session_id"]]
        return defer.succeed({})

    def play_cards(self, player, referee, cards, profile_key=C.PROF_KEY_NONE):
        """Must be call by player when the contrat is selected
        @param player: player's name
        @param referee: arbiter jid
        @cards: cards played (list of tuples)
        @profile_key: profile
        """
        profile = self.host.memory.getProfileName(profile_key)
        if not profile:
            log.error(_("profile %s is unknown") % profile_key)
            return
        log.debug(
            _("Cards played by %(profile)s: [%(cards)s]")
            % {"profile": profile, "cards": cards}
        )
        elem = self.__card_list_to_xml(TarotCard.from_tuples(cards), "cards_played")
        self.send(jid.JID(referee), elem, {"player": player}, profile=profile)

    def newRound(self, room_jid, profile):
        game_data = self.games[room_jid]
        players = game_data["players"]
        game_data["first_player"] = None  # first player for the current trick
        game_data["contrat"] = None
        common_data = {
            "contrat": None,
            "levees": [],  # cards won
            "played": None,  # card on the table
            "wait_for_low": None,  # Used when a player wait for a low card because of excuse
        }

        hand = game_data["hand"] = {}
        hand_size = game_data["hand_size"]
        chien = game_data["chien"] = []
        deck = self.deck_ordered[:]
        random.shuffle(deck)
        for i in range(4):
            hand[players[i]] = deck[0:hand_size]
            del deck[0:hand_size]
        chien.extend(deck)
        del (deck[:])
        msg_elts = {}
        for player in players:
            msg_elts[player] = self.__card_list_to_xml(hand[player], "hand")

        RoomGame.newRound(self, room_jid, (common_data, msg_elts), profile)

        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:
        self.send(to_jid, self.__ask_contrat(), profile=profile)

    def room_game_cmd(self, mess_elt, profile):
        """
        @param mess_elt: instance of twisted.words.xish.domish.Element
        """
        client = self.host.getClient(profile)
        from_jid = jid.JID(mess_elt["from"])
        room_jid = jid.JID(from_jid.userhost())
        nick = self.host.plugins["XEP-0045"].getRoomNick(client, room_jid)

        game_elt = mess_elt.firstChildElement()
        game_data = self.games[room_jid]
        is_player = self.isPlayer(room_jid, nick)
        if "players_data" in game_data:
            players_data = game_data["players_data"]

        for elt in game_elt.elements():
            if not is_player and (elt.name not in ("started", "players")):
                continue  # user is in the room but not playing

            if elt.name in (
                "started",
                "players",
            ):  # new game created and/or players list updated
                players = []
                for player in elt.elements():
                    players.append(str(player))
                signal = (
                    self.host.bridge.tarotGameStarted
                    if elt.name == "started"
                    else self.host.bridge.tarotGamePlayers
                )
                signal(room_jid.userhost(), from_jid.full(), players, profile)

            elif elt.name == "player_ready":  # ready to play
                player = elt["player"]
                status = self.games[room_jid]["status"]
                nb_players = len(self.games[room_jid]["players"])
                status[player] = "ready"
                log.debug(
                    _("Player %(player)s is ready to start [status: %(status)s]")
                    % {"player": player, "status": status}
                )
                if (
                    list(status.values()).count("ready") == nb_players
                ):  # everybody is ready, we can start the game
                    self.newRound(room_jid, profile)

            elif elt.name == "hand":  # a new hand has been received
                self.host.bridge.tarotGameNew(
                    room_jid.userhost(), self.__xml_to_list(elt), profile
                )

            elif elt.name == "contrat":  # it's time to choose contrat
                form = data_form.Form.fromElement(elt.firstChildElement())
                session_id, session_data = self._sessions.newSession(profile=profile)
                session_data["room_jid"] = room_jid
                xml_data = xml_tools.dataForm2XMLUI(
                    form, self.__choose_contrat_id, session_id
                ).toXml()
                self.host.bridge.tarotGameChooseContrat(
                    room_jid.userhost(), xml_data, profile
                )

            elif elt.name == "contrat_choosed":
                # TODO: check we receive the contrat from the right person
                # TODO: use proper XEP-0004 way for answering form
                player = elt["player"]
                players_data[player]["contrat"] = str(elt)
                contrats = [players_data[p]["contrat"] for p in game_data["players"]]
                if contrats.count(None):
                    # not everybody has choosed his contrat, it's next one turn
                    player = self.__next_player(game_data)
                    to_jid = jid.JID(room_jid.userhost() + "/" + player)  # FIXME: gof:
                    self.send(to_jid, self.__ask_contrat(), profile=profile)
                else:
                    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)
                        if idx_pl > idx_best:
                            best_contrat[0] = player
                            best_contrat[1] = contrat
                    if best_contrat[1] == "Passe":
                        log.debug(_("Everybody is passing, round ended"))
                        to_jid = jid.JID(room_jid.userhost())
                        self.send(
                            to_jid,
                            self.__give_scores(*self.__draw_game(game_data)),
                            profile=profile,
                        )
                        game_data["init_player"] = (game_data["init_player"] + 1) % len(
                            game_data["players"]
                        )  # we change the dealer
                        for player in game_data["players"]:
                            game_data["status"][player] = "init"
                        return
                    log.debug(
                        _("%(player)s win the bid with %(contrat)s")
                        % {"player": best_contrat[0], "contrat": best_contrat[1]}
                    )
                    game_data["contrat"] = best_contrat[1]

                    if (
                        game_data["contrat"] == "Garde Sans"
                        or game_data["contrat"] == "Garde Contre"
                    ):
                        self.__start_play(room_jid, game_data, profile)
                        game_data["attaquant"] = best_contrat[0]
                    else:
                        # Time to show the chien to everybody
                        to_jid = jid.JID(room_jid.userhost())  # FIXME: gof:
                        elem = self.__card_list_to_xml(game_data["chien"], "chien")
                        self.send(
                            to_jid, elem, {"attaquant": best_contrat[0]}, profile=profile
                        )
                        # the attacker (attaquant) get the chien
                        game_data["hand"][best_contrat[0]].extend(game_data["chien"])
                        del game_data["chien"][:]

                    if game_data["contrat"] == "Garde Sans":
                        # The chien go into attaquant's (attacker) levees
                        players_data[best_contrat[0]]["levees"].extend(game_data["chien"])
                        del game_data["chien"][:]

            elif elt.name == "chien":  # we have received the chien
                log.debug(_("tarot: chien received"))
                data = {"attaquant": elt["attaquant"]}
                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: show atouts (trumps) if player put some in écart
                    assert (
                        game_data["attaquant"] == elt["player"]
                    )  # TODO: throw an xml error here
                    list_cards = TarotCard.from_tuples(self.__xml_to_list(elt))
                    # we now check validity of card
                    invalid_cards = self.__invalid_cards(game_data, list_cards)
                    if invalid_cards:
                        elem = self.__invalid_cards_elt(
                            list_cards, invalid_cards, game_data["stage"]
                        )
                        self.send(
                            jid.JID(room_jid.userhost() + "/" + elt["player"]),
                            elem,
                            profile=profile,
                        )
                        return

                    # FIXME: gof: manage Garde Sans & Garde Contre cases
                    players_data[elt["player"]]["levees"].extend(
                        list_cards
                    )  # we add the chien to attaquant's levées
                    for card in list_cards:
                        game_data["hand"][elt["player"]].remove(card)

                    self.__start_play(room_jid, game_data, profile)

                elif game_data["stage"] == "play":
                    current_player = game_data["players"][game_data["current_player"]]
                    cards = TarotCard.from_tuples(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:
                        # we first check validity of card
                        invalid_cards = self.__invalid_cards(game_data, cards)
                        if invalid_cards:
                            elem = self.__invalid_cards_elt(
                                cards, invalid_cards, game_data["stage"]
                            )
                            self.send(
                                jid.JID(room_jid.userhost() + "/" + current_player),
                                elem,
                                profile=profile,
                            )
                            return
                        # the card played is ok, we forward it to everybody
                        # 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"] = cards[0]

                        # then we forward the message
                        self.send(room_jid, elt, profile=profile)

                        # Did everybody played ?
                        played = [
                            players_data[player]["played"]
                            for player in game_data["players"]
                        ]
                        if all(played):
                            # everybody has played
                            winner = self.__winner(game_data)
                            log.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 left: the game is finished
                                elem = self.__give_scores(
                                    *self.__calculate_scores(game_data)
                                )
                                self.send(room_jid, elem, profile=profile)
                                game_data["init_player"] = (
                                    game_data["init_player"] + 1
                                ) % len(
                                    game_data["players"]
                                )  # we change the dealer
                                for player in game_data["players"]:
                                    game_data["status"][player] = "init"
                                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
                        to_jid = jid.JID(room_jid.userhost() + "/" + next_player)
                        self.send(to_jid, "your_turn", profile=profile)

            elif elt.name == "your_turn":
                self.host.bridge.tarotGameYourTurn(room_jid.userhost(), profile)

            elif elt.name == "score":
                form_elt = next(elt.elements(name="x", uri="jabber:x:data"))
                winners = []
                loosers = []
                for winner in elt.elements(name="winner", uri=NS_CG):
                    winners.append(str(winner))
                for looser in elt.elements(name="looser", uri=NS_CG):
                    loosers.append(str(looser))
                form = data_form.Form.fromElement(form_elt)
                session_id, session_data = self._sessions.newSession(profile=profile)
                session_data["room_jid"] = room_jid
                xml_data = xml_tools.dataForm2XMLUI(
                    form, self.__score_id, session_id
                ).toXml()
                self.host.bridge.tarotGameScore(
                    room_jid.userhost(), xml_data, winners, loosers, profile
                )
            elif elt.name == "error":
                if elt["type"] == "invalid_cards":
                    played_cards = self.__xml_to_list(
                        next(elt.elements(name="played", uri=NS_CG))
                    )
                    invalid_cards = self.__xml_to_list(
                        next(elt.elements(name="invalid", uri=NS_CG))
                    )
                    self.host.bridge.tarotGameInvalidCards(
                        room_jid.userhost(),
                        elt["phase"],
                        played_cards,
                        invalid_cards,
                        profile,
                    )
                else:
                    log.error(_("Unmanaged error type: %s") % elt["type"])
            else:
                log.error(_("Unmanaged card game element: %s") % elt.name)

    def getSyncDataForPlayer(self, room_jid, nick):
        return []