def send_active_rooms_points(params):
lock.acquire()
a = Room.Room.get_active_rooms_points()
lock.release()
send(params[0], f"GAR~{len(a)}")
for i in range(len(a)):
send(params[0], f"{a[i]}")
def setup():
global client
# socket
try:
client = socket.socket()
client.settimeout(3)
client.connect((IP, ptr.PORT))
client.settimeout(None)
send(client, f"MAP~{ROOM}")
except TimeoutError:
print("Server seems to be shut down.")
return setup()
except socket.timeout:
print("Server seems to be shut down.")
return setup()
except ConnectionRefusedError:
print("Server seems to be shut down.")
return setup()
# window
os.environ['SDL_VIDEO_WINDOW_POS'] = '%i,%i' % (u.GetSystemMetrics(0) // 2, 0)
pygame.init()
a = pygame.image.load(icon_path)
s = pygame.display.set_mode((u.GetSystemMetrics(0) // 2, u.GetSystemMetrics(1)))
pygame.display.set_icon(a)
return s
def send_points_of_room(params):
lock.acquire()
try:
points = Room.Room.get_points_of(params[1])
lock.release()
send(params[0], f"GIT~{str(points[0])}")
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 7)
def send_attribute(params):
lock.acquire()
try:
atr = Unit.Unit.get_attribute(params[1])
lock.release()
send(params[0], f"GAB~{atr[0]}~{atr[1]}")
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 9)
def create_player(params):
lock.acquire()
try:
Player.Player(params[1], True, params[2])
send(params[0], "DON")
lock.release()
except FileExistsError:
lock.release()
Server.send_error(params[0], 4)
def create_room(params):
lock.acquire()
try:
Room.Room(params[1], True, params[2], params[3])
lock.release()
send(params[0], "DON")
except FileExistsError:
lock.release()
Server.send_error(params[0], 6)
def map_send(soc, msg):
try:
send(soc, msg)
res = receive(client)
print(f"(MAP) MSG: {msg}, RES: {res}")
return ptr.map_parse(res, client)
except ConnectionRefusedError:
print("Server seems to be shut down.")
except ConnectionAbortedError:
print("Server seems to be shut down.")
def delete_player(params):
lock.acquire()
try:
a = Player.Player(params[1], False)
a.delete_player()
send(params[0], 'DON')
lock.release()
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 5)
def remove_unit(params):
lock.acquire()
try:
a = Player.Player(params[1], False)
a.remove_unit_form_db(int(params[2]))
send(params[0], 'DON')
lock.release()
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 2)
def remove_player_from_room(params):
lock.acquire()
try:
a = Room.Room(params[1], False)
a.remove_player(params[2])
lock.release()
send(params[0], 'DON')
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 7)
except ValueError:
lock.release()
Server.send_error(params[0], 5)
def is_dead_or_ran(params):
lock.acquire()
try:
a = Player.Player(params[1], False)
res = a.is_dead_or_ran(params[2])
send(params[0], f"GTF~{int(res)}")
lock.release()
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 5)
except IndexError:
lock.release()
Server.send_error(params[0], 3)
def add_player_to_room(params):
lock.acquire()
try:
a = Room.Room(params[1], False)
a.add_player(params[2])
lock.release()
send(params[0], 'DON')
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 7)
except IndexError:
lock.release()
Server.send_error(params[0], 8)
def add_unit(params):
lock.acquire()
try:
a = Player.Player(params[1], False)
a.add_unit_by_name(params[2])
send(params[0], 'DON')
lock.release()
except FileNotFoundError as e:
lock.release()
if "unit" in str(e):
Server.send_error(params[0], 2)
else:
Server.send_error(params[0], 5)
def send_second_player(params):
lock.acquire()
try:
pnames = Room.Room.get_pnames(params[1])
lock.release()
pnames = pnames[0].split(',')
if len(pnames) != 2:
Server.send_error(params[0], 11)
return
pnames = [val for val in pnames if val != params[2]]
send(params[0], f"GST~{pnames[0]}")
except FileNotFoundError:
lock.release()
Server.send_error(params[0], 7)
def create_map(screen, ratios):
res = receive(client)
print(res, PLAYER_NUMBER)
if PLAYER_NUMBER == 1:
a = Map(screen, [''] * (24 * 24))
# a.generate_tiles_from_ratio(*ratios)
a.generate_tiles_from_config()
send(client, f"GMP~{str(a)}")
time.sleep(0.5)
return a
else:
time.sleep(0.5)
tiles_arr = ptr.map_parse(receive(client), client)
print(tiles_arr)
return Map(screen, tiles_arr)
def send_all_units(params):
lock.acquire()
try:
a = Player.Player(params[1], False)
all_units = a.get_unit(-1)
lock.release()
except FileNotFoundError:
Server.send_error(params[0], 5)
lock.release()
return
send(params[0], f"GAU~{len(all_units)}")
for unt in all_units:
msg = "GUT~" + '~'.join([str(val) for val in unt.as_tuple()])
send(params[0], msg)
def send_unit(params):
lock.acquire()
if params[2].isdigit():
try:
unt = Player.Player(params[1],
False).get_unit(int(params[2])).as_tuple()
except IndexError:
Server.send_error(params[0], 3)
lock.release()
return
else:
try:
unt = Unit.Unit.unit_by_name(params[2]).as_tuple()
except FileNotFoundError:
Server.send_error(params[0], 2)
lock.release()
return
msg = "GUT~" + '~'.join([str(val) for val in unt])
send(params[0], msg)
lock.release()
def attack(params):
lock.acquire()
p1 = Player.Player(params[1], False)
p2 = Player.Player(params[3], False)
ranged = bool(int(params[5]))
flank = bool(int(params[6]))
charge = bool(int(params[7]))
front = bool(int(params[8]))
advantage = float(params[9])
try:
d, c = p1.attack(int(params[2]), p2, int(params[4]), ranged, flank,
charge, front, advantage)
send(params[0], f"GDC~{d}~{c}")
lock.release()
except IndexError:
lock.release()
Server.send_error(params[0], 3)
except ValueError:
lock.release()
Server.send_error(params[0], 12)
def client_send(soc, msg):
try:
send(soc, msg)
res = receive(client)
print(f"MSG: {msg}, RES: {res}")
return ptr.client_parse(res, client)
except ConnectionRefusedError:
messagebox.showerror("Connection Error",
"Server seems to be shut down.")
print("Server seems to be shut down.")
return "ERR~11"
except ConnectionAbortedError:
messagebox.showerror("Connection Error",
"Server seems to be shut down.")
print("Server seems to be shut down.")
return "ERR~11"
except socket.timeout:
messagebox.showerror("Connection Error",
"Server seems to be shut down.")
print("Server seems to be shut down.")
return "ERR~11"
def handle_map(client, room, addr):
try:
lock.acquire()
try:
rooms[room].append(addr)
except KeyError:
rooms[room] = [addr]
lock.release()
while True:
lock.acquire()
if len(rooms[room]) == 2:
lock.release()
send(client, 'DON')
break
lock.release()
while True:
res = receive(client)
if res:
lock.acquire()
print(res)
for ad in rooms[room]:
if ad is not addr:
send(clients[ad], res)
lock.release()
except OSError as e:
rooms[room].remove(addr)
del clients[addr]
for ad in rooms[room]:
if ad is not addr:
send(clients[ad], f"FRT")
raise OSError(e)
def send_to_server():
send(client, f"GUA~{len(m.units)}")
for unt in m.units:
send(client, f"GSU~{str(unt)}")
import socket
from pyticario import protocol as ptr
from pyticario.network.common import receive, send
IP = socket.gethostbyname(socket.gethostname())
client = socket.socket()
client.connect((IP, ptr.PORT))
while True:
name = input(">>> ")
send(client, name)
if name == "DIS":
break
res = receive(client)
x = ptr.client_parse(res, client)
if x:
print(x)
def is_password_valid(params):
lock.acquire()
send(params[0],
f"GTF~{int(Player.Player.check_password(params[1], params[2]))}")
lock.release()
def done(params):
send(params[0], "DON")
def disconnect(params):
send(params[0], "DON")
params[0].close()
def send_error(client, error_number):
send(client, f"ERR~{error_number}")
