Mercurial > libervia-backend
changeset 718:074970227bc0
plugin tools: turn src/plugin/games.py into a plugin and move it to src/plugins/plugin_misc_room_game.py
| author | souliane <souliane@mailoo.org> |
|---|---|
| date | Thu, 21 Nov 2013 18:23:08 +0100 |
| parents | 358018c5c398 |
| children | 56aa0e98c92e |
| files | src/plugins/plugin_misc_quiz.py src/plugins/plugin_misc_radiocol.py src/plugins/plugin_misc_room_game.py src/plugins/plugin_misc_tarot.py src/tools/plugins/games.py |
| diffstat | 5 files changed, 547 insertions(+), 521 deletions(-) [+] |
line wrap: on
line diff
--- a/src/plugins/plugin_misc_quiz.py Thu Nov 21 15:49:53 2013 +0100 +++ b/src/plugins/plugin_misc_quiz.py Thu Nov 21 18:23:08 2013 +0100 @@ -28,7 +28,6 @@ from wokkel import data_form from sat.tools.xml_tools import dataForm2XML from sat.tools.frontends.games import TarotCard -from sat.tools.plugins.games import RoomGame from time import time @@ -40,18 +39,24 @@ "import_name": "Quiz", "type": "Game", "protocols": [], - "dependencies": ["XEP-0045", "XEP-0249"], + "dependencies": ["XEP-0045", "XEP-0249", "ROOM-GAME"], "main": "Quiz", "handler": "yes", "description": _("""Implementation of Quiz game""") } -class Quiz(RoomGame): +class Quiz(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): info(_("Plugin Quiz initialization")) - RoomGame.__init__(self, host, PLUGIN_INFO, (NS_QG, QG_TAG), game_init={'stage': None}, player_init={'score': 0}) + self.inheritFromRoomGame(host) + RoomGame._init_(self, host, PLUGIN_INFO, (NS_QG, QG_TAG), game_init={'stage': None}, player_init={'score': 0}) host.bridge.addMethod("quizGameLaunch", ".plugin", in_sign='asss', out_sign='', method=self.prepareRoom) # args: players, room_jid, profile host.bridge.addMethod("quizGameCreate", ".plugin", in_sign='sass', out_sign='', method=self.createGame) # args: room_jid, players, profile host.bridge.addMethod("quizGameReady", ".plugin", in_sign='sss', out_sign='', method=self.playerReady) # args: player, referee, profile
--- a/src/plugins/plugin_misc_radiocol.py Thu Nov 21 15:49:53 2013 +0100 +++ b/src/plugins/plugin_misc_radiocol.py Thu Nov 21 18:23:08 2013 +0100 @@ -25,7 +25,6 @@ import os.path from os import unlink from mutagen.oggvorbis import OggVorbis, OggVorbisHeaderError -from sat.tools.plugins.games import RoomGame NC_RADIOCOL = 'http://www.goffi.org/protocol/radiocol' @@ -36,7 +35,7 @@ "import_name": "Radiocol", "type": "Exp", "protocols": [], - "dependencies": ["XEP-0045", "XEP-0249"], + "dependencies": ["XEP-0045", "XEP-0249", "ROOM-GAME"], "main": "Radiocol", "handler": "yes", "description": _("""Implementation of radio collective""") @@ -45,11 +44,17 @@ QUEUE_LIMIT = 2 -class Radiocol(RoomGame): +class Radiocol(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): info(_("Radio collective initialization")) - RoomGame.__init__(self, host, PLUGIN_INFO, (NC_RADIOCOL, RADIOC_TAG), + self.inheritFromRoomGame(host) + RoomGame._init_(self, host, PLUGIN_INFO, (NC_RADIOCOL, RADIOC_TAG), game_init={'queue': [], 'upload': True, 'playing': False, 'to_delete': {}}) self.host = host host.bridge.addMethod("radiocolLaunch", ".plugin", in_sign='asss', out_sign='', method=self.prepareRoom)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/plugins/plugin_misc_room_game.py Thu Nov 21 18:23:08 2013 +0100 @@ -0,0 +1,520 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# SAT: a jabber client +# Copyright (C) 2009, 2010, 2011, 2012, 2013 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 logging import debug, warning, error +from twisted.words.protocols.jabber.jid import JID +from twisted.words.xish import domish +from time import time +from wokkel import disco, iwokkel +from zope.interface import implements +try: + from twisted.words.protocols.xmlstream import XMPPHandler +except ImportError: + from wokkel.subprotocols import XMPPHandler + +# Don't forget to set it to False before you commit +_DEBUG = False +_DEBUG_FILE = False + +PLUGIN_INFO = { + "name": "Room game", + "import_name": "ROOM-GAME", + "type": "MISC", + "protocols": [], + "dependencies": ["XEP-0045", "XEP-0249"], + "main": "RoomGame", + "handler": "no", # handler MUST be "no" (dynamic inheritance) + "description": _("""Base class for MUC games""") +} + + +class RoomGame(object): + """This class is used to help launching a MUC game.""" + + # Values for self.invite_mode (who can invite after the game creation) + FROM_ALL, FROM_NONE, FROM_REFEREE, FROM_PLAYERS = xrange(0, 4) + # Values for self.wait_mode (for who we should wait before creating the game) + FOR_ALL, FOR_NONE = xrange(0, 2) + # Values for self.join_mode (who can join the game - NONE means solo game) + ALL, INVITED, NONE = xrange(0, 3) + # Values for ready_mode (how to turn a MUC user into a player) + ASK, FORCE = xrange(0, 2) + + MESSAGE = '/message' + REQUEST = '%s/%s[@xmlns="%s"]' + + def __init__(self, host): + self.host = host + + def _init_(self, host, plugin_info, ns_tag, game_init={}, player_init={}): + """ + @param host + @param plugin_info: PLUGIN_INFO map of the game plugin + @ns_tag: couple (nameservice, tag) to construct the messages + @param game_init: dictionary for general game initialization + @param player_init: dictionary for player initialization, applicable to each player + """ + self.host = host + self.name = plugin_info["import_name"] + self.ns_tag = ns_tag + self.request = self.REQUEST % (self.MESSAGE, ns_tag[1], ns_tag[0]) + self.game_init = game_init + self.player_init = player_init + self.games = {} + self.invitations = {} # list of couple (x, y) with x the time and y a list of users + + # These are the default settings, which can be overwritten by child class after initialization + self.invite_mode = self.FROM_PLAYERS if self.player_init == {} else self.FROM_NONE + self.wait_mode = self.FOR_NONE if self.player_init == {} else self.FOR_ALL + self.join_mode = self.INVITED + self.ready_mode = self.FORCE # TODO: asking for confirmation is not implemented + + host.trigger.add("MUC user joined", self.userJoinedTrigger) + host.trigger.add("MUC user left", self.userLeftTrigger) + + def createOrInvite(self, room, other_players, profile): + """ + This is called only when someone explicitly wants to play. + The game must not be created if one already exists in the room, + or its creation could be postponed until all the expected players + join the room (in that case it will be created from userJoinedTrigger). + @param room: instance of wokkel.muc.Room + @param other_players: list for other players JID userhosts + """ + user_jid = self.host.getJidNStream(profile)[0] + room_jid_s = room.occupantJID.userhost() + nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid_s, profile) + nicks = [nick] + if self.gameExists(room_jid_s): + if not self.checkJoinAuth(room_jid_s, user_jid.userhost(), nick): + return + nicks.extend(self.invitePlayers(room, other_players, nick, profile)) + self.updatePlayers(room_jid_s, nicks, profile) + else: + self.initGame(room_jid_s, nick) + (auth, waiting, missing) = self.checkWaitAuth(room, other_players) + nicks.extend(waiting) + nicks.extend(self.invitePlayers(room, missing, nick, profile)) + if auth: + self.createGame(room_jid_s, nicks, profile) + else: + self.updatePlayers(room_jid_s, nicks, profile) + + def initGame(self, room_jid_s, referee_nick): + """Important: do not add the referee to 'players' yet. For a + <players /> message to be emitted whenever a new player is joining, + it is necessary to not modify 'players' outside of updatePlayers. + """ + referee = room_jid_s + '/' + referee_nick + self.games[room_jid_s] = {'referee': referee, 'players': [], 'started': False} + self.games[room_jid_s].update(self.game_init) + + def gameExists(self, room_jid_s, started=False): + """Return True if a game has been initialized/started. + @param started: if False, the game must be initialized only, + otherwise it must be initialized and started with createGame. + @return: True if a game is initialized/started in that room""" + return room_jid_s in self.games and (not started or self.games[room_jid_s]['started']) + + def checkJoinAuth(self, room_jid_s, user_jid_s=None, nick="", verbose=False): + """Checks if this profile is allowed to join the game. + The parameter nick is used to check if the user is already + a player in that game. When this method is called from + userJoinedTrigger, nick is also used to check the user + identity instead of user_jid_s (see TODO remark below). + @param room_jid_s: the room hosting the game + @param user_jid_s: JID userhost of the user + @param nick: nick of the user + """ + auth = False + if not self.gameExists(room_jid_s): + auth = False + elif self.join_mode == self.ALL or self.isPlayer(room_jid_s, nick): + auth = True + elif self.join_mode == self.INVITED: + # considering all the batches of invitations + for invitations in self.invitations[room_jid_s]: + if user_jid_s is not None: + if user_jid_s in invitations[1]: + auth = True + break + else: + # TODO: that's not secure enough but what to do if + # wokkel.muc.User's 'entity' attribute is not set?! + if nick in [JID(invited).user for invited in invitations[1]]: + auth = True + break + + if not auth and (verbose or _DEBUG): + debug(_("%s not allowed to join the game %s in %s") % (user_jid_s or nick, self.name, room_jid_s)) + return auth + + def updatePlayers(self, room_jid_s, nicks, profile): + """Signal to the room or to each player that some players joined the game""" + if nicks == []: + return + new_nicks = set(nicks).difference(self.games[room_jid_s]['players']) + if len(new_nicks) == 0: + return + self.games[room_jid_s]['players'].extend(new_nicks) + self.signalPlayers(room_jid_s, [JID(room_jid_s)], profile) + + def signalPlayers(self, room_jid_s, recipients, profile): + """Let these guys know that we are playing (they may not play themselves).""" + if self.gameExists(room_jid_s, started=True): + element = self.createStartElement(self.games[room_jid_s]['players']) + else: + element = self.createStartElement(self.games[room_jid_s]['players'], name="players") + for recipient in recipients: + self.send(recipient, element, profile=profile) + + def invitePlayers(self, room, other_players, nick, profile): + """Invite players to a room, associated game may exist or not. + @param room: wokkel.muc.Room instance + @param other_players: list of JID userhosts to invite + @param nick: nick of the user who send the invitation + @return: list of the invited players who were already in the room + """ + room_jid = room.occupantJID.userhostJID() + room_jid_s = room.occupantJID.userhost() + if not self.checkInviteAuth(room_jid_s, nick): + return [] + self.invitations.setdefault(room_jid_s, []) + # TODO: remove invitation waiting for too long, using the time data + self.invitations[room_jid_s].append((time(), other_players)) + nicks = [nick] + for player_jid in [JID(player) for player in other_players]: + # TODO: find a way to make it secure + other_nick = self.host.plugins["XEP-0045"].getRoomNickOfUser(room, player_jid, secure=False) + if other_nick is None: + self.host.plugins["XEP-0249"].invite(player_jid, room_jid, {"game": self.name}, profile) + else: + nicks.append(other_nick) + return nicks + + def checkInviteAuth(self, room_jid_s, nick, verbose=False): + """Checks if this profile is allowed to invite players""" + auth = False + if self.invite_mode == self.FROM_ALL or not self.gameExists(room_jid_s): + auth = True + elif self.invite_mode == self.FROM_NONE: + auth = not self.gameExists(room_jid_s, started=True) + elif self.invite_mode == self.FROM_REFEREE: + auth = self.isReferee(room_jid_s, nick) + elif self.invite_mode == self.FROM_PLAYERS: + auth = self.isPlayer(room_jid_s, nick) + if not auth and (verbose or _DEBUG): + debug(_("%s not allowed to invite for the game %s in %s") % (nick, self.name, room_jid_s)) + return auth + + def isReferee(self, room_jid_s, nick): + """Checks if the player with this nick is the referee for the game in this room""" + if not self.gameExists(room_jid_s): + return False + return room_jid_s + '/' + nick == self.games[room_jid_s]['referee'] + + def isPlayer(self, room_jid_s, nick): + """Checks if the player with this nick is a player for the game in this room. + Important: the referee is not in the 'players' list right after the game + initialization - check with isReferee to be sure nick is not a player. + """ + if not self.gameExists(room_jid_s): + return False + return nick in self.games[room_jid_s]['players'] or self.isReferee(room_jid_s, nick) + + def checkWaitAuth(self, room, other_players, verbose=False): + """Check if we must wait before starting the game or not. + @return: (x, y, z) with: + x: False if we must wait, True otherwise + y: the nicks of the players that have been checked and confirmed + z: the players that have not been checked or that are missing + """ + if self.wait_mode == self.FOR_NONE or other_players == []: + result = (True, [], other_players) + elif len(room.roster) < len(other_players) + 1: + result = (False, [], other_players) + else: + # TODO: find a way to make it secure + (nicks, missing) = self.host.plugins["XEP-0045"].getRoomNicksOfUsers(room, other_players, secure=False) + result = (len(nicks) == len(other_players), nicks, missing) + if not result[0] and (verbose or _DEBUG): + debug(_("Still waiting for %s before starting the game %s in %s") % (result[2], self.name, room.occupantJID.userhost())) + return result + + def getUniqueName(self, muc_service="", profile_key='@DEFAULT@'): + room = self.host.plugins["XEP-0045"].getUniqueName(muc_service, profile_key=profile_key) + return "sat_%s_%s" % (self.name.lower(), room) if room != "" else "" + + def prepareRoom(self, other_players=[], room_jid=None, profile_key='@NONE@'): + """Prepare the room for a game: create it and invite players. + @param other_players: list for other players JID userhosts + @param room_jid: JID userhost of the room to reuse or None to create a new room + """ + debug(_('Preparing room for %s game') % self.name) + profile = self.host.memory.getProfileName(profile_key) + if not profile: + error(_("Unknown profile")) + return + + def roomJoined(room): + """@param room: instance of wokkel.muc.Room""" + self.createOrInvite(room, other_players, profile) + + def afterClientInit(room_jid): + """Create/join the given room, or a unique generated one if no room is specified. + @param room_jid: room to join + """ + if room_jid is not None and room_jid != "": # a room name has been specified + if room_jid in self.host.plugins["XEP-0045"].clients[profile].joined_rooms: + roomJoined(self.host.plugins["XEP-0045"].clients[profile].joined_rooms[room_jid]) + return + else: + room_jid = self.getUniqueName(profile_key=profile_key) + if room_jid == "": + return + user_jid = self.host.getJidNStream(profile)[0] + d = self.host.plugins["XEP-0045"].join(JID(room_jid), user_jid.user, {}, profile) + d.addCallback(roomJoined) + + client = self.host.getClient(profile) + if not client: + error(_('No client for this profile key: %s') % profile_key) + return + client.client_initialized.addCallback(lambda ignore: afterClientInit(room_jid)) + + def userJoinedTrigger(self, room, user, profile): + """This trigger is used to check if the new user can take part of a game, + create the game if we were waiting for him or just update the players list. + @room: wokkel.muc.Room object. room.roster is a dict{wokkel.muc.User.nick: wokkel.muc.User} + @user: wokkel.muc.User object. user.nick is a unicode and user.entity a JID + @return: True to not interrupt the main process. + """ + room_jid_s = room.occupantJID.userhost() + profile_nick = room.occupantJID.resource + if not self.isReferee(room_jid_s, profile_nick): + return True # profile is not the referee + if not self.checkJoinAuth(room_jid_s, nick=user.nick): + # user not allowed but let him know that we are playing :p + self.signalPlayers(room_jid_s, [JID(room_jid_s + '/' + user.nick)], profile) + return True + if self.wait_mode == self.FOR_ALL: + # considering the last batch of invitations + batch = len(self.invitations[room_jid_s]) - 1 + if batch < 0: + error("Invitations from %s to play %s in %s have been lost!" % (profile_nick, self.name, room_jid_s)) + return True + other_players = self.invitations[room_jid_s][batch][1] + (auth, nicks, dummy) = self.checkWaitAuth(room, other_players) + if auth: + del self.invitations[room_jid_s][batch] + nicks.insert(0, profile_nick) # add the referee + self.createGame(room_jid_s, nicks, profile_key=profile) + return True + # let the room know that a new player joined + self.updatePlayers(room_jid_s, [user.nick], profile) + return True + + def userLeftTrigger(self, room, user, profile): + """This trigger is used to update or stop the game when a user leaves. + @room: wokkel.muc.Room object. room.roster is a dict{wokkel.muc.User.nick: wokkel.muc.User} + @user: wokkel.muc.User object. user.nick is a unicode and user.entity a JID + @return: True to not interrupt the main process. + """ + room_jid_s = room.occupantJID.userhost() + profile_nick = room.occupantJID.resource + if not self.isReferee(room_jid_s, profile_nick): + return True # profile is not the referee + if self.isPlayer(room_jid_s, user.nick): + try: + self.games[room_jid_s]['players'].remove(user.nick) + except ValueError: + pass + if self.wait_mode == self.FOR_ALL: + # allow this user to join the game again + user_jid = user.entity.userhost() + if len(self.invitations[room_jid_s]) == 0: + self.invitations[room_jid_s].append((time(), [user_jid])) + else: + batch = 0 # add to the first batch of invitations + if user_jid not in self.invitations[room_jid_s][batch][1]: + self.invitations[room_jid_s][batch][1].append(user_jid) + return True + + def checkCreateGameAndInit(self, room_jid_s, profile): + """Check if that profile can create the game. If the game can be created + but is not initialized yet, this method will also do the initialization + @return: a couple (create, sync) with: + - create: set to True to allow the game creation + - sync: set to True to advice a game synchronization + """ + user_nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid_s, profile) + if not user_nick: + error('Internal error') + return False, False + if self.gameExists(room_jid_s): + referee = self.isReferee(room_jid_s, user_nick) + if self.gameExists(room_jid_s, started=True): + warning(_("%s game already created in room %s") % (self.name, room_jid_s)) + return False, referee + elif not referee: + warning(_("%s game in room %s can only be created by %s") % (self.name, room_jid_s, user_nick)) + return False, False + else: + self.initGame(room_jid_s, user_nick) + return True, False + + def createGame(self, room_jid_s, nicks=[], profile_key='@NONE@'): + """Create a new game - this can be called directly from a frontend + and skips all the checks and invitation system, but the game must + not exist and all the players must be in the room already. + @param room_jid: JID userhost of the room + @param nicks: list of players nicks in the room + @param profile_key: %(doc_profile_key)s""" + debug(_("Creating %s game in room %s") % (self.name, room_jid_s)) + profile = self.host.memory.getProfileName(profile_key) + if not profile: + error(_("profile %s is unknown") % profile_key) + return + (create, sync) = self.checkCreateGameAndInit(room_jid_s, profile) + if not create: + if sync: + debug(_('Synchronize game %s in %s for %s') % (self.name, room_jid_s, ', '.join(nicks))) + # TODO: we should call a method to re-send the information to a player who left + # and joined the room again, currently: we may restart a whole new round... + self.updatePlayers(room_jid_s, nicks, profile) + return + self.games[room_jid_s]['started'] = True + self.updatePlayers(room_jid_s, nicks, profile) + if self.player_init == {}: + return + # specific data to each player + status = {} + players_data = {} + for nick in nicks: + # The dict must be COPIED otherwise it is shared between all users + players_data[nick] = self.player_init.copy() + status[nick] = "init" + self.games[room_jid_s].update({'status': status, 'players_data': players_data}) + + def playerReady(self, player, referee, profile_key='@NONE@'): + """Must be called when player is ready to start a new game""" + profile = self.host.memory.getProfileName(profile_key) + if not profile: + error(_("profile %s is unknown") % profile_key) + return + debug('new player ready: %s' % profile) + self.send(JID(referee), 'player_ready', {'player': player}, profile=profile) + + def newRound(self, room_jid, data, profile): + """Launch a new round (reinit the user data)""" + debug(_('new round for %s game') % self.name) + game_data = self.games[room_jid.userhost()] + players = game_data['players'] + players_data = game_data['players_data'] + game_data['stage'] = "init" + + common_data, msg_elts = data if data is not None else (None, None) + + if isinstance(msg_elts, dict): + for player in players: + to_jid = JID(room_jid.userhost() + "/" + player) # FIXME: gof: + elem = msg_elts[player] if isinstance(msg_elts[player], domish.Element) else None + self.send(to_jid, elem, profile=profile) + elif isinstance(msg_elts, domish.Element): + self.send(room_jid, msg_elts, profile=profile) + if common_data is not None: + for player in players: + players_data[player].update(common_data) + + def createGameElt(self, to_jid, type_="normal"): + """Create a generic domish Element for the game""" + type_ = "normal" if to_jid.resource else "groupchat" + elt = domish.Element((None, 'message')) + elt["to"] = to_jid.full() + elt["type"] = type_ + elt.addElement(self.ns_tag) + return elt + + def createStartElement(self, players=None, name="started"): + """Create a game "started" domish Element + @param name: element name (default: "started"). + """ + started_elt = domish.Element((None, name)) + if players is None: + return started_elt + idx = 0 + for player in players: + player_elt = domish.Element((None, 'player')) + player_elt.addContent(player) + player_elt['index'] = str(idx) + idx += 1 + started_elt.addChild(player_elt) + return started_elt + + def send(self, to_jid, elem=None, attrs=None, content=None, profile=None): + """ + @param to_jid: recipient JID + @param elem: domish.Element, unicode or a couple: + - domish.Element to be directly added as a child to the message + - unicode name or couple (uri, name) to create a new domish.Element + and add it as a child to the message (see domish.Element.addElement) + @param attrs: dictionary of attributes for the new child + @param content: unicode that is appended to the child content + @param profile: the profile from which the message is sent + """ + if profile is None: + error(_("Message can not be sent without a sender profile")) + return + msg = self.createGameElt(to_jid) + if elem is not None: + if isinstance(elem, domish.Element): + msg.firstChildElement().addChild(elem) + else: + elem = msg.firstChildElement().addElement(elem) + if attrs is not None: + elem.attributes.update(attrs) + if content is not None: + elem.addContent(content) + self.host.profiles[profile].xmlstream.send(msg) + + if _DEBUG_FILE: + # From here you will see all the game messages + file_ = open("/tmp/game_messages", "a") + file_.write("%s from %s to %s: %s\n" % (self.name, profile, "room" if to_jid.resource is None else to_jid.resource, elem.toXml())) + file_.close() + + def getHandler(self, profile): + return RoomGameHandler(self) + + +class RoomGameHandler (XMPPHandler): + implements(iwokkel.IDisco) + + def __init__(self, plugin_parent): + self.plugin_parent = plugin_parent + self.host = plugin_parent.host + + def connectionInitialized(self): + self.xmlstream.addObserver(self.plugin_parent.request, self.plugin_parent.room_game_cmd, profile=self.parent.profile) + + def getDiscoInfo(self, requestor, target, nodeIdentifier=''): + return [disco.DiscoFeature(self.plugin_parent.ns_tag[0])] + + def getDiscoItems(self, requestor, target, nodeIdentifier=''): + return []
--- a/src/plugins/plugin_misc_tarot.py Thu Nov 21 15:49:53 2013 +0100 +++ b/src/plugins/plugin_misc_tarot.py Thu Nov 21 18:23:08 2013 +0100 @@ -24,7 +24,6 @@ from sat.tools.xml_tools import dataForm2XML from sat.tools.frontends.games import TarotCard -from sat.tools.plugins.games import RoomGame from time import time import random @@ -37,18 +36,24 @@ "import_name": "Tarot", "type": "Misc", "protocols": [], - "dependencies": ["XEP-0045", "XEP-0249"], + "dependencies": ["XEP-0045", "XEP-0249", "ROOM-GAME"], "main": "Tarot", "handler": "yes", "description": _("""Implementation of Tarot card game""") } -class Tarot(RoomGame): +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): info(_("Plugin Tarot initialization")) - RoomGame.__init__(self, host, PLUGIN_INFO, (NS_CG, CG_TAG), + 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')]
--- a/src/tools/plugins/games.py Thu Nov 21 15:49:53 2013 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,509 +0,0 @@ -#!/usr/bin/python -# -*- coding: utf-8 -*- - -# SAT: a jabber client -# Copyright (C) 2009, 2010, 2011, 2012, 2013 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 logging import debug, warning, error -from twisted.words.protocols.jabber.jid import JID -from twisted.words.xish import domish -from time import time -from wokkel import disco, iwokkel -from zope.interface import implements -try: - from twisted.words.protocols.xmlstream import XMPPHandler -except ImportError: - from wokkel.subprotocols import XMPPHandler - - -"""This library help manage general games (e.g. card games) and it can be used by plugins.""" - -# Don't forget to set it to False before you commit -debugMsg = True -debugFile = True - - -class RoomGame(object): - """This class is used to help launching a MUC game.""" - - # Values for self.invite_mode (who can invite after the game creation) - FROM_ALL, FROM_NONE, FROM_REFEREE, FROM_PLAYERS = xrange(0, 4) - # Values for self.wait_mode (for who we should wait before creating the game) - FOR_ALL, FOR_NONE = xrange(0, 2) - # Values for self.join_mode (who can join the game - NONE means solo game) - ALL, INVITED, NONE = xrange(0, 3) - # Values for ready_mode (how to turn a MUC user into a player) - ASK, FORCE = xrange(0, 2) - - MESSAGE = '/message' - REQUEST = '%s/%s[@xmlns="%s"]' - - def __init__(self, host, plugin_info, ns_tag, game_init={}, player_init={}): - """ - @param host - @param plugin_info: PLUGIN_INFO map of the game plugin - @ns_tag: couple (nameservice, tag) to construct the messages - @param game_init: dictionary for general game initialization - @param player_init: dictionary for player initialization, applicable to each player - """ - self.host = host - self.name = plugin_info["import_name"] - self.ns_tag = ns_tag - self.request = self.REQUEST % (self.MESSAGE, ns_tag[1], ns_tag[0]) - self.game_init = game_init - self.player_init = player_init - self.games = {} - self.invitations = {} # list of couple (x, y) with x the time and y a list of users - - # These are the default settings, which can be overwritten by child class after initialization - self.invite_mode = self.FROM_PLAYERS if self.player_init == {} else self.FROM_NONE - self.wait_mode = self.FOR_NONE if self.player_init == {} else self.FOR_ALL - self.join_mode = self.INVITED - self.ready_mode = self.FORCE # TODO: asking for confirmation is not implemented - - host.trigger.add("MUC user joined", self.userJoinedTrigger) - host.trigger.add("MUC user left", self.userLeftTrigger) - - def createOrInvite(self, room, other_players, profile): - """ - This is called only when someone explicitly wants to play. - The game must not be created if one already exists in the room, - or its creation could be postponed until all the expected players - join the room (in that case it will be created from userJoinedTrigger). - @param room: instance of wokkel.muc.Room - @param other_players: list for other players JID userhosts - """ - user_jid = self.host.getJidNStream(profile)[0] - room_jid_s = room.occupantJID.userhost() - nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid_s, profile) - nicks = [nick] - if self.gameExists(room_jid_s): - if not self.checkJoinAuth(room_jid_s, user_jid.userhost(), nick): - return - nicks.extend(self.invitePlayers(room, other_players, nick, profile)) - self.updatePlayers(room_jid_s, nicks, profile) - else: - self.initGame(room_jid_s, nick) - (auth, waiting, missing) = self.checkWaitAuth(room, other_players) - nicks.extend(waiting) - nicks.extend(self.invitePlayers(room, missing, nick, profile)) - if auth: - self.createGame(room_jid_s, nicks, profile) - else: - self.updatePlayers(room_jid_s, nicks, profile) - - def initGame(self, room_jid_s, referee_nick): - """Important: do not add the referee to 'players' yet. For a - <players /> message to be emitted whenever a new player is joining, - it is necessary to not modify 'players' outside of updatePlayers. - """ - referee = room_jid_s + '/' + referee_nick - self.games[room_jid_s] = {'referee': referee, 'players': [], 'started': False} - self.games[room_jid_s].update(self.game_init) - - def gameExists(self, room_jid_s, started=False): - """Return True if a game has been initialized/started. - @param started: if False, the game must be initialized only, - otherwise it must be initialized and started with createGame. - @return: True if a game is initialized/started in that room""" - return room_jid_s in self.games and (not started or self.games[room_jid_s]['started']) - - def checkJoinAuth(self, room_jid_s, user_jid_s=None, nick="", verbose=False): - """Checks if this profile is allowed to join the game. - The parameter nick is used to check if the user is already - a player in that game. When this method is called from - userJoinedTrigger, nick is also used to check the user - identity instead of user_jid_s (see TODO remark below). - @param room_jid_s: the room hosting the game - @param user_jid_s: JID userhost of the user - @param nick: nick of the user - """ - auth = False - if not self.gameExists(room_jid_s): - auth = False - elif self.join_mode == self.ALL or self.isPlayer(room_jid_s, nick): - auth = True - elif self.join_mode == self.INVITED: - # considering all the batches of invitations - for invitations in self.invitations[room_jid_s]: - if user_jid_s is not None: - if user_jid_s in invitations[1]: - auth = True - break - else: - # TODO: that's not secure enough but what to do if - # wokkel.muc.User's 'entity' attribute is not set?! - if nick in [JID(invited).user for invited in invitations[1]]: - auth = True - break - - if not auth and (verbose or debugMsg): - debug(_("%s not allowed to join the game %s in %s") % (user_jid_s or nick, self.name, room_jid_s)) - return auth - - def updatePlayers(self, room_jid_s, nicks, profile): - """Signal to the room or to each player that some players joined the game""" - if nicks == []: - return - new_nicks = set(nicks).difference(self.games[room_jid_s]['players']) - if len(new_nicks) == 0: - return - self.games[room_jid_s]['players'].extend(new_nicks) - self.signalPlayers(room_jid_s, [JID(room_jid_s)], profile) - - def signalPlayers(self, room_jid_s, recipients, profile): - """Let these guys know that we are playing (they may not play themselves).""" - if self.gameExists(room_jid_s, started=True): - element = self.createStartElement(self.games[room_jid_s]['players']) - else: - element = self.createStartElement(self.games[room_jid_s]['players'], name="players") - for recipient in recipients: - self.send(recipient, element, profile=profile) - - def invitePlayers(self, room, other_players, nick, profile): - """Invite players to a room, associated game may exist or not. - @param room: wokkel.muc.Room instance - @param other_players: list of JID userhosts to invite - @param nick: nick of the user who send the invitation - @return: list of the invited players who were already in the room - """ - room_jid = room.occupantJID.userhostJID() - room_jid_s = room.occupantJID.userhost() - if not self.checkInviteAuth(room_jid_s, nick): - return [] - self.invitations.setdefault(room_jid_s, []) - # TODO: remove invitation waiting for too long, using the time data - self.invitations[room_jid_s].append((time(), other_players)) - nicks = [nick] - for player_jid in [JID(player) for player in other_players]: - # TODO: find a way to make it secure - other_nick = self.host.plugins["XEP-0045"].getRoomNickOfUser(room, player_jid, secure=False) - if other_nick is None: - self.host.plugins["XEP-0249"].invite(player_jid, room_jid, {"game": self.name}, profile) - else: - nicks.append(other_nick) - return nicks - - def checkInviteAuth(self, room_jid_s, nick, verbose=False): - """Checks if this profile is allowed to invite players""" - auth = False - if self.invite_mode == self.FROM_ALL or not self.gameExists(room_jid_s): - auth = True - elif self.invite_mode == self.FROM_NONE: - auth = not self.gameExists(room_jid_s, started=True) - elif self.invite_mode == self.FROM_REFEREE: - auth = self.isReferee(room_jid_s, nick) - elif self.invite_mode == self.FROM_PLAYERS: - auth = self.isPlayer(room_jid_s, nick) - if not auth and (verbose or debugMsg): - debug(_("%s not allowed to invite for the game %s in %s") % (nick, self.name, room_jid_s)) - return auth - - def isReferee(self, room_jid_s, nick): - """Checks if the player with this nick is the referee for the game in this room""" - if not self.gameExists(room_jid_s): - return False - return room_jid_s + '/' + nick == self.games[room_jid_s]['referee'] - - def isPlayer(self, room_jid_s, nick): - """Checks if the player with this nick is a player for the game in this room. - Important: the referee is not in the 'players' list right after the game - initialization - check with isReferee to be sure nick is not a player. - """ - if not self.gameExists(room_jid_s): - return False - return nick in self.games[room_jid_s]['players'] or self.isReferee(room_jid_s, nick) - - def checkWaitAuth(self, room, other_players, verbose=False): - """Check if we must wait before starting the game or not. - @return: (x, y, z) with: - x: False if we must wait, True otherwise - y: the nicks of the players that have been checked and confirmed - z: the players that have not been checked or that are missing - """ - if self.wait_mode == self.FOR_NONE or other_players == []: - result = (True, [], other_players) - elif len(room.roster) < len(other_players) + 1: - result = (False, [], other_players) - else: - # TODO: find a way to make it secure - (nicks, missing) = self.host.plugins["XEP-0045"].getRoomNicksOfUsers(room, other_players, secure=False) - result = (len(nicks) == len(other_players), nicks, missing) - if not result[0] and (verbose or debugMsg): - debug(_("Still waiting for %s before starting the game %s in %s") % (result[2], self.name, room.occupantJID.userhost())) - return result - - def getUniqueName(self, muc_service="", profile_key='@DEFAULT@'): - room = self.host.plugins["XEP-0045"].getUniqueName(muc_service, profile_key=profile_key) - return "sat_%s_%s" % (self.name.lower(), room) if room != "" else "" - - def prepareRoom(self, other_players=[], room_jid=None, profile_key='@NONE@'): - """Prepare the room for a game: create it and invite players. - @param other_players: list for other players JID userhosts - @param room_jid: JID userhost of the room to reuse or None to create a new room - """ - debug(_('Preparing room for %s game') % self.name) - profile = self.host.memory.getProfileName(profile_key) - if not profile: - error(_("Unknown profile")) - return - - def roomJoined(room): - """@param room: instance of wokkel.muc.Room""" - self.createOrInvite(room, other_players, profile) - - def afterClientInit(room_jid): - """Create/join the given room, or a unique generated one if no room is specified. - @param room_jid: room to join - """ - if room_jid is not None and room_jid != "": # a room name has been specified - if room_jid in self.host.plugins["XEP-0045"].clients[profile].joined_rooms: - roomJoined(self.host.plugins["XEP-0045"].clients[profile].joined_rooms[room_jid]) - return - else: - room_jid = self.getUniqueName(profile_key=profile_key) - if room_jid == "": - return - user_jid = self.host.getJidNStream(profile)[0] - d = self.host.plugins["XEP-0045"].join(JID(room_jid), user_jid.user, {}, profile) - d.addCallback(roomJoined) - - client = self.host.getClient(profile) - if not client: - error(_('No client for this profile key: %s') % profile_key) - return - client.client_initialized.addCallback(lambda ignore: afterClientInit(room_jid)) - - def userJoinedTrigger(self, room, user, profile): - """This trigger is used to check if the new user can take part of a game, - create the game if we were waiting for him or just update the players list. - @room: wokkel.muc.Room object. room.roster is a dict{wokkel.muc.User.nick: wokkel.muc.User} - @user: wokkel.muc.User object. user.nick is a unicode and user.entity a JID - @return: True to not interrupt the main process. - """ - room_jid_s = room.occupantJID.userhost() - profile_nick = room.occupantJID.resource - if not self.isReferee(room_jid_s, profile_nick): - return True # profile is not the referee - if not self.checkJoinAuth(room_jid_s, nick=user.nick): - # user not allowed but let him know that we are playing :p - self.signalPlayers(room_jid_s, [JID(room_jid_s + '/' + user.nick)], profile) - return True - if self.wait_mode == self.FOR_ALL: - # considering the last batch of invitations - batch = len(self.invitations[room_jid_s]) - 1 - if batch < 0: - error("Invitations from %s to play %s in %s have been lost!" % (profile_nick, self.name, room_jid_s)) - return True - other_players = self.invitations[room_jid_s][batch][1] - (auth, nicks, dummy) = self.checkWaitAuth(room, other_players) - if auth: - del self.invitations[room_jid_s][batch] - nicks.insert(0, profile_nick) # add the referee - self.createGame(room_jid_s, nicks, profile_key=profile) - return True - # let the room know that a new player joined - self.updatePlayers(room_jid_s, [user.nick], profile) - return True - - def userLeftTrigger(self, room, user, profile): - """This trigger is used to update or stop the game when a user leaves. - @room: wokkel.muc.Room object. room.roster is a dict{wokkel.muc.User.nick: wokkel.muc.User} - @user: wokkel.muc.User object. user.nick is a unicode and user.entity a JID - @return: True to not interrupt the main process. - """ - room_jid_s = room.occupantJID.userhost() - profile_nick = room.occupantJID.resource - if not self.isReferee(room_jid_s, profile_nick): - return True # profile is not the referee - if self.isPlayer(room_jid_s, user.nick): - try: - self.games[room_jid_s]['players'].remove(user.nick) - except ValueError: - pass - if self.wait_mode == self.FOR_ALL: - # allow this user to join the game again - user_jid = user.entity.userhost() - if len(self.invitations[room_jid_s]) == 0: - self.invitations[room_jid_s].append((time(), [user_jid])) - else: - batch = 0 # add to the first batch of invitations - if user_jid not in self.invitations[room_jid_s][batch][1]: - self.invitations[room_jid_s][batch][1].append(user_jid) - return True - - def checkCreateGameAndInit(self, room_jid_s, profile): - """Check if that profile can create the game. If the game can be created - but is not initialized yet, this method will also do the initialization - @return: a couple (create, sync) with: - - create: set to True to allow the game creation - - sync: set to True to advice a game synchronization - """ - user_nick = self.host.plugins["XEP-0045"].getRoomNick(room_jid_s, profile) - if not user_nick: - error('Internal error') - return False, False - if self.gameExists(room_jid_s): - referee = self.isReferee(room_jid_s, user_nick) - if self.gameExists(room_jid_s, started=True): - warning(_("%s game already created in room %s") % (self.name, room_jid_s)) - return False, referee - elif not referee: - warning(_("%s game in room %s can only be created by %s") % (self.name, room_jid_s, user_nick)) - return False, False - else: - self.initGame(room_jid_s, user_nick) - return True, False - - def createGame(self, room_jid_s, nicks=[], profile_key='@NONE@'): - """Create a new game - this can be called directly from a frontend - and skips all the checks and invitation system, but the game must - not exist and all the players must be in the room already. - @param room_jid: JID userhost of the room - @param nicks: list of players nicks in the room - @param profile_key: %(doc_profile_key)s""" - debug(_("Creating %s game in room %s") % (self.name, room_jid_s)) - profile = self.host.memory.getProfileName(profile_key) - if not profile: - error(_("profile %s is unknown") % profile_key) - return - (create, sync) = self.checkCreateGameAndInit(room_jid_s, profile) - if not create: - if sync: - debug(_('Synchronize game %s in %s for %s') % (self.name, room_jid_s, ', '.join(nicks))) - # TODO: we should call a method to re-send the information to a player who left - # and joined the room again, currently: we may restart a whole new round... - self.updatePlayers(room_jid_s, nicks, profile) - return - self.games[room_jid_s]['started'] = True - self.updatePlayers(room_jid_s, nicks, profile) - if self.player_init == {}: - return - # specific data to each player - status = {} - players_data = {} - for nick in nicks: - # The dict must be COPIED otherwise it is shared between all users - players_data[nick] = self.player_init.copy() - status[nick] = "init" - self.games[room_jid_s].update({'status': status, 'players_data': players_data}) - - def playerReady(self, player, referee, profile_key='@NONE@'): - """Must be called when player is ready to start a new game""" - profile = self.host.memory.getProfileName(profile_key) - if not profile: - error(_("profile %s is unknown") % profile_key) - return - debug('new player ready: %s' % profile) - self.send(JID(referee), 'player_ready', {'player': player}, profile=profile) - - def newRound(self, room_jid, data, profile): - """Launch a new round (reinit the user data)""" - debug(_('new round for %s game') % self.name) - game_data = self.games[room_jid.userhost()] - players = game_data['players'] - players_data = game_data['players_data'] - game_data['stage'] = "init" - - common_data, msg_elts = data if data is not None else (None, None) - - if isinstance(msg_elts, dict): - for player in players: - to_jid = JID(room_jid.userhost() + "/" + player) # FIXME: gof: - elem = msg_elts[player] if isinstance(msg_elts[player], domish.Element) else None - self.send(to_jid, elem, profile=profile) - elif isinstance(msg_elts, domish.Element): - self.send(room_jid, msg_elts, profile=profile) - if common_data is not None: - for player in players: - players_data[player].update(common_data) - - def createGameElt(self, to_jid, type_="normal"): - """Create a generic domish Element for the game""" - type_ = "normal" if to_jid.resource else "groupchat" - elt = domish.Element((None, 'message')) - elt["to"] = to_jid.full() - elt["type"] = type_ - elt.addElement(self.ns_tag) - return elt - - def createStartElement(self, players=None, name="started"): - """Create a game "started" domish Element - @param name: element name (default: "started"). - """ - started_elt = domish.Element((None, name)) - if players is None: - return started_elt - idx = 0 - for player in players: - player_elt = domish.Element((None, 'player')) - player_elt.addContent(player) - player_elt['index'] = str(idx) - idx += 1 - started_elt.addChild(player_elt) - return started_elt - - def send(self, to_jid, elem=None, attrs=None, content=None, profile=None): - """ - @param to_jid: recipient JID - @param elem: domish.Element, unicode or a couple: - - domish.Element to be directly added as a child to the message - - unicode name or couple (uri, name) to create a new domish.Element - and add it as a child to the message (see domish.Element.addElement) - @param attrs: dictionary of attributes for the new child - @param content: unicode that is appended to the child content - @param profile: the profile from which the message is sent - """ - if profile is None: - error(_("Message can not be sent without a sender profile")) - return - msg = self.createGameElt(to_jid) - if elem is not None: - if isinstance(elem, domish.Element): - msg.firstChildElement().addChild(elem) - else: - elem = msg.firstChildElement().addElement(elem) - if attrs is not None: - elem.attributes.update(attrs) - if content is not None: - elem.addContent(content) - self.host.profiles[profile].xmlstream.send(msg) - - if debugFile: - # From here you will see all the game messages - file_ = open("/tmp/test", "a") - file_.write("%s from %s to %s: %s\n" % (self.name, profile, "room" if to_jid.resource is None else to_jid.resource, elem.toXml())) - file_.close() - - def getHandler(self, profile): - return RoomGameHandler(self) - - -class RoomGameHandler (XMPPHandler): - implements(iwokkel.IDisco) - - def __init__(self, plugin_parent): - self.plugin_parent = plugin_parent - self.host = plugin_parent.host - - def connectionInitialized(self): - self.xmlstream.addObserver(self.plugin_parent.request, self.plugin_parent.room_game_cmd, profile=self.parent.profile) - - def getDiscoInfo(self, requestor, target, nodeIdentifier=''): - return [disco.DiscoFeature(self.plugin_parent.ns_tag[0])] - - def getDiscoItems(self, requestor, target, nodeIdentifier=''): - return []