Fixed some commenting issues; Added code to detect if game was quit by peer and, if so, quit the game locally

includes/serialization.h

@@ -6,17 +6,19 @@ extern "C" {
 #endif
 
 #include <stdint.h>
+#include <stdbool.h>
 
 /* Struct used to hold the data that will be sent between sockets */
 typedef struct {
-	uint16_t pad_x;
-	uint16_t pad_y;
-	uint16_t ball_x;
-	uint16_t ball_y;
+	uint16_t pad_x; // X-coordinate of sending paddle
+	uint16_t pad_y; // Y-coordinate of sending paddle
+	uint16_t ball_x; // X-coordinate of ball (only the server fills this in)
+	uint16_t ball_y; // Y-coordinate of ball (only the server fills this in)
+	bool should_quit; // Flag to indicate whether game should be quit or not
 } Serial_Data;
 
 /* Create a Serial_Data struct from float values */
-Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y);
+Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y, bool should_quit);
 
 /* Serialize a struct into a byte array, that can be sent through a socket */
 uint8_t* Serial_serialize(Serial_Data data);

main.cpp

@@ -264,33 +264,35 @@ int main(int argc, char** argv) {
 		if (game_started) {
 			/* Serialize the data that we need to send, and then send it to the peer paddle */
 			if (type.mode == M_SERVER) {
-				/* Serial_create_data creates a Serial_Data struct from our values, and Serial_serialize serializes it Paddle 2 is controled by the server, Paddle 1, by the client.*/
-				to_send_data = Serial_create_data(pad2.getRect().x, pad2.getRect().y, ball.pos.x, ball.pos.y);
+				/* Serial_create_data creates a Serial_Data struct from our values.
+				 Paddle 2 is controlled by the server, Paddle 1, by the client.*/
+				to_send_data = Serial_create_data(pad2.getRect().x, pad2.getRect().y, ball.pos.x, ball.pos.y, false);
 			}
 			else if (type.mode == M_CLIENT) {
 				/* The _server_ is the authoritative peer for the ball position, so the client sends (0, 0) as the ball position instead of actually sending a position */
-				to_send_data = Serial_create_data(pad1.getRect().x, pad1.getRect().y, 0, 0);
+				to_send_data = Serial_create_data(pad1.getRect().x, pad1.getRect().y, 0, 0, false);
 			}
 			/* Only send and receive data if the game is not in single player mode */
 			if (type.mode != M_SINGLE) {
+				/* Serial_serialize serializes the struct into a byte_array. Since sendAll accepts a string, we have to convert this byte array into a string. */
+				type.netsock->sendAll((char *)Serial_serialize(to_send_data), sizeof(Serial_Data) + 1);
 
-				type.netsock->sendAll((char *)Serial_serialize(to_send_data), 9);	
 				/* Create Serial_data struct from the response of the server. Since recvAll returns a char*, we need to convert it to a byte array */
 				uint8_t* response_array = (uint8_t *)(type.netsock->recvAll());
 				if (response_array != NULL) {
-				/* If the response is NULL, that means it timed-out. In this case, there's no value to print */
 					response_data = Serial_deserialize(response_array);
 					std::cout << response_data.pad_x << "\t" << response_data.pad_y << "\t" << response_data.ball_x << "\t" << response_data.ball_y << std::endl;
 				} else {
+					/* If the response is NULL, that means it timed-out. In this case, there's no value to print */
 					std::cout << "NOTHING RECEIVED" << std::endl;
 				}
-
 			}
 			
-			/* When updating the paddle positions, update the peer paddle's positions based on the vector set earlier */
-
-			std::string to_send = "";
-			/* Update paddle velocity */
+			/* Check to see if peer has quit the game */
+			if (response_data.should_quit == true) {
+				std::cout << "Peer unexpectedly quit game." << std::endl;
+				break; // Break out of main game loop
+			}
 			
 			/* Left paddle (controlled by client) - I use type.mode != M_SERVER, because I also want the single player 
 			mode to be able to control the paddle. Therefore, the only mode that _can't_ control the paddle is the server
@@ -327,7 +329,8 @@ int main(int argc, char** argv) {
 				pad2.velocity.y = 0;
 			}
 
-			/* The client should set the ball position based on the data sent by the server. It doesn't have to do any calculations of its own. */
+			/* Why did I use 'type.mode != M_CLIENT'? - The client should set the ball position solely based
+			 on the data sent by the server. It doesn't have to do any calculations of its own. */
 			if (type.mode != M_CLIENT) {
 				/* Update ball velocity based on collision detection */
 				if (pad1.getRect().CheckCollision(ball.pos, ball.radius)) { /* Collision with paddle 1 */
@@ -366,7 +369,8 @@ int main(int argc, char** argv) {
 				ball.vel.y = ball.vel.y * -1;
 			}
 
-			/* Update positions based on velocities - Client only updates pad1, server updates pad2 and ball */
+			/* Update positions based on velocities - Client only updates pad1 (and receives data for pad2), 
+			server updates pad2 and ball (and receives data for pad1) */
 			if (type.mode != M_CLIENT) {
 				ball.updatePosition();
 				pad2.updatePosition();
@@ -391,6 +395,10 @@ int main(int argc, char** argv) {
 		window.EndDrawing();
 	}
 	
+	/* If the game has been quit, ask the peer to quit as well */
+	to_send_data = Serial_create_data(0, 0, 0, 0, true);
+	type.netsock->sendAll((char *)Serial_serialize(to_send_data), sizeof(Serial_Data) + 1);
+	
 	window.Close();
 	sock_quit();
 

serialization.c

@@ -1,5 +1,6 @@
 #include <stdint.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #ifdef linux
 	#include <arpa/inet.h>
@@ -11,29 +12,32 @@
 
 
 /* Takes in float values, casts them to uint16_t and creates a Serial_Data struct */
-Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y) {
+Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y, bool should_quit) {
 	Serial_Data data;
 	data.pad_x = (uint16_t)pad_x;
 	data.pad_y = (uint16_t)pad_y;
 	data.ball_x = (uint16_t)ball_x;
 	data.ball_y = (uint16_t)ball_y;
-	
+	data.should_quit = should_quit;
 	return data;
 }
 
 /* Serializes a 'Data' struct into a byte array, converted to network-byte order */
 uint8_t* Serial_serialize(Serial_Data data) {
 	/* Create a pointer that can fit the entire struct */
-	uint8_t* serialized = malloc(4 * sizeof(uint16_t) + 1);
+	uint8_t* serialized = malloc(sizeof(Serial_Data) + 1);
 	uint8_t* pad_x_ptr;
 	uint8_t* pad_y_ptr;
 	uint8_t* ball_x_ptr;
 	uint8_t* ball_y_ptr;
-	memset(serialized, 0, 4 * sizeof(uint16_t) + 1); // Zero out the memory
+	uint8_t* should_quit_ptr;
+	
+	memset(serialized, 0, sizeof(Serial_Data) + 1); // Zero out the memory
 	pad_x_ptr = serialized;
 	pad_y_ptr = pad_x_ptr + sizeof(uint16_t);
 	ball_x_ptr = pad_y_ptr + sizeof(uint16_t);
 	ball_y_ptr = ball_x_ptr + sizeof(uint16_t);
+	should_quit_ptr = ball_y_ptr + sizeof(uint16_t);
 
 	*((uint16_t *)pad_x_ptr) = data.pad_x;
 	*((uint16_t *)pad_x_ptr) = htons(*((uint16_t *)pad_x_ptr));
@@ -46,7 +50,9 @@ uint8_t* Serial_serialize(Serial_Data data) {
 	
 	*((uint16_t *)ball_y_ptr) = data.ball_y;
 	*((uint16_t *)ball_y_ptr) = htons(*((uint16_t *)ball_y_ptr));
-	*(ball_y_ptr + sizeof(uint16_t)) = '\0';
+	
+	*((bool *)should_quit_ptr) = data.should_quit;
+	*(should_quit_ptr + sizeof(bool)) = '\0';
 
 	return serialized;
 }
@@ -59,6 +65,7 @@ Serial_Data Serial_deserialize(uint8_t* serialized) {
 	uint8_t* pad_y_ptr = serialized + sizeof(uint16_t);
 	uint8_t* ball_x_ptr = pad_y_ptr + sizeof(uint16_t);
 	uint8_t* ball_y_ptr = ball_x_ptr + sizeof(uint16_t);
+	uint8_t* should_quit_ptr = ball_y_ptr + sizeof(uint16_t);
 
 	/* Dereference (and cast) the pointers, and store them into the struct */
 	deserialized.pad_x = *((uint16_t *)pad_x_ptr);
@@ -73,6 +80,8 @@ Serial_Data Serial_deserialize(uint8_t* serialized) {
 	deserialized.ball_y = *((uint16_t *)ball_y_ptr);
 	deserialized.ball_y = ntohs(deserialized.ball_y);
 		
+	deserialized.should_quit = *((bool *)should_quit_ptr);
+	
 	return deserialized;
 }