def recv_message():
global flaga_rozlaczenia
global numer_sekwencyjny
while True:
if flaga_rozlaczenia == False:
while True:
recv_m1 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
if int(recv_m1["nr_sekwencyjny"])>1 and recv_m1["operacja"] != "DISCONNECT":
recv_m2 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
if int(recv_m2["nr_sekwencyjny"])>1:
recv_m3 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
print("[ " + str(recv_m3["id"]) + " ]> " + str(recv_m3["data"]))
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, client_ID).encode("utf-8") # Utworzenie pakietu ACK
client.sendto(pakiet_ack, dstHost) # ACK SEND
elif int(recv_m1["nr_sekwencyjny"])>1 and recv_m1["operacja"] == "DISCONNECT":
recv_m2 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, client_ID).encode("utf-8") # Utworzenie pakietu ACK
client.sendto(pakiet_ack, dstHost) # Wysłanie ACK na DISCONNCONNECTED
flaga_rozlaczenia = True
print("Partner sie rozlaczyl")
return 0
def send_invite_denied():
numer_sekwencyjny = 2
client.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "INVITE", numer_sekwencyjny, client_ID).encode('utf-8'), dstHost)
numer_sekwencyjny -= 1
client.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "DENY", numer_sekwencyjny, client_ID).encode(('utf-8')),dstHost)
received_message2 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))# ACK RECV
print("Wyslano odmowe")
def send_invite_denied(adres_surowy):
numer_sekwencyjny = 2
sock.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "INVITE", numer_sekwencyjny, 1).encode('utf-8'),adres_surowy)
numer_sekwencyjny = 1
sock.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "DENY", numer_sekwencyjny, 1).encode(('utf-8')),adres_surowy)
received_message2 = protocol.decode_message(sock.recvfrom(1024)[0].decode("utf-8"))# ACK
print("[SERWER] Wyslano odmowe")
def close_connection():
print("Proba rozlaczenia: disconnect")
numer_sekwencyjny = 2
client.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "DISCONNECT", numer_sekwencyjny, client_ID).encode('utf-8'), dstHost)
numer_sekwencyjny -= 1
client.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "REQUEST", numer_sekwencyjny, client_ID).encode('utf-8'), dstHost)
received_message1 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))# ACK RECV
print("Polaczenie rozwiazane!")
def wyslij_do_sesji(sock, adr_klienta, client_data):
sesja = tablica_klientow[adr_klienta].nr_sesji
for k in tablica_klientow:
if tablica_klientow[k].nr_sesji == sesja and tablica_klientow[k].id != tablica_klientow[adr_klienta].id:
numer_sekwencyjny = 3
sock.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "COMMUNICATE", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"),tablica_klientow[k].adres_surowy)
numer_sekwencyjny = 2
sock.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "SENT", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"),tablica_klientow[k].adres_surowy)
numer_sekwencyjny = 1
sock.sendto(client_data, tablica_klientow[k].adres_surowy)
received_ack = protocol.decode_message(sock.recvfrom(1024)[0].decode("utf-8"))# ACK
def czy_zaproszenie():
global flaga_otrzymania_invite
global flaga_wyslania_invite
global wiadomosc_temp
while True:
if flaga_wyslania_invite == True:
return 0
else:
try:
recv_data = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
print("Otrzymano INVITE od Klienta {}".format(recv_data["id"]))
client.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny , client_ID).encode("utf-8"), dstHost)
wiadomosc_temp = recv_data
flaga_otrzymania_invite = True
return 0
except:
continue
def run(tcp_ip, tcp_port, gui, ai=None):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("connecting to", tcp_ip)
sock.connect((tcp_ip, tcp_port))
running = True
inputs = [
sock,
]
# If no AI, this thread will manage keyboard inputs
# TODO : remove for a more advanced GUI
if ai is None:
inputs.append(sys.stdin)
data = b''
while running:
rds, wts, ers = select.select(inputs, [], [], 0)
for s in rds:
if s is sys.stdin:
# Managing keyboard input
cmd = s.readline()
send(sock, 'play', cmd.strip())
if s is sock:
d = s.recv(2048)
if d:
data += d
else:
print("lost connection")
running = False
# manage data
msg, remain = extract_msg(data)
if msg:
mtype, mval = decode_message(msg)
gui.process_message(mtype, mval)
# if an AI is attached, ask for a play
if ai is not None:
play = ai.process_message(mtype, mval)
if play is not None:
send(sock, 'play', play)
data = remain
sock.close()
def process_msg(self, client, msg):
if len(self.players) != 2:
send(client, 'info', "Waiting for opponent")
return
msg_type, msg = decode_message(msg)
if msg_type == 'play':
try:
self.game.play(self.players[client], msg)
p = player_name(self.players[client])
self.broadcast('info', "%s played %s" % (p, msg))
self.send_game()
except AwaleException as e:
send(client, 'error', str(e))
if self.game.over():
win_player = winner(self.game.game, self.game.scores)
if win_player is not None:
self.broadcast('info',
"%s wins !" % player_name(win_player))
else:
self.broadcast('info', "Draw !")
self.running = False
#print("wysylam SENT")
numer_sekwencyjny -= 1
client.sendto(protocol.encode_messsage_Dane(time.ctime(time.time()),numer_sekwencyjny, client_ID, message).encode(('utf-8')),dstHost)
#print("wysylam wiadomosc : {}".format(message))
#received_message2 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))# ACK
#print("wyslano wiadomosc")
#=========================================================
# Wysłanie sekwencji CONNECT>REQUEST>""
print("Zadanie polaczenia z serwerem")
numer_sekwencyjny = 2
client.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "CONNECT", numer_sekwencyjny, client_ID).encode('utf-8'), dstHost)
numer_sekwencyjny -=1
client.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "REQUEST", numer_sekwencyjny, client_ID).encode(('utf-8')),dstHost)
received_message = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8")) # Odebranie ACK po inicjacji
received_message1 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
received_message2 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
received_message3 = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
client_ID = received_message3["id"]
numer_sekwencyjny = 1
client.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, client_ID).encode("utf-8"),dstHost)
print("Poprawnie polaczono z serwerem")
print("Otrzymane id:{}".format(client_ID))
print("Oczekiwanie na drugiego klienta")
#========================================================================
while True:
received_message = protocol.decode_message(client.recvfrom(1024)[0].decode("utf-8"))
def client_connect():
global nsesji
global numer_sekwencyjny
global addr
adres_nadawcy =""
adres_odbiorcy=""
client_data, client_address = sock.recvfrom(1024) # Odebranie komunikatu
adr_klienta = adr_to_klucz(client_address[0], client_address[1]) # Klucz klienta ("IPv4:Port")
adres_nadawcy = adr_klienta
pakiet1 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie komunikatu
if pakiet1["operacja"] == "CONNECT": # Jezeli operacja = CONNECT
client_data, client_address = sock.recvfrom(1024) # Oczekiwanie na status REQUEST
pakiet2 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie pakietu
if pakiet2["status"] == "REQUEST": # Jezeli status == REQUEST
dodaj_klienta(adr_klienta, client_address) # Dodanie klienta do tablica_klientow
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet2["id"]).encode("utf-8")
sock.sendto(pakiet_ack, tablica_klientow[adr_klienta].adres_surowy)
numer_sekwencyjny = 3
sock.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "CONNECT", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"),tablica_klientow[adr_klienta].adres_surowy)
numer_sekwencyjny -= 1
sock.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "CONNECTED", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"), tablica_klientow[adr_klienta].adres_surowy)
numer_sekwencyjny -= 1
sock.sendto(protocol.encode_messsage_Dane(time.ctime(time.time()),numer_sekwencyjny,tablica_klientow[adr_klienta].id,"").encode("utf-8"),tablica_klientow[adr_klienta].adres_surowy)
client_data, client_address = sock.recvfrom(1024)
pakiet5 = protocol.decode_message(client_data.decode("utf-8"))
addr.append(adr_klienta)
print("Nowy klient!")
# Obsługa DISCONNECT
elif pakiet1["operacja"] == "DISCONNECT":
print("[SERWER] Otrzymano DISCONNECT")
client_data, client_address = sock.recvfrom(1024) # Oczekiwanie na status
pakiet2 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie pakietu
if pakiet2["status"] == "REQUEST":
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet1["id"]).encode("utf-8")# ACK dla DISCONNECT
sock.sendto(pakiet_ack, tablica_klientow[adr_klienta].adres_surowy) # Wyslanie ACK
# Koniec obslugi klienta ktory wywolal CLOSE
print("[SERWER] Koniec obslugi klienta ktory wywolal CLOSE")
#Przeslanie info o rozlaczeniu do drugiego klienta
for adres in addr:
if adres != adr_to_klucz(client_address[0],client_address[1]):
adres_odbiorcy = tablica_klientow[adres].adres_surowy
numer_sekwencyjny = 2
pakiet3 = protocol.encode_messsage_Operacja(time.ctime(time.time()), "DISCONNECT", numer_sekwencyjny, pakiet1["id"]).encode("utf-8")
sock.sendto(pakiet3,adres_odbiorcy)# Wyslanie info o rozlaczeniu
numer_sekwencyjny -= 1
pakiet4 = protocol.encode_messsage_Status(time.ctime(time.time()), "TERMINATE", numer_sekwencyjny, pakiet1["id"]).encode("utf-8")
sock.sendto(pakiet4,adres_odbiorcy)# Wyslanie info o rozlaczeniu
pakiet5 = protocol.decode_message(client_data.decode("utf-8"))# Otrzymanie ACK
print("[SERWER] Koniec obslugi drugiego klienta")
# Koniec obslugi drugiego klienta
reset_sesji()
# Obsługa INVITE>REQUEST
elif pakiet1["operacja"] == "INVITE":
print("[SERWER] Otrzymano INVITE")
client_data, client_address = sock.recvfrom(1024) # Oczekiwanie na status
pakiet2 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie pakietu
#print(pakiet2)
# Poszukiwanie adresu rozmowcy
for adres in tablica_klientow:
if adres != adres_nadawcy:
adres_odbiorcy = tablica_klientow[adres_nadawcy].adres_surowy
if pakiet2["status"] == "REQUEST":
print("[SERWER] Otrzymano request")
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet2["id"]).encode("utf-8")
sock.sendto(pakiet_ack, client_address) # ACK SEND
for adres in addr:
if adres != adr_to_klucz(client_address[0],client_address[1]):
adres_odbiorcy = tablica_klientow[adres].adres_surowy
print(adr_to_klucz(client_address[0],client_address[1]))
print(adres_odbiorcy)
print("[SERWER] Odebrano serie invite/request")
# Wysłanie serii komunikatow zapraszajacych do rozmowy
numer_sekwencyjny = 2
sock.sendto(protocol.encode_messsage_Operacja(time.ctime(time.time()), "INVITE", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"),adres_odbiorcy)
sock.sendto(protocol.encode_messsage_Status(time.ctime(time.time()), "REQUEST", numer_sekwencyjny, tablica_klientow[adr_klienta].id).encode("utf-8"), adres_odbiorcy)
client_data, client_address = sock.recvfrom(1024)# ACK RECV
print("Wyslano invite/request")
# Koniec serii
elif pakiet2["status"] == "ACCEPT":
print("[SERWER] Odebrano INVITE/ ACCEPT")
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet2["id"]).encode("utf-8")
sock.sendto(pakiet_ack, tablica_klientow[adr_klienta].adres_surowy)# ACK SEND
for adres in addr:
if adres != adr_to_klucz(client_address[0],client_address[1]):
adres_odbiorcy = tablica_klientow[adres].adres_surowy
send_invite_accept(adres_odbiorcy)# wyslanie potwierdzenia zaproszenia
for adres in tablica_klientow:
if tablica_klientow[adres].adres_surowy == adres_odbiorcy:
tablica_klientow[adres].nr_sesji=nsesji
elif tablica_klientow[adres].adres_surowy == client_address:
tablica_klientow[adres].nr_sesji=nsesji
nsesji+=1
elif pakiet2["status"] == "DENY":
print("[SERWER] Odebrano INVITE/ DENY")
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet2["id"]).encode("utf-8")
sock.sendto(pakiet_ack, tablica_klientow[adr_klienta].adres_surowy)# ACK SEND
for adres in addr:
if adres != adr_to_klucz(client_address[0],client_address[1]):
adres_odbiorcy = tablica_klientow[adres].adres_surowy
send_invite_denied(adres_odbiorcy)
sock.sendto(protocol.encode_messsage_Dane(time.ctime(time.time()),numer_sekwencyjny,tablica_klientow[adr_klienta].id,"DENY").encode("utf-8"),tablica_klientow[adr_klienta].adres_surowy)
client_data, client_address = sock.recvfrom(1024)
reset_sesji()
elif pakiet1["operacja"]=="COMMUNICATE":
#wyslij_do_sesji(sock, adr_klienta, client_data)
#print("Otrzymano COMMUNICATE")
client_data, client_address = sock.recvfrom(1024) # Oczekiwanie na status REQUEST
pakiet2 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie pakietu
if pakiet2["status"]=="SENT":
#print("Otrzymano SENT")
client_data, client_address = sock.recvfrom(1024) # Oczekiwanie na status REQUEST
pakiet3 = protocol.decode_message(client_data.decode("utf-8")) # Odkodowanie pakietu
print("[ " + pakiet3["id"] + " ] " + pakiet3["data"])
for adres in tablica_klientow:
if adres == adres_nadawcy:
adres_odbiorcy = tablica_klientow[adres_nadawcy].adres_surowy
numer_sekwencyjny = 1
pakiet_ack = protocol.encode_messsage_Operacja(time.ctime(time.time()), "ACK", numer_sekwencyjny, pakiet1["id"]).encode("utf-8")
sock.sendto(pakiet_ack, adres_odbiorcy)
wyslij_do_sesji(sock, adr_klienta, client_data)# Przesłanie komunikatu do docelowego uczestnika sesji