working client/server gameplay

Author: teddy-zhng

Diff for: client.py

@@ -42,14 +42,14 @@ def __init__(self, connect_tuple, debug = True):
 	def read_response(self):
 		resp_len = self.server_conn.recv(4)
 		if len(resp_len) < 4:
-			client_error_wrapper("unable to read resposne length")
-			raise Exception("need 4 bytes in length resposne, you have " + str(len(resp_len)))
+			client_error_wrapper("unable to read response length")
+			raise Exception("need 4 bytes in length response, you have " + str(len(resp_len)))
 		elif len(resp_len) > 4:
-			client_error_wrapper("unable to read resposne length")
-			raise Exception("need 4 bytes in length resposne, you have " + str(len(resp_len)))
+			client_error_wrapper("unable to read response length")
+			raise Exception("need 4 bytes in length response, you have " + str(len(resp_len)))
 		resp_len = int.from_bytes(resp_len, NET_ORDER)
 		if self.debug:
-			print("getting msg resposne len:", resp_len)
+			print("getting msg response len:", resp_len)
 
 		resp_data = self.server_conn.recv(resp_len)
 		return resp_data
@@ -68,30 +68,36 @@ def get_version(self):
 
     #caller guarantees turn is a single char, X or O
 	def place(self, turn):
-		user_coords = input("Please enter the coordinates you want to mark, eg: 0 0").split()
+		user_coords = input("Please enter the coordinates you want to mark in x-y order, eg: 0 0\n>").split(' ')
 		while len(user_coords) != 2:
-			input = ("You made me almost seg fault! Give me two coordinates!")
+			user_coords = input("Watch it! you made me almost seg fault! Give me two coordinates!").split(' ')
 
 		turn_enum = 1
 		if turn == 'O':
 			turn_enum = 2
-		packet = int.to_bytes(turn_enum, 4, NET_ORDER) + user_coords[0].encode("utf-8") + user_coords[1].encode("utf-8")
+
+		packet = int.to_bytes(turn_enum, 4, NET_ORDER) + int.to_bytes(int(user_coords[0]), 4, NET_ORDER) + int.to_bytes(int(user_coords[1]), 4, NET_ORDER)
 		self.server_conn.sendall(int.to_bytes(7, 4, NET_ORDER))
 		self.server_conn.sendall(packet) #send which player, and coordinates
 
+
 	#expects a response that is a 9 byte string representing the board
 	def read_board(self):
 		self.server_conn.sendall(int.to_bytes(8, 4, NET_ORDER))
 		response = self.read_response()
-		print(response)
 
 		#print the board //TODO convert ascii code from stuff
-		print('     0     1     2')
-		print(f'0    {response[0]}  |  {response[1]}  |  {response[2]}')
-		print('      --------------')
-		print(f'1    {response[3]}  |  {response[4]}  |  {response[5]}')
-		print('      --------------')
-		print(f'2    {response[6]}  |  {response[7]}  |  {response[8]}')
+		print()
+		print()
+		print('       0       1       2')
+		print()
+		print(f'0      {chr(response[0])}   |   {chr(response[1])}   |   {chr(response[2])}')
+		print('        ---------------')
+		print(f'1      {chr(response[3])}   |   {chr(response[4])}   |   {chr(response[5])}')
+		print('        ---------------')
+		print(f'2      {chr(response[6])}   |   {chr(response[7])}   |   {chr(response[8])}')
+		print()
+		print()
 
 	#expects 4 bytes repr. winner, 0 = no one, 1 = X, 2 = O
 	def get_winner(self):
@@ -109,20 +115,20 @@ def play(connect_tuple):
 	print("WELCOME TO ZERO TICTACTOE. 100% VULNERABILITY-FREE CODE GUARANTEED")
 	game.read_board()
 
-	time.sleep(1)
 	#gameplay
 	turn = 'X'
 	while game.get_winner() == 0:
-		print('Player %s\'s')
-		game.place(game, turn)
+		print('Player %s\'s turn' % turn)
+		game.place(turn)
 		print('Good move. I think...')
-		time.sleep(1)
+		print('-'*20)
 		game.read_board()
-		turn = turn == 'X' if turn == 'Y' else 'Y'
+		turn = 'X' if turn == 'O' else 'O'
 
 	#game ended
 	name = random.choice(names) # fingers crossed
