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)
