def syn_client(self):
"""
Synchronise the client
:return: None
"""
Server.log("Synchronise client", "GamePanel")
if self.is_server:
grid_state = ''
for line in self.game.grid:
for e in line:
grid_state += str(e.value)
grid_state += SUB_SEPARATOR
self.ui.server.send_message_to_all(Server.encode_message(PARAMETER_SEPARATOR.join((
MESSAGE_SYN, SYN_GRID, str(self.game.current_turn.value), grid_state))))
if self.game.is_win():
self.ui.server.send_message_to_all(Server.encode_message(PARAMETER_SEPARATOR.join((
MESSAGE_SYN,
SYN_WIN, str(self.game.winner.value),
SUB_SEPARATOR.join(
(str(self.game.score[0]), str(self.game.score[1]))),
SUB_SEPARATOR.join((
''.join(str(self.game.win_tokens_coord[0])),
''.join(str(self.game.win_tokens_coord[1]))
))
))))
else:
self.ui.client.send_message(Server.encode_message(MESSAGE_SYN))
def button_play_command(self):
"""
When the button play (or ready is press)
:return: None
"""
if self.is_server:
if self.player_2_is_connected:
if self.player_2_is_ready:
self.export_last_game_settings()
self.ui.server.send_message_to_all(Server.encode_message(MESSAGE_PLAY))
self.ui.change_panel(
ServerGamePanel.ServerGamePanel,
player_1=Player.Player(TokenState.Player_1, self.players_tokens[0],
self.players_entry_string_variable[0].get()),
player_2=Player.Player(TokenState.Player_2, self.players_tokens[1],
self.players_entry_string_variable[1].get()),
is_server=self.is_server
)
else:
self.player_1_want_to_start()
else:
self.set_player_2_ready(not self.player_2_is_ready)
self.ui.client.send_message(Server.encode_message(PARAMETER_SEPARATOR.join((MESSAGE_SEND_READY,
str(self.player_2_is_ready)))))
class UI(tkinter.tix.Tk):
"""
The UI
"""
def __init__(self):
"""
Constructor
"""
super().__init__()
self.current_panel = None
self.is_alive = True
self.server = Server(max_clients_connected=1)
self.client = None
self.preference = Preferences.Preferences(
default_preferences=Preferences.DEFAULT_PREFERENCES)
self.translation = Translation.Translation(self.preference)
self.image_getter = ImageGetter.ImageGetter(self.translation)
# Configure
self.title(self.translation.get_translation("connect_four"))
# noinspection SpellCheckingInspection
self.iconphoto(True, self.image_getter.logo_image) # set the logo
self.geometry("{}x{}".format(WIDTH, HEIGHT))
self.minsize(MIN_WIDTH, MIN_HEIGHT)
self.protocol("WM_DELETE_WINDOW", self.destroy)
def change_panel(self, new_panel, **kwargs):
"""
Change the panel
:param new_panel: the new panel
:return: None
"""
if self.current_panel is not None:
self.current_panel.destroy()
new_panel = new_panel(master=self, ui=self, **kwargs)
self.current_panel = new_panel
self.current_panel.pack(expand=True, fill=tkinter.tix.BOTH)
self.update()
self.current_panel.on_create_finish()
def mainloop(self, n=0):
self.is_alive = True
super().mainloop(n)
def destroy(self):
self.is_alive = False
if self.server.server_is_on:
self.server.stop_server()
if self.client is not None and self.client.connected:
self.client.close_connection()
super().destroy()
def manual_connexion_button_command(self):
"""
When the button manual connexion is clicked
:return: None
"""
try:
host = socket.gethostbyname(
self.manual_connexion_host_string_var.get())
except socket.gaierror:
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_list_dialog_host_error_title"),
self.ui.translation.get_translation(
"server_list_dialog_host_error_message").format(
Server.get_ip()))
return None
port = self.manual_connexion_port.get()
try:
port = int(port)
except ValueError:
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_title"),
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_message"))
return None
if not (3000 <= port <= 3020):
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_title"),
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_message"))
return None
if Server.exist(host, port):
self.ui.client = Client(host, port)
if self.ui.client.connect():
self.ui.change_panel(
ServerGameConfigurationPanel.ServerGameConfigurationPanel,
create_game=False)
else:
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_list_dialog_unreachable_title"),
self.ui.translation.get_translation(
"server_list_dialog_unreachable_message"))
return
def send_add_token(self, x, y):
"""
Send add token to the player
:param x: The x coord of the new token
:param y: The y coord of the new token
:return: None
"""
if self.is_server:
self.ui.server.send_message_to_all(
Server.encode_message(PARAMETER_SEPARATOR.join((MESSAGE_NEW_TOKEN, str(x), str(y))))
)
else:
self.ui.client.send_message(Server.encode_message(
PARAMETER_SEPARATOR.join((MESSAGE_NEW_TOKEN, str(x), str(y))))
)
def __init__(self,
port_min=3000,
port_max=3020,
max_thread=100,
list_update_function=lambda add_remove, host_port: None):
"""
Constructor
"""
super().__init__()
self.setDaemon(True)
self.server_detected_list = []
self.stop_scan = False
self.list_update_function = list_update_function
self.port_min = port_min
self.port_max = port_max
socket.setdefaulttimeout(TIMEOUT)
self.max_thread = max_thread
self.thread_running = 0
self.threads = Queue()
self.list_in_queue = []
self.disable_local_loop = Server.get_ip() != LOCAL_LOOP
def server_send_token(self):
"""
Send the token of the client
:return: None
"""
self.ui.server.send_message_to_all(Server.encode_message(
PARAMETER_SEPARATOR.join((MESSAGE_SEND_TOKEN_SELECTED, str(self.players_tokens[self.player_id].value))))
)
def client_on_connection_function(self):
"""
When the client is connect
:return: None
"""
self.ui.client.send_message(Server.encode_message(MESSAGE_NEED_STATE))
self.client_send_player_name()
self.client_send_token()
def client_send_player_name(self):
"""
Send the name of the client player
:return:
"""
self.ui.client.send_message(Server.encode_message(
PARAMETER_SEPARATOR.join((MESSAGE_SEND_NAME_SELECTED,
self.players_entry_string_variable[self.player_id].get()))))
def server_send_player_name(self):
"""
Send the name of the host player
:return: None
"""
self.ui.server.send_message_to_all(Server.encode_message(
PARAMETER_SEPARATOR.join((MESSAGE_SEND_NAME_SELECTED,
self.players_entry_string_variable[self.player_id].get())))
)
def player_1_want_to_start(self):
"""
When the player click on the button play and the second player isn't ready
:return: None
"""
self.player_1_label.configure(
text=self.ui.translation.get_translation("server_configuration_player_1_want_start"), bg="#ee2e31"
)
if self.is_server:
self.ui.server.send_message_to_all(Server.encode_message(MESSAGE_PLAYER_1_WANT_START))
def button_restart_command(self):
"""
The command of the button restart
:return: None
"""
if self.is_server:
self.ui.server.send_message_to_all(Server.encode_message(MESSAGE_RESTART_GAME))
self.game.reset()
self.ui.change_panel(ServerGamePanel,
player_1=self.players[TokenState.TokenState.Player_1],
player_2=self.players[TokenState.TokenState.Player_2],
game=self.game, is_server=self.is_server)
def server_on_message(self, message):
"""
When the server receive a message
:param message: The message receive
:return: None
"""
message = message.split(PARAMETER_SEPARATOR)
if message[0] == MESSAGE_NEW_TOKEN and len(message) == 3:
if self.game.current_turn == TokenState.TokenState.Player_1:
self.syn_client()
try:
x = int(message[1])
y = int(message[2])
if 0 <= x < self.game.grid_width and \
0 <= y < self.game.grid_height:
if not self.add_token_with_coord(x, y)[0]:
Server.warn("Can't place a token at this coord", "GamePanel")
self.syn_client()
else:
Server.warn("X or y is not valid", "GamePanel")
self.syn_client()
except ValueError:
Server.warn("X or y coord NaN", "GamePanel")
self.syn_client()
elif message[0] == MESSAGE_SYN:
self.syn_client()
def __init__(self):
"""
Constructor
"""
super().__init__()
self.current_panel = None
self.is_alive = True
self.server = Server(max_clients_connected=1)
self.client = None
self.preference = Preferences.Preferences(default_preferences=Preferences.DEFAULT_PREFERENCES)
self.translation = Translation.Translation(self.preference)
self.image_getter = ImageGetter.ImageGetter(self.translation)
# Configure
self.title(self.translation.get_translation("connect_four"))
# noinspection SpellCheckingInspection
self.iconphoto(True, self.image_getter.logo_image) # set the logo
self.geometry("{}x{}".format(WIDTH, HEIGHT))
self.minsize(MIN_WIDTH, MIN_HEIGHT)
self.protocol("WM_DELETE_WINDOW", self.destroy)
def manual_connexion_button_command(self):
"""
When the button manual connexion is clicked
:return: None
"""
try:
host = socket.gethostbyname(
self.manual_connexion_host_string_var.get())
except socket.gaierror:
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_list_dialog_host_error_title"),
self.ui.translation.get_translation(
"server_list_dialog_host_error_message").format(
Server.get_ip()))
return None
port = self.manual_connexion_port.get()
try:
port = int(port)
if port < 1 or port > 65535:
raise ValueError
except ValueError:
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_title"),
self.ui.translation.get_translation(
"server_configuration_dialog_port_error_message"))
return None
if not (GAME_PORT_MIN <= port <= GAME_PORT_MAX):
if not tkinter.messagebox.askokcancel(
self.ui.translation.get_translation(
"server_configuration_dialog_port_warning_title"),
self.ui.translation.get_translation(
"server_configuration_dialog_port_warning_message")):
return None
self.ui.client = Client(host, port)
if self.ui.client.connect():
self.ui.change_panel(
ServerGameConfigurationPanel.ServerGameConfigurationPanel,
is_server=False)
else:
self.ui.client = None
tkinter.messagebox.showerror(
self.ui.translation.get_translation(
"server_list_dialog_unreachable_title"),
self.ui.translation.get_translation(
"server_list_dialog_unreachable_message"))
return
def button_play_server_command(self, host_port):
"""
When the button to play with a server
:param host_port: host and port of the server
:return: None
"""
if Server.exist(host_port[0], host_port[1]):
self.ui.client = Client(host_port[0], host_port[1])
if self.ui.client.connect():
self.ui.change_panel(
ServerGameConfigurationPanel.ServerGameConfigurationPanel,
is_server=False)
else:
self.server_scanner_server_detection(ServerScanner.SERVER_REMOVE,
host_port)
def button_back_command(self):
"""
The command of the button back
:return: None
"""
if self.is_server:
from UI.ServerGameConfigurationPanel import ServerGameConfigurationPanel
self.ui.change_panel(ServerGameConfigurationPanel, is_server=self.is_server)
self.ui.server.send_message_to_all(Server.encode_message(MESSAGE_BACK_MENU))
else:
if tkinter.messagebox.askquestion(
self.ui.translation.get_translation("server_dialog_quit_title"),
self.ui.translation.get_translation("server_dialog_quit_message")
) == tkinter.messagebox.YES:
from UI.ServerListPanel import ServerListPanel
self.ui.client.close_connection()
self.ui.change_panel(ServerListPanel)
def __init__(self, master, ui, is_server=False,
player_1=Player.Player(TokenState.TokenState.Player_1, TokenStyle.TokenStyle.Blue),
player_2=Player.Player(TokenState.TokenState.Player_2, TokenStyle.TokenStyle.Green),
game=None):
"""
Constructor
"""
super().__init__(master, ui, player_1, player_2, game, disable_end_button=not is_server)
self.is_server = is_server
self.button_syn = tkinter.tix.Button(
self, image=self.ui.image_getter.syn_icon, command=self.button_syn_command)
self.button_syn.place(relx=1., rely=0., x=0, y=0, anchor=tkinter.N + tkinter.E)
self.button_syn_lock = False
if self.is_server:
self.after(100, lambda: self.ui.server.send_message_to_all(Server.encode_message(
PARAMETER_SEPARATOR.join((MESSAGE_SET_TURN, str(self.game.current_turn.value))))))
self.button_main_menu.configure(
text=self.ui.translation.get_translation("quit"), command=self.button_back_dialog_command
)
# Set server functions
self.ui.server.on_message_function = self.server_on_message
self.ui.server.on_client_connect_function = self.server_on_client_connect_function
self.ui.server.on_client_disconnect_function = self.server_on_client_disconnect_function
else:
tkinter.tix.Label(
self.win_text_frame,
text=self.ui.translation.get_translation("server_game_wait_host")
).grid(row=1, column=0)
# Set client functions
self.ui.client.on_message_function = self.client_on_message
self.ui.client.on_connection_function = self.client_on_connection_function
self.ui.client.on_disconnection_function = self.client_on_disconnection_function
def __init__(self, master, ui):
"""
Constructor
"""
super().__init__(master, ui)
for r in range(1, 2):
self.grid_rowconfigure(r, weight=1)
for c in range(0, 2):
self.grid_columnconfigure(c, weight=1)
tkinter.tix.Label(self,
text=self.ui.translation.get_translation(
"server_list_server_detected")).grid(
row=0, column=0, sticky=tkinter.tix.W)
self.scrolled_window_server_detected = tkinter.tix.ScrolledWindow(self)
self.scrolled_window_server_detected.grid(row=1,
column=0,
columnspan=2,
sticky=tkinter.tix.NSEW)
self.window_server_detected = self.scrolled_window_server_detected.window
self.window_server_detected.grid_columnconfigure(0, weight=1)
self.dict_server_detected = {}
self.manual_connexion_frame = tkinter.tix.Frame(self)
self.manual_connexion_frame.grid(row=2,
column=0,
columnspan=2,
sticky=tkinter.tix.NSEW)
for c in range(0, 3):
self.manual_connexion_frame.columnconfigure(c, weight=1)
tkinter.tix.Label(self.manual_connexion_frame,
text=self.ui.translation.get_translation(
"server_list_manual_connexion_frame_text")).grid(
row=0,
column=0,
rowspan=2,
sticky=tkinter.tix.NSEW)
tkinter.tix.Label(self.manual_connexion_frame,
text=self.ui.translation.get_translation(
"server_list_manual_connexion_frame_host")).grid(
row=0, column=1, sticky=tkinter.tix.E)
self.manual_connexion_host_string_var = tkinter.tix.StringVar()
self.manual_connexion_host_string_var.set(Server.get_ip())
self.manual_connexion_host_entry = tkinter.tix.Entry(
self.manual_connexion_frame,
textvariable=self.manual_connexion_host_string_var)
self.manual_connexion_host_entry.grid(row=0,
column=2,
sticky=tkinter.tix.NSEW)
tkinter.tix.Label(self.manual_connexion_frame,
text=self.ui.translation.get_translation(
"server_list_manual_connexion_frame_port")).grid(
row=1, column=1, sticky=tkinter.tix.E)
self.manual_connexion_port = tkinter.tix.Spinbox(
self.manual_connexion_frame, from_=1, to=65535, increment=1)
self.manual_connexion_port.delete(0, 1)
self.manual_connexion_port.insert(0, GAME_PORT_MIN)
self.manual_connexion_port.grid(row=1,
column=2,
sticky=tkinter.tix.NSEW)
self.play_button = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation("play"),
state=tkinter.tix.DISABLED)
self.play_button.grid(row=3, column=0, sticky=tkinter.tix.NSEW)
self.manual_connexion_button = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation(
"server_list_manual_connexion"),
command=self.manual_connexion_button_command)
self.manual_connexion_button.grid(row=3,
column=1,
sticky=tkinter.tix.NSEW)
self.back_button = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation("back"),
command=self.button_back_command)
self.back_button.grid(row=4, column=0, sticky=tkinter.tix.NSEW)
self.create_game_button = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation(
"server_list_create_game"),
command=self.button_create_game_command)
self.create_game_button.grid(row=4, column=1, sticky=tkinter.tix.NSEW)
self.server_scanner = ServerScanner.ServerScanner(
list_update_function=self.server_scanner_server_detection)
def client_on_message(self, message):
"""
When the client receive a message
:param message: The message receive
:return: None
"""
message = message.split(PARAMETER_SEPARATOR)
if message[0] == MESSAGE_SET_TURN and len(message) == 2:
self.game.current_turn = TokenState.TokenState(int(message[1]))
self.update_turn_label()
elif message[0] == MESSAGE_NEW_TOKEN and len(message) == 3:
if self.game.current_turn == TokenState.TokenState.Player_2:
self.syn_client()
return
try:
x = int(message[1])
y = int(message[2])
if 0 <= x < self.game.grid_width and \
0 <= y < self.game.grid_height:
if not self.add_token_with_coord(x, y)[0]:
Server.warn("Can't place a token at this coord", "GamePanel")
self.syn_client()
else:
Server.warn("X or y is not valid", "GamePanel")
self.syn_client()
except ValueError:
Server.warn("X or y coord NaN", "GamePanel")
self.syn_client()
elif message[0] == MESSAGE_BACK_MENU:
from UI.ServerGameConfigurationPanel import ServerGameConfigurationPanel
self.ui.change_panel(ServerGameConfigurationPanel, is_server=False)
elif message[0] == MESSAGE_RESTART_GAME:
self.button_restart_command()
elif message[0] == MESSAGE_SYN and 3 < len(message) < 6:
if message[1] == SYN_GRID:
try:
current_token = TokenState.TokenState(int(message[2]))
if self.game.current_turn != current_token:
self.game.current_turn = current_token
self.update_turn_label()
except ValueError:
pass
split = message[3].split(SUB_SEPARATOR)
if len(split) == self.game.grid_width and len(split[0]) == self.game.grid_height:
for x, line in enumerate(split):
for y, e in enumerate(line):
token = TokenState.TokenState(int(e))
if self.game.grid[x][y] != token:
self.game.grid[x][y] = token
self.update_image(x, y)
else:
try:
self.game.winner = TokenState.TokenState(int(message[2]))
except ValueError:
pass
scores = message[3].split(SUB_SEPARATOR)
if len(scores) == 2:
scores[0], scores[1] = int(scores[0]), int(scores[1])
self.game.score = scores
token_coord = message[4].split(SUB_SEPARATOR) # xy|xy
if len(token_coord) == 2 and len(token_coord[0]) == 2:
for i, c in enumerate(token_coord):
for j, xy in enumerate(c):
self.game.win_tokens_coord[i][j] = xy
self.game.win_tokens_coord = token_coord
self.update_win()
def server_start_stop_command(self):
"""
Start the server
:return: None
"""
if self.ui.server.server_is_on:
if not self.player_2_is_connected or tkinter.messagebox.askquestion(
self.ui.translation.get_translation("server_dialog_server_stop_title"),
self.ui.translation.get_translation("server_dialog_server_stop_message")
) == tkinter.messagebox.YES:
if self.ui.server.stop_server():
self.server_port_spin_box.configure(state=tkinter.tix.NORMAL, increment=1)
self.server_start_stop.configure(
text=self.ui.translation.get_translation("server_configuration_start")
)
self.server_state_label.configure(
text=self.ui.translation.get_translation("server_state_stopped"),
fg="#ee2e31"
)
else:
try:
port = int(self.server_port_spin_box.get())
if port < 1 or port > 65535:
raise ValueError
except ValueError:
tkinter.messagebox.showerror(
self.ui.translation.get_translation("server_configuration_dialog_port_error_title"),
self.ui.translation.get_translation("server_configuration_dialog_port_error_message")
)
else:
if port < GAME_PORT_MIN or port > GAME_PORT_MAX:
if not tkinter.messagebox.askokcancel(
self.ui.translation.get_translation("server_configuration_dialog_port_warning_title"),
self.ui.translation.get_translation("server_configuration_dialog_port_warning_message")
):
return
self.ui.server = Server(
port=port, max_clients_connected=1,
on_message_function=self.server_on_message,
on_client_connect_function=self.server_on_client_connect_function,
on_client_disconnect_function=self.server_on_client_disconnect_function
)
result = self.ui.server.start_server()
if result[0]:
self.server_port_spin_box.configure(state="readonly", increment=0)
self.server_start_stop.configure(
text=self.ui.translation.get_translation("server_configuration_stop")
)
self.server_state_label.configure(
text=self.ui.translation.get_translation("server_state_started"), fg="#78bc61"
)
else:
error_name = errno.errorcode[result[1]]
if self.ui.translation.translation_exist(SERVER_ERROR_DIALOG_KEY_FORMAT.format(error_name)):
tkinter.messagebox.showerror(
self.ui.translation.get_translation("server_start_error_dialog_title")
.format(result[1]),
self.ui.translation.get_translation(SERVER_ERROR_DIALOG_KEY_FORMAT.format(error_name))
)
else:
tkinter.messagebox.showerror(
self.ui.translation.get_translation("server_start_error_dialog_title")
.format(result[1]),
self.ui.translation.get_translation("server_start_error_unknown_dialog_message")
.format(result[1], error_name, result[2].strerror)
)
for i in range(1000):
rtt100.append(100)
rtt150.append(150)
#+++++++++++++++++++++Chunks++++++++++++++++++++++++++++++++++++++++++
for size in chunksizes:
clientq = queue.Queue()
serverq = queue.Queue()
ackq = queue.Queue()
#++++++++++++++++++++++Sequential++++++++++++++++++++++++++++++
s = Server(size, ackq, clientq, serverq, "receive" , "sequential" , rtt100, 10)
c = Client(size, ackq, clientq, serverq, "send", "sequential")
s.setName("Server")
c.setName("Client")
s.start()
c.start()
c.join()
while True:
if not c.is_alive():
delay = s.get_delay()
chunkresult['value'][:,0][np.logical_and(chunkresult['scheme'] == 'seq', chunkresult['chunksize'] == size)] = delay
s.join()
break
def __init__(self, master, ui, is_server=False):
"""
Constructor
"""
super().__init__(master, ui)
self.is_server = is_server
self.player_2_is_ready = False
self.player_2_is_connected = False
for r in range(2, 3):
self.rowconfigure(r, weight=1)
for c in range(0, 2):
self.columnconfigure(c, weight=1)
self.player = (TokenState.Player_2, TokenState.Player_1)[is_server]
self.player_id = (1, 0)[is_server]
self.opponent = (TokenState.Player_1, TokenState.Player_2)[is_server]
self.opponent_id = (0, 1)[is_server]
self.ui.image_getter.resize_tokens_images(100)
# Configure server
if is_server:
self.server_configure_frame = tkinter.tix.Frame(
self, relief=tkinter.tix.SUNKEN, borderwidth=2,
padx=10, pady=10
)
self.server_configure_frame.grid(row=0, column=0, columnspan=2, sticky=tkinter.tix.NSEW, padx=10, pady=10)
for c in range(0, 2):
self.server_configure_frame.columnconfigure(c, weight=1)
self.server_state_label = tkinter.tix.Label(
self.server_configure_frame, text=self.ui.translation.get_translation("server_state_stopped"),
fg="#ee2e31"
)
self.server_state_label.grid(row=0, column=0, columnspan=2, sticky=tkinter.tix.NSEW)
self.server_host = tkinter.tix.Label(
self.server_configure_frame,
text=self.ui.translation.get_translation("server_configuration_host_label").format(
Server.get_ip())
)
self.server_host.grid(row=1, column=0, sticky=tkinter.tix.NSEW)
self.server_port_frame = tkinter.tix.Frame(self.server_configure_frame)
self.server_port_frame.grid(row=1, column=1, sticky=tkinter.tix.NSEW)
for c in range(0, 2):
self.server_port_frame.columnconfigure(c, weight=1)
self.server_port_label = tkinter.tix.Label(
self.server_port_frame,
text=self.ui.translation.get_translation("server_configuration_port_entry_title")
)
self.server_port_label.grid(row=0, column=0, sticky=tkinter.tix.E)
self.server_port_spin_box = tkinter.tix.Spinbox(self.server_port_frame, from_=1, to=65535, increment=1)
self.server_port_spin_box.delete(0, 1)
self.server_port_spin_box.insert(0, GAME_PORT_MIN)
self.server_port_spin_box.grid(row=0, column=1, sticky=tkinter.tix.W)
self.server_action_frame = tkinter.tix.Frame(self.server_configure_frame)
self.server_action_frame.grid(row=2, column=0, columnspan=2, sticky=tkinter.tix.NSEW)
for c in range(0, 3):
self.server_action_frame.columnconfigure(c, weight=1)
self.server_start_stop = tkinter.tix.Button(
self.server_action_frame, text=self.ui.translation.get_translation("server_configuration_start"),
command=self.server_start_stop_command
)
self.server_start_stop.grid(row=0, column=0, sticky=tkinter.tix.NSEW)
if self.ui.server.server_is_on:
self.server_port_spin_box.configure(state="readonly", increment=0)
self.server_start_stop.configure(
text=self.ui.translation.get_translation("server_configuration_stop")
)
self.server_state_label.configure(
text=self.ui.translation.get_translation("server_state_started"), fg="#78bc61"
)
# Configure game
self.players_name_frame = [tkinter.tix.Frame(self),
tkinter.tix.Frame(self)]
self.players_name_frame[0].grid(row=1, column=0)
self.players_name_frame[1].grid(row=1, column=1)
tkinter.tix.Label(self.players_name_frame[0], text=self.ui.translation.get_translation(
"configure_game_panel_name")).grid(row=0, column=0)
tkinter.tix.Label(self.players_name_frame[1], text=self.ui.translation.get_translation(
"configure_game_panel_name")).grid(row=0, column=0)
self.players_entry_string_variable = [
tkinter.tix.StringVar(),
tkinter.tix.StringVar()
]
for i in range(0, 2):
if i == self.opponent_id:
self.players_entry_string_variable[i].set(
self.ui.translation.get_translation("server_configuration_waiting"))
else:
self.players_entry_string_variable[i].set(
self.ui.translation.get_translation("default_player_name").format(str(i + 1))
)
self.players_entry = [tkinter.tix.Entry(self.players_name_frame[0],
textvariable=self.players_entry_string_variable[0],
state=("readonly", "normal")[is_server]),
tkinter.tix.Entry(self.players_name_frame[1],
textvariable=self.players_entry_string_variable[1],
state=("normal", "readonly")[is_server])]
if is_server:
self.players_entry_string_variable[0].trace_add("write", lambda x, y, z: self.name_string_var_trace_write())
else:
self.players_entry_string_variable[1].trace_add("write", lambda x, y, z: self.name_string_var_trace_write())
self.players_entry[0].grid(row=0, column=1)
self.players_entry[1].grid(row=0, column=1)
self.players_settings_scrolled_window = [tkinter.tix.ScrolledWindow(self, relief=tkinter.tix.SUNKEN,
borderwidth=3),
tkinter.tix.ScrolledWindow(self, relief=tkinter.tix.SUNKEN,
borderwidth=3)]
self.players_settings_scrolled_window[0].grid(row=2, column=0, sticky=tkinter.tix.NSEW, pady=10, padx=5)
self.players_settings_scrolled_window[1].grid(row=2, column=1, sticky=tkinter.tix.NSEW, pady=10, padx=5)
self.players_settings_window = [self.players_settings_scrolled_window[0].window,
self.players_settings_scrolled_window[1].window]
for i in range(0, 2):
self.players_settings_window[i].grid_columnconfigure(0, weight=1)
self.players_tokens = [
TokenStyle.TokenStyle(random.randint(0, TokenStyle.NUMBER_STYLE - 1)),
TokenStyle.TokenStyle(random.randint(0, TokenStyle.NUMBER_STYLE - 1))
]
self.players_tokens[self.opponent_id] = TokenStyle.TokenStyle.Not_Connected
self.players_tokens_images = [
self.ui.image_getter.save_token_photos[TokenState.Player_1][self.players_tokens[0]],
self.ui.image_getter.save_token_photos[TokenState.Player_2][self.players_tokens[1]]
]
self.players_tokens_labels = [
tkinter.tix.Label(self.players_settings_window[0], image=self.players_tokens_images[0]),
tkinter.tix.Label(self.players_settings_window[1], image=self.players_tokens_images[1])
]
self.players_tokens_labels[0].grid(row=1, column=0, sticky=tkinter.tix.NSEW)
self.players_tokens_labels[1].grid(row=1, column=0, sticky=tkinter.tix.NSEW)
self.player_1_label = tkinter.tix.Label(
self.players_settings_window[0], fg="white", text="", wraplength=250
)
self.player_1_label.grid(row=2, column=0)
self.player_2_ready_label = tkinter.tix.Label(
self.players_settings_window[1], fg="#ee2e31",
text=self.ui.translation.get_translation(
("server_configuration_player_2_not_ready",
"server_configuration_player_2_not_connected")
[self.is_server])
)
self.player_2_ready_label.grid(row=2, column=0)
self.button_token_choose_per_line_last = 0
self.button_token_choose_per_line = 0
self.token_choose_frame = tkinter.tix.Frame(self.players_settings_window[self.player_id])
self.token_choose_frame.grid(row=3, column=0, sticky=tkinter.tix.NSEW)
self.token_choose_buttons = []
for index in range(0, TokenStyle.NUMBER_STYLE):
self.token_choose_buttons.append(tkinter.tix.Button(self.token_choose_frame,
image=self.ui.image_getter.save_token_icons[self.player]
[TokenStyle.TokenStyle(index)],
command=lambda _index=index:
self.button_change_token_command(
_index)))
self.button_main_menu = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation("back"),
command=self.button_main_menu_command)
self.button_main_menu.grid(row=3, column=0, sticky=tkinter.tix.NSEW)
self.button_play = tkinter.tix.Button(
self,
text=self.ui.translation.get_translation(("ready", "play")[is_server]),
command=self.button_play_command)
if not self.is_server:
self.button_play.configure(fg="#ee2e31", activeforeground="#ee2e31")
self.button_play.grid(row=3, column=1, sticky=tkinter.tix.NSEW)
self.import_last_game_setting()
if is_server:
# Set server functions
self.ui.server.on_message_function = self.server_on_message
self.ui.server.on_client_connect_function = self.server_on_client_connect_function
self.ui.server.on_client_disconnect_function = self.server_on_client_disconnect_function
else:
# Set client functions
self.ui.client.on_message_function = self.client_on_message
self.ui.client.on_connection_function = self.client_on_connection_function
self.ui.client.on_disconnection_function = self.client_on_disconnection_function
self.client_on_connection_function() # because it is already connected