-	print('CONGRATS %s YOU WIN!' % name) 
+	print('Congrats %s, YOU WIN!' % name) 
+	print('hope I guessed that right :^)')
 
 
 def main():

Diff for: helper.c

@@ -6,11 +6,17 @@
 
 #include "helper.h"
 #include "globals.h"
+#include "tictactoe.h"
 
 bool handle_get_version(int client_fd, char* client_str) {
     char version_str[0x100] = {0};
     sprintf(version_str, "Stanford Zero TicTacToe vesion %s", TICTACTOE_VERSION_STR);
     respond_str_to_client(client_fd, version_str);
+
+	//reset the board here in case a previous game was cut off before winning
+
+	reset_board();
+
     return true;
 }
 

Diff for: tictactoe.c

@@ -10,27 +10,40 @@
 #include "high_score.h"
 #include "helper.h"
 
-//TODO make sure each game has their own board, client_fd etc
-//this is just a visualization of what it'd look like for each player
-
+// from tictactoe.h:
+// enum Player {
+//     E, //E means empty and happens to be null too
+//	   X, 
+//     O 
+// };
 enum Player board[__BOARD_SIZE__][__BOARD_SIZE__] = { //(0, 0) top left, (2, 2) bottom right
     {E, E, E}, 
     {E, E, E}, 
     {E, E, E} 
 };
 
+void reset_board(){
+	for (int x = 0; x < __BOARD_SIZE__; x++) {
+        for (int y = 0; y < __BOARD_SIZE__; y++) {
+			board[x][y] = E;
+        }
+    }
+}
+
 //expects 3 * 4 bytes = 12
 bool handle_place(int client_fd, char* client_str) {
-    enum Player player; //first four bytes of packet are the player
-    while ( (player = get_int_from_client(client_fd)) == -1) { }
-    int x_coord; //next four bytes are the x
-    while ( (x_coord = get_int_from_client(client_fd)) == -1) { }
-    int y_coord; //last 4 are the y
-    while ( (y_coord = get_int_from_client(client_fd)) == -1) { }
+	enum Player player; //first four bytes of packet are the player
 
-    board[x_coord][y_coord] = player;
+	//flipped because of array indexing vs x-y order
+	int y_coord; //next four bytes are the y
+	int x_coord; //last 4 are the x
 
-    return true;
+	while ( (player = get_int_from_client(client_fd)) == -1) { }
+	while ( (y_coord = get_int_from_client(client_fd)) == -1) { }
+	while ( (x_coord = get_int_from_client(client_fd)) == -1) { }
+
+	board[x_coord][y_coord] = player;
+	return true;
 }
 
 //should we send the whole board as a (9 * 4) byte string instead? modify client/how we send this
@@ -66,8 +79,6 @@ bool handle_read_board(int client_fd, char* client_str) {
 bool handle_get_winner(int client_fd, char* client_str) {
     //implement a more effecient check if needed 
 
-		printf("entered get winner\n");
-
     enum Player winner = E;
 
     for (int i = 0; i < 3; i++) {
@@ -78,19 +89,19 @@ bool handle_get_winner(int client_fd, char* client_str) {
         if ((board[0][i] != E) && (board[0][i] == board[1][i]) && (board[0][i] == board[2][i]))
             winner = board[0][i];
     }
-	printf("sdfadafa\n");
 
     // check diagonals
     if ((board[0][0] != E) && (board[0][0] == board[1][1]) && (board[0][0] == board[2][2]))
         winner = board[0][0];
-printf("sdfadafa\n");
 
     if ((board[2][0] != E) && (board[2][0] == board[1][1]) && (board[0][0] == board[0][2]))
         winner = board[2][0];
 
-    //send winner to client
-	
-    respond_buff_to_client(client_fd, winner, sizeof(E));
+    //clear board and send winner to client
+	if (winner != E) {
+		reset_board();
+	}
+    respond_buff_to_client(client_fd, (char*)(&winner), sizeof(E));
 
     return true;//what to return for status?
 

Diff for: tictactoe.h

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 
 enum Player {
-    E, X, O //E is empty and happens to be null too, 0, 1, 2 default values
+    E, X, O //E means empty and happens to be null too, 0, 1, 2 default values
 };
 
 bool handle_place(int client_fd, char* client_str);
@@ -14,4 +14,6 @@ bool handle_read_board(int client_fd, char* client_str);
 
 bool handle_get_winner(int client_fd, char* client_str);
 
+void reset_board();
+
 #endif