libervia-backend: src/plugins/plugin_misc_room

comparison src/plugins/plugin_misc_room_game.py @ 828:8f335c03eebb

plugins room_games, radiocol, libervia: small changes like refactorization to ease the maintenance

author	souliane <souliane@mailoo.org>
date	Fri, 17 Jan 2014 15:02:46 +0100
parents	e3f4d80f987d
children	f3513c8cc2e6

comparison

equal deleted inserted replaced

-:215a2cb15e2d
+:8f335c03eebb
 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
+# this has been added for testing purpose. It is sometimes needed to remove a dependence
+# while building the synchronization data, for example to replace a call to time.time()
+# by an arbitrary value. If needed, this attribute would be set to True from the testcase.
+self.testing = False
 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,
+The game will not be created if one already exists in the room,
-and its creation could be postponed until all the expected players
+also 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]
 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)
+self._updatePlayers(room_jid_s, nicks, True, 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)
+self._updatePlayers(room_jid_s, nicks, False, 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.
 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):
+def _updatePlayers(self, room_jid_s, nicks, sync, profile):
 """Update the list of players and signal to the room that some players joined the game.
+If sync is True, the news players are synchronized with the game data they have missed.
 Remark: self.games[room_jid_s]['players'] should not be modified outside this method.
 @param room_jid_s: room userhost
 @param nicks: list of players nicks in the room (referee included, in first position)
+@param sync: set to True to send synchronization data to the new players
+@param profile
 """
 if nicks == []:
 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
+sync = sync and self._gameExists(room_jid_s, True) and len(self.games[room_jid_s]['players']) > 0
 setStatus('desync' if sync else 'init')
 self.games[room_jid_s]['players'].extend(new_nicks)
 self._synchronizeRoom(room_jid_s, [JID(room_jid_s)], profile)
 if sync:
 setStatus('init')
 else:
 element = self._createStartElement(self.games[room_jid_s]['players'], name="players")
 elements = [(element, None, None)]
 sync_args = []
-sync_data = self.getSyncData(room_jid_s)
+sync_data = self._getSyncData(room_jid_s)
 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]:
 for recipient in recipients:
 self._sendElements(recipient, elements, profile=profile)
 for args, kwargs in sync_args:
 self._sendElements(*args, **kwargs)
-def getSyncData(self, room_jid_s, force_nicks=[]):
+def _getSyncData(self, room_jid_s, force_nicks=[]):
+"""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 elements to
+be sent by self._synchronizeRoom for the game to be synchronized.
+"""
+if not self._gameExists(room_jid_s):
+return {}
+data = {}
+status = self.games[room_jid_s]['status']
+nicks = [nick for nick in status if status[nick] == 'desync']
+for nick in force_nicks:
+if nick not in nicks:
+nicks.append(nick)
+for nick in nicks:
+elements = self.getSyncDataForPlayer(room_jid_s, nick)
+if elements:
+data[nick] = elements
+return data
+def getSyncDataForPlayer(self, room_jid_s, nick):
 """This method may (and should probably) be overwritten by a child class.
-The synchronization data are returned for each player who has the state
+@param room_jid_s: room userhost
-'desync' or if he's been contained by force_nicks.
+@param nick: the nick of the player to be synchronized
-@param room_jid_s: room userhost
+@return: a list of elements to synchronize this player with the game.
-@param force_nicks: force the synchronization for this list of the nicks
+"""
-@return: a mapping between player nicks and a list of child elements
+return []
-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
 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)
+self._updatePlayers(room_jid_s, [user.nick], True, 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}
 if self.isPlayer(room_jid_s, user.nick):
 try:
 self.games[room_jid_s]['players'].remove(user.nick)
 except ValueError:
 pass
+if len(self.games[room_jid_s]['players']) == 0:
+del self.games[room_jid_s]  # finish the game
+return True
 if self.wait_mode == self.FOR_ALL:
 # allow this user to join the game again
 user_jid_s = user.entity.userhost()
 if len(self.invitations[room_jid_s]) == 0:
 self.invitations[room_jid_s].append((time(), [user_jid_s]))
 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)))
+self._updatePlayers(room_jid_s, nicks, True, profile)
-self._updatePlayers(room_jid_s, nicks, profile)
 return
 self.games[room_jid_s]['started'] = True
-self._updatePlayers(room_jid_s, nicks, profile)
+self._updatePlayers(room_jid_s, nicks, False, profile)
 if self.player_init:
 # specific data to each player (score, private data)
 self.games[room_jid_s].setdefault('players_data', {})
 for nick in nicks:
 # The dict must be COPIED otherwise it is shared between all users

Mercurial > libervia-backend

comparison src/plugins/plugin_misc_room_game.py @ 828:8f335c03eebb