Mercurial > libervia-backend
comparison sat/plugins/plugin_misc_quiz.py @ 2624:56f94936df1e
code style reformatting using black
author | Goffi <goffi@goffi.org> |
---|---|
date | Wed, 27 Jun 2018 20:14:46 +0200 |
parents | 26edcf3a30eb |
children | 003b8b4b56a7 |
comparison
equal
deleted
inserted
replaced
2623:49533de4540b | 2624:56f94936df1e |
---|---|
18 # along with this program. If not, see <http://www.gnu.org/licenses/>. | 18 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
19 | 19 |
20 from sat.core.i18n import _ | 20 from sat.core.i18n import _ |
21 from sat.core.constants import Const as C | 21 from sat.core.constants import Const as C |
22 from sat.core.log import getLogger | 22 from sat.core.log import getLogger |
23 | |
23 log = getLogger(__name__) | 24 log = getLogger(__name__) |
24 from twisted.words.xish import domish | 25 from twisted.words.xish import domish |
25 from twisted.internet import reactor | 26 from twisted.internet import reactor |
26 from twisted.words.protocols.jabber import client as jabber_client, jid | 27 from twisted.words.protocols.jabber import client as jabber_client, jid |
27 from time import time | 28 from time import time |
28 | 29 |
29 | 30 |
30 NS_QG = 'http://www.goffi.org/protocol/quiz' | 31 NS_QG = "http://www.goffi.org/protocol/quiz" |
31 QG_TAG = 'quiz' | 32 QG_TAG = "quiz" |
32 | 33 |
33 PLUGIN_INFO = { | 34 PLUGIN_INFO = { |
34 C.PI_NAME: "Quiz game plugin", | 35 C.PI_NAME: "Quiz game plugin", |
35 C.PI_IMPORT_NAME: "Quiz", | 36 C.PI_IMPORT_NAME: "Quiz", |
36 C.PI_TYPE: "Game", | 37 C.PI_TYPE: "Game", |
37 C.PI_PROTOCOLS: [], | 38 C.PI_PROTOCOLS: [], |
38 C.PI_DEPENDENCIES: ["XEP-0045", "XEP-0249", "ROOM-GAME"], | 39 C.PI_DEPENDENCIES: ["XEP-0045", "XEP-0249", "ROOM-GAME"], |
39 C.PI_MAIN: "Quiz", | 40 C.PI_MAIN: "Quiz", |
40 C.PI_HANDLER: "yes", | 41 C.PI_HANDLER: "yes", |
41 C.PI_DESCRIPTION: _("""Implementation of Quiz game""") | 42 C.PI_DESCRIPTION: _("""Implementation of Quiz game"""), |
42 } | 43 } |
43 | 44 |
44 | 45 |
45 class Quiz(object): | 46 class Quiz(object): |
46 | |
47 def inheritFromRoomGame(self, host): | 47 def inheritFromRoomGame(self, host): |
48 global RoomGame | 48 global RoomGame |
49 RoomGame = host.plugins["ROOM-GAME"].__class__ | 49 RoomGame = host.plugins["ROOM-GAME"].__class__ |
50 self.__class__ = type(self.__class__.__name__, (self.__class__, RoomGame, object), {}) | 50 self.__class__ = type( |
51 self.__class__.__name__, (self.__class__, RoomGame, object), {} | |
52 ) | |
51 | 53 |
52 def __init__(self, host): | 54 def __init__(self, host): |
53 log.info(_("Plugin Quiz initialization")) | 55 log.info(_("Plugin Quiz initialization")) |
54 self.inheritFromRoomGame(host) | 56 self.inheritFromRoomGame(host) |
55 RoomGame._init_(self, host, PLUGIN_INFO, (NS_QG, QG_TAG), game_init={'stage': None}, player_init={'score': 0}) | 57 RoomGame._init_( |
56 host.bridge.addMethod("quizGameLaunch", ".plugin", in_sign='asss', out_sign='', method=self._prepareRoom) # args: players, room_jid, profile | 58 self, |
57 host.bridge.addMethod("quizGameCreate", ".plugin", in_sign='sass', out_sign='', method=self._createGame) # args: room_jid, players, profile | 59 host, |
58 host.bridge.addMethod("quizGameReady", ".plugin", in_sign='sss', out_sign='', method=self._playerReady) # args: player, referee, profile | 60 PLUGIN_INFO, |
59 host.bridge.addMethod("quizGameAnswer", ".plugin", in_sign='ssss', out_sign='', method=self.playerAnswer) | 61 (NS_QG, QG_TAG), |
60 host.bridge.addSignal("quizGameStarted", ".plugin", signature='ssass') # args: room_jid, referee, players, profile | 62 game_init={"stage": None}, |
61 host.bridge.addSignal("quizGameNew", ".plugin", | 63 player_init={"score": 0}, |
62 signature='sa{ss}s', | 64 ) |
63 doc={'summary': 'Start a new game', | 65 host.bridge.addMethod( |
64 'param_0': "room_jid: jid of game's room", | 66 "quizGameLaunch", |
65 'param_1': "game_data: data of the game", | 67 ".plugin", |
66 'param_2': '%(doc_profile)s'}) | 68 in_sign="asss", |
67 host.bridge.addSignal("quizGameQuestion", ".plugin", | 69 out_sign="", |
68 signature='sssis', | 70 method=self._prepareRoom, |
69 doc={'summary': "Send the current question", | 71 ) # args: players, room_jid, profile |
70 'param_0': "room_jid: jid of game's room", | 72 host.bridge.addMethod( |
71 'param_1': "question_id: question id", | 73 "quizGameCreate", |
72 'param_2': "question: question to ask", | 74 ".plugin", |
73 'param_3': "timer: timer", | 75 in_sign="sass", |
74 'param_4': '%(doc_profile)s'}) | 76 out_sign="", |
75 host.bridge.addSignal("quizGamePlayerBuzzed", ".plugin", | 77 method=self._createGame, |
76 signature='ssbs', | 78 ) # args: room_jid, players, profile |
77 doc={'summary': "A player just pressed the buzzer", | 79 host.bridge.addMethod( |
78 'param_0': "room_jid: jid of game's room", | 80 "quizGameReady", |
79 'param_1': "player: player who pushed the buzzer", | 81 ".plugin", |
80 'param_2': "pause: should the game be paused ?", | 82 in_sign="sss", |
81 'param_3': '%(doc_profile)s'}) | 83 out_sign="", |
82 host.bridge.addSignal("quizGamePlayerSays", ".plugin", | 84 method=self._playerReady, |
83 signature='sssis', | 85 ) # args: player, referee, profile |
84 doc={'summary': "A player just pressed the buzzer", | 86 host.bridge.addMethod( |
85 'param_0': "room_jid: jid of game's room", | 87 "quizGameAnswer", |
86 'param_1': "player: player who pushed the buzzer", | 88 ".plugin", |
87 'param_2': "text: what the player say", | 89 in_sign="ssss", |
88 'param_3': "delay: how long, in seconds, the text must appear", | 90 out_sign="", |
89 'param_4': '%(doc_profile)s'}) | 91 method=self.playerAnswer, |
90 host.bridge.addSignal("quizGameAnswerResult", ".plugin", | 92 ) |
91 signature='ssba{si}s', | 93 host.bridge.addSignal( |
92 doc={'summary': "Result of the just given answer", | 94 "quizGameStarted", ".plugin", signature="ssass" |
93 'param_0': "room_jid: jid of game's room", | 95 ) # args: room_jid, referee, players, profile |
94 'param_1': "player: player who gave the answer", | 96 host.bridge.addSignal( |
95 'param_2': "good_answer: True if the answer is right", | 97 "quizGameNew", |
96 'param_3': "score: dict of score with player as key", | 98 ".plugin", |
97 'param_4': '%(doc_profile)s'}) | 99 signature="sa{ss}s", |
98 host.bridge.addSignal("quizGameTimerExpired", ".plugin", | 100 doc={ |
99 signature='ss', | 101 "summary": "Start a new game", |
100 doc={'summary': "Nobody answered the question in time", | 102 "param_0": "room_jid: jid of game's room", |
101 'param_0': "room_jid: jid of game's room", | 103 "param_1": "game_data: data of the game", |
102 'param_1': '%(doc_profile)s'}) | 104 "param_2": "%(doc_profile)s", |
103 host.bridge.addSignal("quizGameTimerRestarted", ".plugin", | 105 }, |
104 signature='sis', | 106 ) |
105 doc={'summary': "Nobody answered the question in time", | 107 host.bridge.addSignal( |
106 'param_0': "room_jid: jid of game's room", | 108 "quizGameQuestion", |
107 'param_1': "time_left: time left before timer expiration", | 109 ".plugin", |
108 'param_2': '%(doc_profile)s'}) | 110 signature="sssis", |
111 doc={ | |
112 "summary": "Send the current question", | |
113 "param_0": "room_jid: jid of game's room", | |
114 "param_1": "question_id: question id", | |
115 "param_2": "question: question to ask", | |
116 "param_3": "timer: timer", | |
117 "param_4": "%(doc_profile)s", | |
118 }, | |
119 ) | |
120 host.bridge.addSignal( | |
121 "quizGamePlayerBuzzed", | |
122 ".plugin", | |
123 signature="ssbs", | |
124 doc={ | |
125 "summary": "A player just pressed the buzzer", | |
126 "param_0": "room_jid: jid of game's room", | |
127 "param_1": "player: player who pushed the buzzer", | |
128 "param_2": "pause: should the game be paused ?", | |
129 "param_3": "%(doc_profile)s", | |
130 }, | |
131 ) | |
132 host.bridge.addSignal( | |
133 "quizGamePlayerSays", | |
134 ".plugin", | |
135 signature="sssis", | |
136 doc={ | |
137 "summary": "A player just pressed the buzzer", | |
138 "param_0": "room_jid: jid of game's room", | |
139 "param_1": "player: player who pushed the buzzer", | |
140 "param_2": "text: what the player say", | |
141 "param_3": "delay: how long, in seconds, the text must appear", | |
142 "param_4": "%(doc_profile)s", | |
143 }, | |
144 ) | |
145 host.bridge.addSignal( | |
146 "quizGameAnswerResult", | |
147 ".plugin", | |
148 signature="ssba{si}s", | |
149 doc={ | |
150 "summary": "Result of the just given answer", | |
151 "param_0": "room_jid: jid of game's room", | |
152 "param_1": "player: player who gave the answer", | |
153 "param_2": "good_answer: True if the answer is right", | |
154 "param_3": "score: dict of score with player as key", | |
155 "param_4": "%(doc_profile)s", | |
156 }, | |
157 ) | |
158 host.bridge.addSignal( | |
159 "quizGameTimerExpired", | |
160 ".plugin", | |
161 signature="ss", | |
162 doc={ | |
163 "summary": "Nobody answered the question in time", | |
164 "param_0": "room_jid: jid of game's room", | |
165 "param_1": "%(doc_profile)s", | |
166 }, | |
167 ) | |
168 host.bridge.addSignal( | |
169 "quizGameTimerRestarted", | |
170 ".plugin", | |
171 signature="sis", | |
172 doc={ | |
173 "summary": "Nobody answered the question in time", | |
174 "param_0": "room_jid: jid of game's room", | |
175 "param_1": "time_left: time left before timer expiration", | |
176 "param_2": "%(doc_profile)s", | |
177 }, | |
178 ) | |
109 | 179 |
110 def __game_data_to_xml(self, game_data): | 180 def __game_data_to_xml(self, game_data): |
111 """Convert a game data dict to domish element""" | 181 """Convert a game data dict to domish element""" |
112 game_data_elt = domish.Element((None, 'game_data')) | 182 game_data_elt = domish.Element((None, "game_data")) |
113 for data in game_data: | 183 for data in game_data: |
114 data_elt = domish.Element((None, data)) | 184 data_elt = domish.Element((None, data)) |
115 data_elt.addContent(game_data[data]) | 185 data_elt.addContent(game_data[data]) |
116 game_data_elt.addChild(data_elt) | 186 game_data_elt.addChild(data_elt) |
117 return game_data_elt | 187 return game_data_elt |
127 """Parse answer result element and return a tuple of signal arguments | 197 """Parse answer result element and return a tuple of signal arguments |
128 @param answer_result_elt: answer result element | 198 @param answer_result_elt: answer result element |
129 @return: (player, good_answer, score)""" | 199 @return: (player, good_answer, score)""" |
130 score = {} | 200 score = {} |
131 for score_elt in answer_result_elt.elements(): | 201 for score_elt in answer_result_elt.elements(): |
132 score[score_elt['player']] = int(score_elt['score']) | 202 score[score_elt["player"]] = int(score_elt["score"]) |
133 return (answer_result_elt['player'], answer_result_elt['good_answer'] == str(True), score) | 203 return ( |
204 answer_result_elt["player"], | |
205 answer_result_elt["good_answer"] == str(True), | |
206 score, | |
207 ) | |
134 | 208 |
135 def __answer_result(self, player_answering, good_answer, game_data): | 209 def __answer_result(self, player_answering, good_answer, game_data): |
136 """Convert a domish an answer_result element | 210 """Convert a domish an answer_result element |
137 @param player_answering: player who gave the answer | 211 @param player_answering: player who gave the answer |
138 @param good_answer: True is the answer is right | 212 @param good_answer: True is the answer is right |
139 @param game_data: data of the game""" | 213 @param game_data: data of the game""" |
140 players_data = game_data['players_data'] | 214 players_data = game_data["players_data"] |
141 score = {} | 215 score = {} |
142 for player in game_data['players']: | 216 for player in game_data["players"]: |
143 score[player] = players_data[player]['score'] | 217 score[player] = players_data[player]["score"] |
144 | 218 |
145 answer_result_elt = domish.Element((None, 'answer_result')) | 219 answer_result_elt = domish.Element((None, "answer_result")) |
146 answer_result_elt['player'] = player_answering | 220 answer_result_elt["player"] = player_answering |
147 answer_result_elt['good_answer'] = str(good_answer) | 221 answer_result_elt["good_answer"] = str(good_answer) |
148 | 222 |
149 for player in score: | 223 for player in score: |
150 score_elt = domish.Element((None, "score")) | 224 score_elt = domish.Element((None, "score")) |
151 score_elt['player'] = player | 225 score_elt["player"] = player |
152 score_elt['score'] = str(score[player]) | 226 score_elt["score"] = str(score[player]) |
153 answer_result_elt.addChild(score_elt) | 227 answer_result_elt.addChild(score_elt) |
154 | 228 |
155 return answer_result_elt | 229 return answer_result_elt |
156 | 230 |
157 def __ask_question(self, question_id, question, timer): | 231 def __ask_question(self, question_id, question, timer): |
158 """Create a element for asking a question""" | 232 """Create a element for asking a question""" |
159 question_elt = domish.Element((None, 'question')) | 233 question_elt = domish.Element((None, "question")) |
160 question_elt['id'] = question_id | 234 question_elt["id"] = question_id |
161 question_elt['timer'] = str(timer) | 235 question_elt["timer"] = str(timer) |
162 question_elt.addContent(question) | 236 question_elt.addContent(question) |
163 return question_elt | 237 return question_elt |
164 | 238 |
165 def __start_play(self, room_jid, game_data, profile): | 239 def __start_play(self, room_jid, game_data, profile): |
166 """Start the game (tell to the first player after dealer to play""" | 240 """Start the game (tell to the first player after dealer to play""" |
167 client = self.host.getClient(profile) | 241 client = self.host.getClient(profile) |
168 game_data['stage'] = "play" | 242 game_data["stage"] = "play" |
169 next_player_idx = game_data['current_player'] = (game_data['init_player'] + 1) % len(game_data['players']) # the player after the dealer start | 243 next_player_idx = game_data["current_player"] = ( |
170 game_data['first_player'] = next_player = game_data['players'][next_player_idx] | 244 game_data["init_player"] + 1 |
245 ) % len( | |
246 game_data["players"] | |
247 ) # the player after the dealer start | |
248 game_data["first_player"] = next_player = game_data["players"][next_player_idx] | |
171 to_jid = jid.JID(room_jid.userhost() + "/" + next_player) | 249 to_jid = jid.JID(room_jid.userhost() + "/" + next_player) |
172 mess = self.createGameElt(to_jid) | 250 mess = self.createGameElt(to_jid) |
173 mess.firstChildElement().addElement('your_turn') | 251 mess.firstChildElement().addElement("your_turn") |
174 client.send(mess) | 252 client.send(mess) |
175 | 253 |
176 def playerAnswer(self, player, referee, answer, profile_key=C.PROF_KEY_NONE): | 254 def playerAnswer(self, player, referee, answer, profile_key=C.PROF_KEY_NONE): |
177 """Called when a player give an answer""" | 255 """Called when a player give an answer""" |
178 client = self.host.getClient(profile_key) | 256 client = self.host.getClient(profile_key) |
179 log.debug(u'new player answer (%(profile)s): %(answer)s' % {'profile': client.profile, 'answer': answer}) | 257 log.debug( |
258 u"new player answer (%(profile)s): %(answer)s" | |
259 % {"profile": client.profile, "answer": answer} | |
260 ) | |
180 mess = self.createGameElt(jid.JID(referee)) | 261 mess = self.createGameElt(jid.JID(referee)) |
181 answer_elt = mess.firstChildElement().addElement('player_answer') | 262 answer_elt = mess.firstChildElement().addElement("player_answer") |
182 answer_elt['player'] = player | 263 answer_elt["player"] = player |
183 answer_elt.addContent(answer) | 264 answer_elt.addContent(answer) |
184 client.send(mess) | 265 client.send(mess) |
185 | 266 |
186 def timerExpired(self, room_jid, profile): | 267 def timerExpired(self, room_jid, profile): |
187 """Called when nobody answered the question in time""" | 268 """Called when nobody answered the question in time""" |
188 client = self.host.getClient(profile) | 269 client = self.host.getClient(profile) |
189 game_data = self.games[room_jid] | 270 game_data = self.games[room_jid] |
190 game_data['stage'] = 'expired' | 271 game_data["stage"] = "expired" |
191 mess = self.createGameElt(room_jid) | 272 mess = self.createGameElt(room_jid) |
192 mess.firstChildElement().addElement('timer_expired') | 273 mess.firstChildElement().addElement("timer_expired") |
193 client.send(mess) | 274 client.send(mess) |
194 reactor.callLater(4, self.askQuestion, room_jid, client.profile) | 275 reactor.callLater(4, self.askQuestion, room_jid, client.profile) |
195 | 276 |
196 def pauseTimer(self, room_jid): | 277 def pauseTimer(self, room_jid): |
197 """Stop the timer and save the time left""" | 278 """Stop the timer and save the time left""" |
198 game_data = self.games[room_jid] | 279 game_data = self.games[room_jid] |
199 left = max(0, game_data["timer"].getTime() - time()) | 280 left = max(0, game_data["timer"].getTime() - time()) |
200 game_data['timer'].cancel() | 281 game_data["timer"].cancel() |
201 game_data['time_left'] = int(left) | 282 game_data["time_left"] = int(left) |
202 game_data['previous_stage'] = game_data['stage'] | 283 game_data["previous_stage"] = game_data["stage"] |
203 game_data['stage'] = "paused" | 284 game_data["stage"] = "paused" |
204 | 285 |
205 def restartTimer(self, room_jid, profile): | 286 def restartTimer(self, room_jid, profile): |
206 """Restart a timer with the saved time""" | 287 """Restart a timer with the saved time""" |
207 client = self.host.getClient(profile) | 288 client = self.host.getClient(profile) |
208 game_data = self.games[room_jid] | 289 game_data = self.games[room_jid] |
209 assert game_data['time_left'] is not None | 290 assert game_data["time_left"] is not None |
210 mess = self.createGameElt(room_jid) | 291 mess = self.createGameElt(room_jid) |
211 mess.firstChildElement().addElement('timer_restarted') | 292 mess.firstChildElement().addElement("timer_restarted") |
212 jabber_client.restarted_elt["time_left"] = str(game_data['time_left']) | 293 jabber_client.restarted_elt["time_left"] = str(game_data["time_left"]) |
213 client.send(mess) | 294 client.send(mess) |
214 game_data["timer"] = reactor.callLater(game_data['time_left'], self.timerExpired, room_jid, profile) | 295 game_data["timer"] = reactor.callLater( |
296 game_data["time_left"], self.timerExpired, room_jid, profile | |
297 ) | |
215 game_data["time_left"] = None | 298 game_data["time_left"] = None |
216 game_data['stage'] = game_data['previous_stage'] | 299 game_data["stage"] = game_data["previous_stage"] |
217 del game_data['previous_stage'] | 300 del game_data["previous_stage"] |
218 | 301 |
219 def askQuestion(self, room_jid, profile): | 302 def askQuestion(self, room_jid, profile): |
220 """Ask a new question""" | 303 """Ask a new question""" |
221 client = self.host.getClient(profile) | 304 client = self.host.getClient(profile) |
222 game_data = self.games[room_jid] | 305 game_data = self.games[room_jid] |
223 game_data['stage'] = "question" | 306 game_data["stage"] = "question" |
224 game_data['question_id'] = "1" | 307 game_data["question_id"] = "1" |
225 timer = 30 | 308 timer = 30 |
226 mess = self.createGameElt(room_jid) | 309 mess = self.createGameElt(room_jid) |
227 mess.firstChildElement().addChild(self.__ask_question(game_data['question_id'], u"Quel est l'âge du capitaine ?", timer)) | 310 mess.firstChildElement().addChild( |
228 client.send(mess) | 311 self.__ask_question( |
229 game_data["timer"] = reactor.callLater(timer, self.timerExpired, room_jid, profile) | 312 game_data["question_id"], u"Quel est l'âge du capitaine ?", timer |
313 ) | |
314 ) | |
315 client.send(mess) | |
316 game_data["timer"] = reactor.callLater( | |
317 timer, self.timerExpired, room_jid, profile | |
318 ) | |
230 game_data["time_left"] = None | 319 game_data["time_left"] = None |
231 | 320 |
232 def checkAnswer(self, room_jid, player, answer, profile): | 321 def checkAnswer(self, room_jid, player, answer, profile): |
233 """Check if the answer given is right""" | 322 """Check if the answer given is right""" |
234 client = self.host.getClient(profile) | 323 client = self.host.getClient(profile) |
235 game_data = self.games[room_jid] | 324 game_data = self.games[room_jid] |
236 players_data = game_data['players_data'] | 325 players_data = game_data["players_data"] |
237 good_answer = game_data['question_id'] == "1" and answer == "42" | 326 good_answer = game_data["question_id"] == "1" and answer == "42" |
238 players_data[player]['score'] += 1 if good_answer else -1 | 327 players_data[player]["score"] += 1 if good_answer else -1 |
239 players_data[player]['score'] = min(9, max(0, players_data[player]['score'])) | 328 players_data[player]["score"] = min(9, max(0, players_data[player]["score"])) |
240 | 329 |
241 mess = self.createGameElt(room_jid) | 330 mess = self.createGameElt(room_jid) |
242 mess.firstChildElement().addChild(self.__answer_result(player, good_answer, game_data)) | 331 mess.firstChildElement().addChild( |
332 self.__answer_result(player, good_answer, game_data) | |
333 ) | |
243 client.send(mess) | 334 client.send(mess) |
244 | 335 |
245 if good_answer: | 336 if good_answer: |
246 reactor.callLater(4, self.askQuestion, room_jid, profile) | 337 reactor.callLater(4, self.askQuestion, room_jid, profile) |
247 else: | 338 else: |
248 reactor.callLater(4, self.restartTimer, room_jid, profile) | 339 reactor.callLater(4, self.restartTimer, room_jid, profile) |
249 | 340 |
250 def newGame(self, room_jid, profile): | 341 def newGame(self, room_jid, profile): |
251 """Launch a new round""" | 342 """Launch a new round""" |
252 common_data = {'game_score': 0} | 343 common_data = {"game_score": 0} |
253 new_game_data = {"instructions": _(u"""Bienvenue dans cette partie rapide de quizz, le premier à atteindre le score de 9 remporte le jeu | 344 new_game_data = { |
254 | 345 "instructions": _( |
255 Attention, tu es prêt ?""")} | 346 u"""Bienvenue dans cette partie rapide de quizz, le premier à atteindre le score de 9 remporte le jeu |
347 | |
348 Attention, tu es prêt ?""" | |
349 ) | |
350 } | |
256 msg_elts = self.__game_data_to_xml(new_game_data) | 351 msg_elts = self.__game_data_to_xml(new_game_data) |
257 RoomGame.newRound(self, room_jid, (common_data, msg_elts), profile) | 352 RoomGame.newRound(self, room_jid, (common_data, msg_elts), profile) |
258 reactor.callLater(10, self.askQuestion, room_jid, profile) | 353 reactor.callLater(10, self.askQuestion, room_jid, profile) |
259 | 354 |
260 def room_game_cmd(self, mess_elt, profile): | 355 def room_game_cmd(self, mess_elt, profile): |
261 client = self.host.getClient(profile) | 356 client = self.host.getClient(profile) |
262 from_jid = jid.JID(mess_elt['from']) | 357 from_jid = jid.JID(mess_elt["from"]) |
263 room_jid = jid.JID(from_jid.userhost()) | 358 room_jid = jid.JID(from_jid.userhost()) |
264 game_elt = mess_elt.firstChildElement() | 359 game_elt = mess_elt.firstChildElement() |
265 game_data = self.games[room_jid] | 360 game_data = self.games[room_jid] |
266 # if 'players_data' in game_data: | 361 # if 'players_data' in game_data: |
267 # players_data = game_data['players_data'] | 362 # players_data = game_data['players_data'] |
268 | 363 |
269 for elt in game_elt.elements(): | 364 for elt in game_elt.elements(): |
270 | 365 |
271 if elt.name == 'started': # new game created | 366 if elt.name == "started": # new game created |
272 players = [] | 367 players = [] |
273 for player in elt.elements(): | 368 for player in elt.elements(): |
274 players.append(unicode(player)) | 369 players.append(unicode(player)) |
275 self.host.bridge.quizGameStarted(room_jid.userhost(), from_jid.full(), players, profile) | 370 self.host.bridge.quizGameStarted( |
276 | 371 room_jid.userhost(), from_jid.full(), players, profile |
277 elif elt.name == 'player_ready': # ready to play | 372 ) |
278 player = elt['player'] | 373 |
279 status = self.games[room_jid]['status'] | 374 elif elt.name == "player_ready": # ready to play |
280 nb_players = len(self.games[room_jid]['players']) | 375 player = elt["player"] |
281 status[player] = 'ready' | 376 status = self.games[room_jid]["status"] |
282 log.debug(_(u'Player %(player)s is ready to start [status: %(status)s]') % {'player': player, 'status': status}) | 377 nb_players = len(self.games[room_jid]["players"]) |
283 if status.values().count('ready') == nb_players: # everybody is ready, we can start the game | 378 status[player] = "ready" |
379 log.debug( | |
380 _(u"Player %(player)s is ready to start [status: %(status)s]") | |
381 % {"player": player, "status": status} | |
382 ) | |
383 if ( | |
384 status.values().count("ready") == nb_players | |
385 ): # everybody is ready, we can start the game | |
284 self.newGame(room_jid, profile) | 386 self.newGame(room_jid, profile) |
285 | 387 |
286 elif elt.name == 'game_data': | 388 elif elt.name == "game_data": |
287 self.host.bridge.quizGameNew(room_jid.userhost(), self.__xml_to_game_data(elt), profile) | 389 self.host.bridge.quizGameNew( |
288 | 390 room_jid.userhost(), self.__xml_to_game_data(elt), profile |
289 elif elt.name == 'question': # A question is asked | 391 ) |
290 self.host.bridge.quizGameQuestion(room_jid.userhost(), elt["id"], unicode(elt), int(elt["timer"]), profile) | 392 |
291 | 393 elif elt.name == "question": # A question is asked |
292 elif elt.name == 'player_answer': | 394 self.host.bridge.quizGameQuestion( |
293 player = elt['player'] | 395 room_jid.userhost(), |
294 pause = game_data['stage'] == 'question' # we pause the game only if we are have a question at the moment | 396 elt["id"], |
397 unicode(elt), | |
398 int(elt["timer"]), | |
399 profile, | |
400 ) | |
401 | |
402 elif elt.name == "player_answer": | |
403 player = elt["player"] | |
404 pause = ( | |
405 game_data["stage"] == "question" | |
406 ) # we pause the game only if we are have a question at the moment | |
295 # we first send a buzzer message | 407 # we first send a buzzer message |
296 mess = self.createGameElt(room_jid) | 408 mess = self.createGameElt(room_jid) |
297 buzzer_elt = mess.firstChildElement().addElement('player_buzzed') | 409 buzzer_elt = mess.firstChildElement().addElement("player_buzzed") |
298 buzzer_elt['player'] = player | 410 buzzer_elt["player"] = player |
299 buzzer_elt['pause'] = str(pause) | 411 buzzer_elt["pause"] = str(pause) |
300 client.send(mess) | 412 client.send(mess) |
301 if pause: | 413 if pause: |
302 self.pauseTimer(room_jid) | 414 self.pauseTimer(room_jid) |
303 # and we send the player answer | 415 # and we send the player answer |
304 mess = self.createGameElt(room_jid) | 416 mess = self.createGameElt(room_jid) |
305 _answer = unicode(elt) | 417 _answer = unicode(elt) |
306 say_elt = mess.firstChildElement().addElement('player_says') | 418 say_elt = mess.firstChildElement().addElement("player_says") |
307 say_elt['player'] = player | 419 say_elt["player"] = player |
308 say_elt.addContent(_answer) | 420 say_elt.addContent(_answer) |
309 say_elt['delay'] = "3" | 421 say_elt["delay"] = "3" |
310 reactor.callLater(2, client.send, mess) | 422 reactor.callLater(2, client.send, mess) |
311 reactor.callLater(6, self.checkAnswer, room_jid, player, _answer, profile=profile) | 423 reactor.callLater( |
312 | 424 6, self.checkAnswer, room_jid, player, _answer, profile=profile |
313 elif elt.name == 'player_buzzed': | 425 ) |
314 self.host.bridge.quizGamePlayerBuzzed(room_jid.userhost(), elt["player"], elt['pause'] == str(True), profile) | 426 |
315 | 427 elif elt.name == "player_buzzed": |
316 elif elt.name == 'player_says': | 428 self.host.bridge.quizGamePlayerBuzzed( |
317 self.host.bridge.quizGamePlayerSays(room_jid.userhost(), elt["player"], unicode(elt), int(elt["delay"]), profile) | 429 room_jid.userhost(), elt["player"], elt["pause"] == str(True), profile |
318 | 430 ) |
319 elif elt.name == 'answer_result': | 431 |
432 elif elt.name == "player_says": | |
433 self.host.bridge.quizGamePlayerSays( | |
434 room_jid.userhost(), | |
435 elt["player"], | |
436 unicode(elt), | |
437 int(elt["delay"]), | |
438 profile, | |
439 ) | |
440 | |
441 elif elt.name == "answer_result": | |
320 player, good_answer, score = self.__answer_result_to_signal_args(elt) | 442 player, good_answer, score = self.__answer_result_to_signal_args(elt) |
321 self.host.bridge.quizGameAnswerResult(room_jid.userhost(), player, good_answer, score, profile) | 443 self.host.bridge.quizGameAnswerResult( |
322 | 444 room_jid.userhost(), player, good_answer, score, profile |
323 elif elt.name == 'timer_expired': | 445 ) |
446 | |
447 elif elt.name == "timer_expired": | |
324 self.host.bridge.quizGameTimerExpired(room_jid.userhost(), profile) | 448 self.host.bridge.quizGameTimerExpired(room_jid.userhost(), profile) |
325 | 449 |
326 elif elt.name == 'timer_restarted': | 450 elif elt.name == "timer_restarted": |
327 self.host.bridge.quizGameTimerRestarted(room_jid.userhost(), int(elt['time_left']), profile) | 451 self.host.bridge.quizGameTimerRestarted( |
452 room_jid.userhost(), int(elt["time_left"]), profile | |
453 ) | |
328 | 454 |
329 else: | 455 else: |
330 log.error(_(u'Unmanaged game element: %s') % elt.name) | 456 log.error(_(u"Unmanaged game element: %s") % elt.name) |