libervia-backend: src/plugins/plugin_misc_room

comparison src/plugins/plugin_misc_room_game.py @ 825:e3f4d80f987d

plugins room_games, radiocol: better synchronization after a user joins a running game

author	souliane <souliane@mailoo.org>
date	Wed, 15 Jan 2014 23:01:23 +0100
parents	1fe00f0c9a91
children	8f335c03eebb

comparison

equal deleted inserted replaced

-:c304ce32042b
+:e3f4d80f987d
 """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] = {'referee': referee, 'players': [], 'started': False, 'status': {}}
 self.games[room_jid_s].update(copy.deepcopy(self.game_init))
 self.invitations.setdefault(room_jid_s, [])
 def _gameExists(self, room_jid_s, started=False):
 """Return True if a game has been initialized/started.
 return
 # this is better than set(nicks).difference(...) as it keeps the order
 new_nicks = [nick for nick in nicks if nick not in self.games[room_jid_s]['players']]
 if len(new_nicks) == 0:
 return
+sync = self._gameExists(room_jid_s, True) and len(self.games[room_jid_s]['players']) > 0
+def setStatus(status):
+for nick in new_nicks:
+self.games[room_jid_s]['status'][nick] = status
+setStatus('desync' if sync else 'init')
 self.games[room_jid_s]['players'].extend(new_nicks)
-self._signalPlayers(room_jid_s, [JID(room_jid_s)], profile)
+self._synchronizeRoom(room_jid_s, [JID(room_jid_s)], profile)
+if sync:
-def _signalPlayers(self, room_jid_s, recipients, profile):
+setStatus('init')
-"""Let these guys know that we are playing (they may not play themselves).
+def _synchronizeRoom(self, room_jid_s, recipients, profile):
+"""Communicate the list of players to the whole room or only to some users,
+also send the synchronization data to the players who recently joined the game.
 @param room_jid_s: room userhost
 @recipients: list of JIDs, the recipients of the message could be:
 - room JID
 - room JID + "/" + user nick
+@param profile
 """
 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")
 elements = [(element, None, None)]
-for child in self.getSyncData(room_jid_s):
-# TODO: sync data may be different and private to each player,
+sync_args = []
-# in that case send a separate message to the new players
+sync_data = self.getSyncData(room_jid_s)
-elements.append((child, None, None))
+for nick in sync_data:
+user_jid = JID(room_jid_s + '/' + nick)
+if user_jid in recipients:
+user_elements = copy.deepcopy(elements)
+for child in sync_data[nick]:
+user_elements.append((child, None, None))
+recipients.remove(user_jid)
+else:
+user_elements = [(child, None, None) for child in sync_data[nick]]
+sync_args.append(([user_jid, user_elements], {'profile': profile}))
 for recipient in recipients:
 self._sendElements(recipient, elements, profile=profile)
+for args, kwargs in sync_args:
-def getSyncData(self, room_jid_s):
+self._sendElements(*args, **kwargs)
-"""This method may be overwritten by any child class.
-@return: a list of child elements to be added for the game to be synchronized.
+def getSyncData(self, room_jid_s, force_nicks=[]):
-"""
+"""This method may (and should probably) be overwritten by a child class.
-return []
+The synchronization data are returned for each player who has the state
+'desync' or if he's been contained by force_nicks.
+@param room_jid_s: room userhost
+@param force_nicks: force the synchronization for this list of the nicks
+@return: a mapping between player nicks and a list of child elements
+to be sent by self._synchronizeRoom for the game to be synchronized.
+"""
+return {}
 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
 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, user.entity.userhost() if user.entity else None, 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)
+self._synchronizeRoom(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:
 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 == {}:
+if self.player_init:
-return
+# specific data to each player (score, private data)
-# specific data to each player
+self.games[room_jid_s].setdefault('players_data', {})
-status = {}
+for nick in nicks:
-players_data = {}
+# The dict must be COPIED otherwise it is shared between all users
-for nick in nicks:
+self.games[room_jid_s]['players_data'][nick] = copy.deepcopy(self.player_init)
-# The dict must be COPIED otherwise it is shared between all users
-players_data[nick] = copy.deepcopy(self.player_init)
-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
 @param player: the player nick in the room
 @param referee: referee userhost
 elem.attributes.update(attrs)
 if content is not None:
 elem.addContent(content)
 self.host.profiles[profile].xmlstream.send(msg)
 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

Mercurial > libervia-backend

comparison src/plugins/plugin_misc_room_game.py @ 825:e3f4d80f987d