def gif(message, param): api_instance = giphy_client.DefaultApi() try: api_key = config.bot['giphy']['api_key'] rating = config.bot['giphy']['rating'] lang = config.bot['giphy']['lang'] except: common.send_message('Failed to get giphy configurationn') q = param limit = 1 offset = 0 fmt = 'json' try: # Search Endpoint api_response = api_instance.gifs_search_get( api_key, q, limit=limit, offset=offset, rating=rating, lang=lang, fmt=fmt, ) pprint(api_response.data) common.send_message('*' + q + '*', api_response.data[0].images.original.url) except(ApiException, e): print('Exception when calling DefaultApi->gifs_search_get: %s\n' \ % e)
def magic8ball(message, param): answers = [ "π It is certain", "π It is decidedly so", "π Without a doubt", "π Yes definitely", "π You may rely on it", "π As I see it yes", "π€ Most likely", "βΊοΈ Outlook good", "π Yes", "βοΈ Signs point to yes", "π Reply hazy try again", "π Ask again later", "π Better not tell you now", "π Cannot predict now", "π Concentrate and ask again", "π Don't count on it", "π‘ My reply is no", "π My sources say no", "π Outlook not so good", "π₯ Very doubtful" ] common.send_message("π± *Magic 8 ball says*:\n" + answers[random.randint(0, len(answers))-1])
def kick_out(self): '''Kick out player ''' if self.opponent is None: return msg = clientlib.make_req_kick_out(self.client_name, self.opponent) send_message(self.channel, msg, self.key_game, self.client_queue)
def get_history(self, conn_id, queues): result = dict() for q in queues: if q in ThreadedTCPServer.HISTORY: result[q] = list(ThreadedTCPServer.HISTORY[q]) send_message(self.request, conn_id, dict(response=result))
def main(): killer = gracefulkiller.GracefulKiller() # setup config.bot = config.read() try: config.rocket = rocketapi.create_session(config.bot['server_info']['username'], config.bot['server_info']['password'], server_url = config.bot['server_info']['server']) except: sys.exit("failed to connect to rocketchat server!") # startup message common.send_message("I am up and running!") # start listening loop bot_running = True lastchecked = None while bot_running: time.sleep(0.100) lastchecked = read_messages(channel = config.bot['bot_config']['channel'], lastId=lastchecked) if killer.kill_now: break common.send_message("I'm shutting down NOW!")
def broadcast(self, queue, message): for conn_id, d in TCPRequestHandler.connections.items(): if conn_id == message['coremq_sender'] and queue != conn_id and d['options'].get('echo', False) is False: continue if queue in d['subscriptions']: send_message(d['handler'].request, queue, message)
def get_history(self, conn_id, queues): result = dict() for q in queues: if q in ThreadedTCPServer.HISTORY: result[q] = list(ThreadedTCPServer.HISTORY[q]) send_message(self.request, conn_id, dict(response=result))
def broadcast(self, queue, message): for conn_id, d in TCPRequestHandler.connections.items(): if conn_id == message['coremq_sender'] and queue != conn_id and d[ 'options'].get('echo', False) is False: continue if queue in d['subscriptions']: send_message(d['handler'].request, queue, message)
def add_feedback(self, user_chat_id=-1, text=None): if len(self.feedback) == 0: f_n = 0 else: f_n = self.feedback[-1].self_num + 1 self.feedback.append(Feedback(user_chat_id, text, f_n)) self.write_feedback() common.send_message(text="FEEDBACK", inline_keyboard=-1)
def get_feed(url): rss = feedparser.parse(url) send_message(rss['feed']['title'].encode('utf8')) rank = 1 for entry in rss['entries']: title = entry['title'].encode('utf8') message = '%d: %s' % (rank, title) send_message(message) rank = rank + 1
def get_games_list(self): '''Send requests to server to get list of all game sessions. ''' routing_key = common.make_key_games(self.server_name) # Sending request to get list of opened games msg = clientlib.make_req_list_opened() send_message(self.channel, msg, routing_key, self.client_queue) # Sending request to get list of closed games msg = clientlib.make_req_list_closed() send_message(self.channel, msg, routing_key, self.client_queue)
def start_game(self): '''Check if all players are ready and start the game. ''' if self.players.issubset(self.players_ready) and\ self.client_name in self.players_ready: # Send start game request to server msg = clientlib.make_req_start_game(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) else: tkMessageBox.showinfo('Game', 'Not all players are ready')
def keep_alive(loop: Value): url = 'https://huey-bot.herokuapp.com/keep_alive' last_time = time.time() while loop.value: if time.time() - last_time > 10: res = requests.post(url=url) # print('ping') last_time = time.time() send_message("I'm still alive")
def change_turn(self): '''Change turn to next player and send event. ''' next_index = self.player_order.index(self.on_turn) + 1 if next_index >= len(self.player_order): next_index = 0 self.on_turn = self.player_order[next_index] # Send on turn event msg = serverlib.make_e_on_turn(self.on_turn) send_message(self.channel, msg, self.key_events)
def spectate_game(self): '''Send spectate game request to server. ''' if self.listbox_closed.curselection() == (): return game_name = self.listbox_closed.get(self.listbox_closed.curselection()) # Sending request to spectate game msg = clientlib.make_req_spectate_game(game_name, self.client_name) routing_key = common.make_key_games(self.server_name) send_message(self.channel, msg, routing_key, self.client_queue)
def get_seed(self): message = self.__create_message(MessageTypes.GET_SEED, '') try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.server_ip, self.server_port)) common.send_message(sock, message.serialize()) received_message = common.recv_message(sock) logging.debug('received_message = {0}'.format(received_message)) except: logging.error(sys.exc_info()) finally: sock.close()
def remove_game(self, name): '''Remove game from the dict of games. @param name: name of game ''' try: del self.games[name] # Send event about removed game msg = serverlib.make_e_game_end(name) send_message(self.channel, msg, common.make_key_game_advert(self.server_name)) except KeyError: pass
def main(): with open('config.yml') as f: config = yaml.safe_load(f) remote_name = config['remote_name'] server_port = config['server_port'] user_name = config['user_name'] soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sender = (remote_name, server_port) soc.connect(sender) msg = common.recv_message(soc) my_addr = msg.params['client_address'] print(my_addr) # register msg = AppMessageFactory.register(user_name) common.send_message(soc, msg) msg = common.recv_message(soc) while True: cmd = input('input command:').strip().split(' ') if cmd[0] == 'game': if cmd[1] == 'create': gamename = cmd[2] msg = AppMessageFactory.create_game(gamename) common.send_message(soc, msg) msg = common.recv_message(soc) elif cmd[1] == 'list': msg = AppMessageFactory.get_game_list() common.send_message(soc, msg) msg = common.recv_message(soc) for g in msg.params['games']: print(g) elif cmd[1] == 'join': game_name = cmd[2] msg = AppMessageFactory.join_game(game_name) common.send_message(soc, msg) msg = common.recv_message(soc) print(msg) elif cmd[0] == 'close': msg = AppMessageFactory.close() common.send_message(soc, msg) msg = common.recv_message(soc) break soc.close()
def dota_game_service(last_game_state: LastGameState): while True: if time.time() - last_game_state.last_query_time >= 10.: # TODO: REMOVE THIS print('time to check') if last_game_state.match_id > 0: try: # Refresh the player's match data on OpenDota.com refresh_response = requests.post(url=PLAYER_REFRESH_URL) # Get the latest match data match_id = requests.get(url=PLAYER_MATCHES_URL, params={ 'limit': 1 }).json()[0]['match_id'] if match_id != last_game_state.match_id: match_data = requests.get(url=MATCHES_URL + str(match_id)).json() # Update the last game state with the new game's information update_last_game_state(last_game_state, match_data) # Post to the group chat send_message( generate_game_notification(last_game_state)) else: last_game_state.last_query_time = time.time() except: pass else: # Get the latest match data match_id = requests.get(url=PLAYER_MATCHES_URL, params={ 'limit': 1 }).json()[0]['match_id'] print(f'Last match id: {match_id}') # Get the latest match data match_data = requests.get(url=MATCHES_URL + str(match_id)).json() # Give the last game state its data update_last_game_state(last_game_state, match_data)
def connect_server(self): '''Send connection request to server selected in the listbox. ''' if self.listbox.curselection() == (): return server_name = self.listbox.get(self.listbox.curselection()) client_name = self.username_entry.get() if client_name.strip() == '': tkMessageBox.showinfo('Username', 'Please enter username') return # Sending connect request msg = clientlib.make_req_connect(client_name) routing_key = common.make_key_server(server_name) send_message(self.channel, msg, routing_key, self.client_queue)
def get_ready(self): '''Confirm the ship positioning to the server. ''' if self.client_name in self.players_ready: return elif self.ships_remaining != 0: tkMessageBox.showinfo('Game', 'Ships remaining: %s' % self.ships_remaining) else: # Send request to server ships = self.fields[self.client_name].get_all_items('ship') msg = clientlib.make_req_set_ready(self.client_name, ships) send_message(self.channel, msg, self.key_game, self.client_queue) # Color the button self.button_ready.config(bg='#68c45c', activebackground='#68c45c')
def create_game(self): '''Send game creation request to server. ''' game_name = self.gamename_entry.get() if game_name.strip() == '': tkMessageBox.showinfo('Name', 'Please enter name of the game') return width = self.width_entry.get() height = self.height_entry.get() # Sending request to create game msg = clientlib.make_req_create_game(game_name, self.client_name, width, height) routing_key = common.make_key_games(self.server_name) send_message(self.channel, msg, routing_key, self.client_queue)
def webhook(): app.logger.debug('Got a message!') # Comfortable amount of time to not cause a graphical glitch in GroupMe time.sleep(1) data = request.get_json() if data['name'] != 'Huey': if oi_huey(data): send_message(generate_excuse()) elif question_about_last_game(data): send_message(generate_old_game_notification(get_last_match_data())) return "ok", 200
def weather(message, param): if not param: param = config.bot['weather']['default_location'] r = requests.get('http://wttr.in/' + param + '?1n') buienradar_url = \ 'https://api.buienradar.nl/image/1.0/RadarMapBE?w=500&h=512&time=' \ + str(int(time.time())) if r.text: # we get text in ANSI, escape it ansi_escape = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]') common.send_message('```\n' + ansi_escape.sub('', r.text) + '\n```', buienradar_url) return common.send_message('*Current weather in BE:*', buienradar_url)
def add_game(self, name, owner, width, height): '''Add game to the dict of games. @param name: name of game @param owner: owner of game @param width: width of field of game @param height: height of field of game ''' # Create game in new thread game = Game(self, self.server_args, name, owner, width, height) self.games[name] = game game.start() # Send event about added game msg = serverlib.make_e_game_open(name) send_message(self.channel, msg, common.make_key_game_advert(self.server_name)) return game
def changes_notify(): def gen_changes(class_id): changes = my_context.db.timetable.changes try: changes_cell = changes.changes[changes.ch_ind[class_id]] except BaseException as err: print(err) return err return "Π‘Π²Π΅ΠΆΠΈΠ΅ ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΡ Π΄Π»Ρ " + my_context.db.timetable.c_n[class_id] + " Π½Π° " + \ my_context.db.timetable.d_n[changes.change_day] + ":```\n" + \ '\n'.join(c_d for c_d in changes_cell.change_data) + \ "```\n\nΠΡΠ΅Π³Π΄Π° ΠΌΠΎΠΆΠ½ΠΎ ΠΎΡΠΊΠ°Π·Π°ΡΡΡΡ ΠΎΡ ΡΡΠΈΡ ΡΠ²Π΅Π΄ΠΎΠΌΠ»Π΅Π½ΠΈΠΉ Π² Π½Π°ΡΡΡΠΎΠΉΠΊΠ°Ρ " def gen_all_changes(): return "Π‘Π²Π΅ΠΆΠΈΠ΅ ΠΈΠ·ΠΌΠ΅Π½Π΅Π½ΠΈΡ Π½Π° " + my_context.db.timetable.d_n[my_context.db.timetable.changes.change_day] + \ " Π΄Π»Ρ Π²ΡΠ΅Ρ " + '\n\n'.join( my_context.db.timetable.c_n[changesCell.class_ind] + '\n'.join(c_d for c_d in changesCell.change_data) for changesCell in my_context.db.timetable.changes.changes) + \ "\nΠΡΠ΅Π³Π΄Π° ΠΌΠΎΠΆΠ½ΠΎ ΠΎΡΠΊΠ°Π·Π°ΡΡΡΡ ΠΎΡ ΡΡΠΈΡ ΡΠ²Π΅Π΄ΠΎΠΌΠ»Π΅Π½ΠΈΠΉ Π² Π½Π°ΡΡΡΠΎΠΉΠΊΠ°Ρ (Π΅ΡΠ»ΠΈ Ρ ΠΈΡ ΡΠ΄Π΅Π»Π°Π»)" is_ok = True for u_id in my_context.db.users: user = my_context.db.users[u_id] if (user.settings.type_name != Type.CLASS or my_context.db.timetable.changes.has_changes[ user.settings.type_id]) and user.settings.notify: if user.settings.type_name == Type.CLASS: text = gen_changes(user.settings.type_id) is_ok = is_ok and (text is not False) else: text = gen_all_changes() is_ok = is_ok and (text is not False) if text is not False: common.send_message(text=text, chat_id=user.user_id, inline_keyboard=-1, silent=True, markdown=True) return is_ok
def player_disconnected(self, player): '''Actions on player leaving or disconnecting from the game @param player: name of player ''' # Remove player's client queue try: del self.client_queues[player] except KeyError: pass # If noone is in the game if len(self.client_queues.keys()) == 0: # Quit game self.channel.stop_consuming() self.game_list.remove_game(self.name) # Else we might need to change the owner elif self.owner == player: new_owner = random.choice(self.client_queues.keys()) self.owner = new_owner # Send event that owner changed msg = serverlib.make_e_new_owner(new_owner) send_message(self.channel, msg, self.key_events)
def player_left(self, player): '''Actions on player leaving from the game @param player: name of player ''' try: self.players.remove(player) except KeyError: pass try: del self.fields[player] except KeyError: pass try: del self.player_hits[player] except KeyError: pass try: self.spectators.remove(player) except KeyError: pass # Send event that player left msg = serverlib.make_e_player_left(player) send_message(self.channel, msg, self.key_events)
def on_event(self, ch, method, properties, body): '''React on game event. @param ch: pika.BlockingChannel @param method: pika.spec.Basic.Deliver @param properties: pika.spec.BasicProperties @param body: str or unicode ''' LOG.debug('Received event: %s', body) msg_parts = body.split(common.SEP) # New player if msg_parts[0] == common.E_NEW_PLAYER: self.add_players(msg_parts[1:]) # Player left if msg_parts[0] == common.E_PLAYER_LEFT: self.remove_player(msg_parts[1]) # New owner if msg_parts[0] == common.E_NEW_OWNER: if msg_parts[1] == self.client_name: if not self.is_owner: self.become_owner() # Player ready if msg_parts[0] == common.E_PLAYER_READY: self.players_ready.add(msg_parts[1]) # Game starts if msg_parts[0] == common.E_GAME_STARTS: self.at_game_start(msg_parts[1]) # On turn if msg_parts[0] == common.E_ON_TURN: self.on_turn = msg_parts[1] self.turn_label.destroy() self.turn_label = Tkinter.Label(self.frame_player, text='Turn: %s' % self.on_turn) self.turn_label.grid(row=self.height + 2, columnspan=self.width) # Hit if msg_parts[0] == common.E_HIT: self.fields[msg_parts[2]].add_item(int(msg_parts[3]), int(msg_parts[4]), common.FIELD_HIT_SHIP) # Sink if msg_parts[0] == common.E_SINK: field = self.fields[msg_parts[1]] for sink_ship in msg_parts[2:]: sink_ship_pos = sink_ship.split(common.FIELD_SEP) field.add_item(int(sink_ship_pos[0]), int(sink_ship_pos[1]), common.FIELD_SINK_SHIP) self.update_buttons() # Player end if msg_parts[0] == common.E_PLAYER_END: if msg_parts[1] == self.client_name: if tkMessageBox.askyesno('Game', 'You lost! Leave game?'): self.leave() else: self.spectator = True msg = clientlib.make_req_get_spectator_queue( self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_all_fields(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) else: self.remove_player(msg_parts[1]) # Game end if msg_parts[0] == common.E_GAME_END: ships = self.fields[self.client_name].get_all_items( common.FIELD_SHIP) if ships != []: tkMessageBox.showinfo('Game', 'Congratulations, you won!') else: tkMessageBox.showinfo('Game', 'Game ended!') if self.is_owner: if tkMessageBox.askyesno('Game', 'Restart session?'): msg = clientlib.make_req_restart_session() send_message(self.channel, msg, self.key_game, self.client_queue) # Game restart if msg_parts[0] == common.E_GAME_RESTART: self.hide() self.show([ self.server_name, self.client_name, self.game_name, self.is_owner, self.spectator, self.spectator_queue ])
def button_pressed(self): '''Reaction on pressing the button. ''' if self.game_window.spectator: return LOG.debug('Pressed button on position: %s, %s', self.row, self.column) # If in positioning ships phase if self.game_window.client_name not in self.game_window.players_ready: if self.parent == 'opponent': return # Add ship if self.color == common.FIELD_WATER and\ self.game_window.ships_remaining != 0: self.change_color(common.FIELD_SHIP) self.game_window.ships_remaining -= 1 # Update ready_label self.game_window.ready_label.destroy() self.game_window.ready_label = Tkinter.Label( self.game_window.frame_player, text='Ships remaining: %s' %\ self.game_window.ships_remaining) self.game_window.ready_label.grid( row=self.game_window.height + 2, columnspan=self.game_window.width) # Update field self.game_window.fields[self.game_window.client_name].add_item( self.row, self.column, common.FIELD_SHIP) # Remove ship elif self.color == common.FIELD_SHIP: self.change_color(common.FIELD_WATER) self.game_window.ships_remaining += 1 # Update ready_label self.game_window.ready_label.destroy() self.game_window.ready_label = Tkinter.Label( self.game_window.frame_player, text='Ships remaining: %s' %\ self.game_window.ships_remaining) self.game_window.ready_label.grid( row=self.game_window.height + 2, columnspan=self.game_window.width) # Update field self.game_window.fields[ self.game_window.client_name].remove_item( self.row, self.column) # If game started and on turn if self.game_window.on_turn == self.game_window.client_name: if self.parent == 'player' or self.game_window.opponent is None: return # Dont allow shooting at known positions if self.color != 'unknown': return # Mark as shot and send request to server self.change_color('shot') msg = clientlib.make_req_shoot(self.game_window.client_name, self.game_window.opponent, self.row, self.column) send_message(self.game_window.channel, msg, self.game_window.key_game, self.game_window.client_queue)
def respond(self, conn_id, text): send_message(self.request, conn_id, dict(response=text))
#!/usr/bin/python # coding: utf-8 import sys import urllib2 import urllib from bs4 import BeautifulSoup from common import send_message send_message('Apple Dev Center System Status') try: response = urllib2.urlopen('https://developer.apple.com/support/system-status/') html = response.read() parsed_html = BeautifulSoup(html) result = parsed_html.body.find('table', attrs={'class':'status-table'}) for row in result.find_all('td'): message = '%s - %s' % (row.span.text, row['class'][0].title()) send_message(message) send_message('https://developer.apple.com/support/system-status/') except Exception, e: send_message('Error: %s' % str(sys.exc_info()))
# coding: utf-8 import sys import feedparser from common import send_message COUNTRIES = ['jp', 'us'] LIMIT = 10 URLS = ['https://itunes.apple.com/%s/rss/topfreeapplications/limit=%d/xml', 'https://itunes.apple.com/%s/rss/toppaidapplications/limit=%d/xml', 'https://itunes.apple.com/%s/rss/topgrossingapplications/limit=%d/xml'] def get_feed(url): rss = feedparser.parse(url) send_message(rss['feed']['title'].encode('utf8')) rank = 1 for entry in rss['entries']: title = entry['title'].encode('utf8') message = '%d: %s' % (rank, title) send_message(message) rank = rank + 1 for country in COUNTRIES: for url in URLS: try: url = url % (country, LIMIT) get_feed(url) except Exception, e: send_message('Error: %s' % str(sys.exc_info()))
def leave(self): '''Leave game session. ''' msg = clientlib.make_req_leave_game(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue)
def disconnect(self): '''Disconnect from server. ''' msg = clientlib.make_req_disconnect(self.client_name) send_message(self.channel, msg, self.key_server, self.client_queue) send_message(self.channel, msg, self.key_game, self.client_queue)
def on_show(self): '''Bind queues, set consuming and listen. ''' # Routing keys self.key_client = self.client_queue self.key_server = common.make_key_server(self.server_name) self.key_game = common.make_key_game(self.server_name, self.game_name) self.key_events = common.make_key_game_events(self.server_name, self.game_name) if self.spectator: self.key_spectate = self.spectator_queue # Binding queues self.channel.queue_bind(exchange='direct_logs', queue=self.client_queue, routing_key=self.client_queue) self.channel.queue_bind(exchange='direct_logs', queue=self.events_queue, routing_key=self.key_events) if self.spectator: self.channel.queue_bind(exchange='direct_logs', queue=self.events_queue, routing_key=self.key_spectate) # Set consuming self.channel.basic_consume(self.on_response, queue=self.client_queue, no_ack=True) self.channel.basic_consume(self.on_event, queue=self.events_queue, no_ack=True) # Listening self.listening_thread = listen(self.channel, 'game') # Remove old settings and get all information from server self.reset_setting() msg = clientlib.make_req_get_dimensions() send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_players() send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_players_ready() send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_owner() send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_turn() send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_field(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) msg = clientlib.make_req_get_spectator(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) self.wait_for_ready() # If game already started if self.on_turn is not None: self.at_game_start(self.on_turn) msg = clientlib.make_req_get_hits(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue) if self.spectator: msg = clientlib.make_req_get_all_fields(self.client_name) send_message(self.channel, msg, self.key_game, self.client_queue)
#!/usr/bin/python # coding: utf-8 from common import send_message send_message('test')
def process_request(self, msg_parts, properties): '''Process request about list of games. @param msg_parts: parsed message @param properties: pika.spec.BasicProperties @return String, response ''' # Get list of games request if msg_parts[0] == common.REQ_LIST_OPENED: game_names = [game.name for game in self.get_games('opened')] return serverlib.make_rsp_list_opened(game_names) if msg_parts[0] == common.REQ_LIST_CLOSED: game_names = [game.name for game in self.get_games('closed')] return serverlib.make_rsp_list_closed(game_names) # Create game request if msg_parts[0] == common.REQ_CREATE_GAME: if len(msg_parts) != 5 or msg_parts[1].strip() == '' or\ msg_parts[3].strip() == '' or msg_parts[4].strip() == '': return serverlib.make_rsp_invalid_request() game_name = msg_parts[1] client_name = msg_parts[2] width = msg_parts[3] height = msg_parts[4] if game_name in self.games: return serverlib.make_rsp_name_exists() if client_name not in self.clients.client_set: return serverlib.make_rsp_permission_denied() game = self.add_game(game_name, client_name, width, height) game.wait_for_ready() game.client_queues[client_name] = properties.reply_to return serverlib.make_rsp_game_entered(game_name, 1) # Join game request if msg_parts[0] == common.REQ_JOIN_GAME: if len(msg_parts) != 3: return serverlib.make_rsp_invalid_request() game_name = msg_parts[1] client_name = msg_parts[2] if game_name not in self.games: return serverlib.make_rsp_name_doesnt_exist() if client_name not in self.clients.client_set: return serverlib.make_rsp_permission_denied() if client_name not in self.games[game_name].players and\ self.games[game_name].state == 'closed': return serverlib.make_rsp_permission_denied() self.games[game_name].client_queues[client_name] =\ properties.reply_to if client_name not in self.games[game_name].players: self.games[game_name].players.add(client_name) # Send event that new player was added msg = serverlib.make_e_new_player(client_name) send_message(self.channel, msg, common.make_key_game_events(self.server_name, game_name)) return serverlib.make_rsp_game_entered(game_name, 0) # Spectating game request if msg_parts[0] == common.REQ_SPECTATE_GAME: if len(msg_parts) != 3: return serverlib.make_rsp_invalid_request() game_name = msg_parts[1] client_name = msg_parts[2] if game_name not in self.games: return serverlib.make_rsp_name_doesnt_exist() if client_name not in self.clients.client_set: return serverlib.make_rsp_permission_denied() if client_name in self.games[game_name].players: return serverlib.make_rsp_permission_denied() game = self.games[game_name] game.spectators.add(client_name) return serverlib.make_rsp_game_spectate(game_name, 0, game.spectator_queue)
def send_message(self): message = sys.stdin.readline()[:-1] envelope = self.ENVELOPE_FORMAT % (self.username, message) log.debug("Sending the envelope %r", envelope) send_message(self.socket, envelope)