erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

plugin tools: turn src/plugin/games.py into a plugin and move it to src/plugins/plugin_misc_room_game.py

Browse source
This commit is contained in:
souliane 2013-11-21 18:23:08 +01:00
commit 674a3e958d
4 changed files with 49 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files

13
src/plugins/plugin_misc_quiz.py
View file

@ -28,7 +28,6 @@ import random
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 @@ PLUGIN_INFO = {
"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

13
src/plugins/plugin_misc_radiocol.py
View file

@ -25,7 +25,6 @@ from twisted.words.protocols.jabber import jid
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 @@ PLUGIN_INFO = {
"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 @@ PLUGIN_INFO = {
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)

520
src/plugins/plugin_misc_room_game.py Normal file
View file

@ -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 []

13
src/plugins/plugin_misc_tarot.py
View file

@ -24,7 +24,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
import random
@ -37,18 +36,24 @@ PLUGIN_INFO = {
"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')]