def SaveIn(self, message, client):
if (os.path.exists(message.Save + ".json")):
mess = model.Message(id='0',
win='0',
quit=True,
Number=0,
idCl='1',
Load="No2").marshal()
client.sendall(mess)
return False
try:
with open("JSONF.json") as file:
file_content = file.read().strip()
if file_content: # если нет
username = json.loads(file_content)
else:
mess = model.Message(id='0',
win='0',
quit=True,
Number=0,
idCl='1',
Load="No2").marshal()
client.sendall(mess)
return False
except FileNotFoundError:
return None
except json.JSONDecodeError:
return None
with open(message.Save + ".json", "w") as write_file:
json.dump(username, write_file, indent=4)
def __init__(self, argv):
self.clients = set()
self.listen_thread = None
self.port = None
self.sock = None
self.parse_args(argv)
self.leader = client.Client()
self.gamer = client.Client()
self.game = 0
self.message = model.Message()
self.server_message = model.Message()
self.server_message.username = messages.SERVER
self.counter = 0
self.stop = False
def handle(self, client):
while True:
try:
message = model.Message(**json.loads(self.receive(client)))
except (ConnectionAbortedError, ConnectionResetError):
print(CONNECTION_ABORTED)
return
if message.quit:
client.close()
self.clients.remove(client)
return
if SHUTDOWN_MESSAGE.lower() == message.message.lower():
self.exit()
return
self.check(message)
if self.first_client.name == message.username:
self.first_client.last_message = message.message
else:
self.second_client.last_message = message.message
print(str(self.timetable))
print(str(self.first_client.name))
print(str(self.first_client.last_message))
print(str(self.second_client.name))
print(str(self.second_client.last_message))
self.broadcast(message)
self.count += 1
if self.count == 2:
self.decide()
if self.day != 5:
self.start_new_day()
else:
self.finish()
def post(self):
name = self.request.get('name', '')
comment = self.request.get('comment', '')
try:
message = model.Message(name=name, comment=comment)
message.put()
counter = model.Counter.get_by_key_name('message')
if counter is None:
counter = model.Counter(key_name='message')
counter.value = counter.value + 1
counter.put()
if memcache.get('total_msgs'):
memcache.incr('total_msgs')
else:
total_msgs = counter.value
memcache.set('total_msgs', total_msgs)
total_pages = counter.value / MSGS_PER_PAGE
if counter.value % MSGS_PER_PAGE:
total_pages += 1
if memcache.get('msgs_%d' % total_pages):
memcache.delete('msgs_%d' % total_pages)
self.redirect('/')
except BadValueError:
self.response.out.write('You have not filled the name or comment field. <a href="/">Back »</a>')
def all(self):
messages = []
for id_, data in self._db.items():
m = model.Message(data['name'], data['message'])
m.id = id_
messages.append(messages)
return messages
def __init__(self, **kwargs):
self.game = 0
self.counter = 0
self.leader = client.Client()
self.gamer = client.Client()
self.message = model.Message()
self.__dict__.update(kwargs)
def handle(self, client):
while True:
try:
message = model.Message(**json.loads(self.receive(client)))
except (ConnectionAbortedError, ConnectionResetError):
print(CONNECTION_ABORTED)
return
if message.quit:
client.close()
self.clients.remove(client)
return
print(str(message))
if SHUTDOWN_MESSAGE.lower() == message.message.lower():
self.exit()
return
if message.username == messages.USERNAME_ROCKET:
self.handle_rocket_msg(message)
elif message.username == messages.USERNAME_GROUND:
if self.ground_client is None:
self.ground_client = client
self.timer_thread = threading.Thread(
target=self.timer_update_param)
self.timer_thread.start()
else:
time.sleep(parametr.MESSAGE_DELAY_SEC)
self.broadcast(message)
def execute(self):
# Initialize GUI
if not self.ui.show():
return
# Initialize the socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to the server
while True:
try:
self.sock.connect((socket.gethostname(), server.PORT))
break
except (socket.error, OverflowError):
pass
# Receive information about the game state from the server (e. g. the username)
try:
message = model.Message(**json.loads(self.receive_all()))
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(ERROR, CONNECTION_ERROR)
return
self.username = message.username
self.operations = message.operations
self.ui.set_operations(self.operations)
self.ui.gui.title(message.username)
self.receive_worker = threading.Thread(target=self.receive)
self.receive_worker.start()
self.ui.loop()
def skt_recv(connection):
"""
return a Message object
"""
msg = _skt_recv_msg(connection)
t = msg[0]
p = None
sp = None
py = None
ap = None
idx = 1
if t == REQUEST or t == CANCEL or t == PAYLOAD:
p = int.from_bytes(msg[idx:idx + 4], ENDIAN)
sp = int.from_bytes(msg[idx + 4:idx + 8], ENDIAN)
idx = idx + 8
if t == PAYLOAD:
# Actually is msg[idx:], to save memory use a costant
# since the purpose of this project is to distribute
# content, thus receiving it in memory is good enough,
# no need to actually write it to file system.
py = 'PAYLOAD'
if t == ANNOUNCE:
ap_len = int.from_bytes(msg[idx:idx + 4], ENDIAN)
idx = idx + 4
ap = []
for i in range(ap_len):
ap.append(int.from_bytes(msg[idx:idx + 4], ENDIAN))
idx = idx + 4
if t == PEERID:
p = int.from_bytes(msg[idx:idx + 4], ENDIAN)
return model.Message(t, p, sp, py, ap)
def receive(self):
while True:
try:
message = model.Message(**json.loads(self.receive_all()))
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
return
if message.message.find("Now {} lead".format(self.username)) == 0:
self.ui.show_send_button()
self.ui.show_message(message)
else:
if message.message.isdigit():
if not self.last_reciever == self.username:
self.ui.show_send_button()
if self.last_message.isdigit():
self.ui.show_timer(message)
else:
self.ui.disable_send_button()
self.ui.show_message(message)
if not message.username == messages.SERVER:
self.last_reciever = message.username
self.last_message = message.message
def get_message_to_send(self):
message = self.r_ui.message.get()
if len(message) == 0:
return
self.r_ui.message.set("")
return model.Message(username=self.username,
message=message,
quit=False)
def __init__(self):
self.clients = set()
self.listen_thread = None
self.port = 8081
self.sock = None
self.message = model.Message()
self.message.username = "******"
self.game = game_object.Game_obj()
def exit(self):
self.closing = True
try:
self.sock.sendall(model.Message(username=self.username, message="", quit=True).marshal())
except (ConnectionResetError, ConnectionAbortedError, OSError):
print(messages.CONNECTION_ERROR)
finally:
self.sock.close()
def post(self):
name = self.request.get("name")
message_text = self.request.get("message_text")
email = self.request.get("email")
message = model.Message(message_text=message_text,
name=name,
email=email)
message.put()
return self.redirect_to("startseite")
def get_speed_to_send(self):
speed = self.r_ui.get_speed()
if all([speed[param] == 0 for param in parametr.XYR]):
return
return model.Message(username=self.username,
rocket_speed=speed,
message="",
quit=False)
def receive(self):
while True:
try:
message = model.Message(**json.loads(self.receive_all()))
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
return
self.ui.show_speed_or_message(message)
def exit(self, S):
self.closing = True
try:
self.sock.sendall(
model.Message(quit=True, Number=0, idCl=S).marshal())
except (ConnectionResetError, ConnectionAbortedError, OSError):
print("Could not connect to server")
finally:
self.sock.close()
def msg(data):
data.__setitem__('time',
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
print(json.dumps(data))
db.add(
model.Message(content=json.dumps(data),
createdTime=datetime.datetime.now(),
channel=users[request.sid]))
db.commit()
emit('msg', data, room=users[request.sid])
def handle(self, client):
while True:
if self.game.count == 0:
self.broadcast(self.game)
try:
data = self.receive(client)
if (data.find('count') == -1):
message = model.Message(**json.loads(data))
else:
old_name_1 = self.game.first_client.name
old_name_2 = self.game.second_client.name
self.game = game_object.Game_obj(**json.loads(data))
self.game.first_client = client_model.Client(
**self.game.first_client)
self.game.second_client = client_model.Client(
**self.game.second_client)
self.game.first_client.name = old_name_1
self.game.second_client.name = old_name_2
self.message.message = "Game has been loaded It`s day " + str(
self.game.day)
self.broadcast(self.message)
continue
except (ConnectionAbortedError, ConnectionResetError):
print(CONNECTION_ABORTED)
return
if message.quit:
client.close()
self.clients.remove(client)
return
if SHUTDOWN_MESSAGE.lower() == message.message.lower():
self.exit()
return
self.check(message)
if self.game.first_client.name == message.username:
self.game.first_client.last_message = message.message
else:
self.game.second_client.last_message = message.message
self.broadcast(message)
self.game.count += 1
if self.game.count == 2:
self.decide()
print(self.game.first_client.points)
print(self.game.second_client.points)
if self.game.day != 5:
self.start_new_day()
else:
self.finish()
def timer_update_param(self):
while True:
self.timer_tic += 1
self.update_speed_and_pos()
self.end_of_game = self.is_win()
if not self.end_of_game:
if self.timer_tic >= parametr.SEND_EVERY_N_TIMER_TIC:
self.timer_tic = 0
message = model.Message(username=messages.USERNAME_SERVER,
rocket_pos=self.rocket_pos,
rocket_speed=self.speed,
Lagrange_pos=self.L1)
self.ground_client.sendall(message.marshal())
time.sleep(parametr.TIME_TO_UPDATE_SPEED_ML / 1000)
else:
message = model.Message(username="******",
message="YOU WON",
quit=False)
self.broadcast(message)
break
def listen(self):
self.obn()
self.sock.listen(2)
while True:
try:
client, address = self.sock.accept()
self.N = self.N + 1
if (self.N == 1):
mess = model.Message(quit=True, Number="-2").marshal()
client.sendall(mess)
if (self.N == 2):
mess = model.Message(quit=True, Number="-1").marshal()
client.sendall(mess)
print(self.N)
except OSError:
print("Connection aborted")
return
print(CONNECTED_PATTERN.format(*address))
self.clients.add(client)
threading.Thread(target=self.handle, args=(client, )).start()
def end_game_for_this_client(self):
"""
Метод, который вызывается при нажатии кнопки end у клиента
"""
message = model.Message(username_last_player=self.username, quit=True)
self.ui.add_number_button['state'] = 'disabled'
self.ui.end_game_button['state'] = 'disabled'
try:
self.sock.sendall(message.marshal())
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
def __init__(self):
self.clients = set()
self.listen_thread = None
self.port = 8080
self.sock = None
self.day = 1
self.timetable = self.rand()
self.count = 0
self.message = model.Message()
self.message.username = "******"
self.first_client = client.Client()
self.second_client = client.Client()
def send(self, event=None):
message = self.ui.message.get()
if len(message) == 0:
return
message = model.Message(username=self.username,
message=message,
quit=False)
try:
self.client.sock.sendall(message.marshal())
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
def handle(self, client):
while True:
try:
mess = json.loads(self.receive(client))
message = model.Message(**mess)
except (ConnectionAbortedError, ConnectionResetError):
print("Connection aborted")
return
if (message.Save != None):
self.SaveIn(message, client)
elif (message.Load != None):
self.LoadS(message, client)
elif (message.Number == '-'):
self.obn()
for client2 in self.clients:
if (client == client2):
mess = model.Message(quit=True, Number="-1").marshal()
client2.sendall(mess)
else:
mess = model.Message(quit=True, Number="-2").marshal()
client2.sendall(mess)
else:
if message.quit:
self.obn()
client.close()
self.clients.remove(client)
print("The client disconnected")
t = 0
for client2 in self.clients:
mess = model.Message(quit=True, Number="-2").marshal()
client2.sendall(mess)
t = 1
if (t == 1):
self.N = 1
else:
self.N = 0
return
self.Save(mess)
self.broadcast(message, client)
def receive(self):
# Receive and handle messages from the server
while True:
try:
message = model.Message(**json.loads(self.receive_all()))
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(ERROR, CONNECTION_ERROR)
return
if message.can_move:
self.can_move = True
print(self.can_move)
self.ui.show_message(message)
def exit(self):
"""
Метод, который вызывался изначально, чтобы отключить текущего клиента от чата
"""
self.closing = True
try:
self.sock.sendall(
model.Message(username=self.username, message="",
quit=True).marshal())
except (ConnectionResetError, ConnectionAbortedError, OSError):
print(messages.CONNECTION_ERROR)
finally:
self.sock.close()
def send(self, message):
if len(message) == 0:
return
message = model.Message(id=message[0],
win=message[1],
quit=False,
Number=message[2],
idCl=message[3])
try:
self.sock.sendall(message.marshal())
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
print("Error")
def first_hello_message(self):
"""
Клиент пишет серверу пустое сообщение, только лишь с именем данного клиента,
Чтобы сервер оповеслил всех остальных о новом игроке.
Сервер делает рассылку с новым score, с учетом нового игрока
"""
message = model.Message(username_last_player=self.username)
try:
self.sock.sendall(
message.marshal()) # шлем сообщение через сокет серверу
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
def receive(self):
"""
Метод, в котором с помощью receive_all мы получаем объект класса message, внутри которого лежат нужные
нам данные. В конце метода вызывается метод show_message(message), определенный внутри класса UI
"""
while True:
try:
message = model.Message(**json.loads(self.receive_all()))
except (ConnectionAbortedError, ConnectionResetError):
if not self.closing:
self.ui.alert(messages.ERROR, messages.CONNECTION_ERROR)
return
self.ui.show_message(message)
