Added a virtual destructor to the Sock class, which would allow Server and Client to override it

.gitignore

@@ -1,4 +1,3 @@
 main.o
 easysock.o
 pong
-release/

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "subprojects/raylib"]
-	path = subprojects/raylib
-	url = https://github.com/raysan5/raylib.git

README.md

@@ -1,32 +0,0 @@
-## Netpong - A Pong game for the internet era
-
-__Netpong__ is a network-enabled Pong game, written in C++. It enables two players to play against each other, provided an IP address and a port. It also supports a single-player mode.
-
-## How it works
-
-The game has only one runtime dependency: The [raylib](https://www.raylib.com/) graphics system. In order to write idiomatic C++, I chose to use the [raylib-cpp](https://robloach.github.io/raylib-cpp/) wrapper, which provides an object-oriented interface to the Raylib library. However, this wrapper is bundled with the project, and is thus not required to be installed.
-
-## Building
-
-This application uses [Meson](https://mesonbuild.com/) as a build system. To build the application:
-1. Install __meson__ from the link above.
-2. Install __raylib__ from the link above (THIS IS OPTIONAL, SEE STEP 5)
-3. Set up the build directory with the `meson setup build` command.
-4. Compile the application, with the existing raylib installation, using `meson compile -C build`.
-5. If you don't have raylib installed, you can create a statically linked version of the library on Linux by running the following commands:
-
-	 ```
-	 meson configure -Ddefault_library=static build/
-	 meson compile -C build -Ddefault_library=static
-	 ```
-
-## Running
-
-- To run in single-player mode:
-	- Run the application with no arguments: `build/pong`
-	- Left paddle is controlled with `W` and `S` keys, right paddle is controlled with `Up` and `Down` arrow keys.
-	
-- To run in multi-player mode:
-	- One player runs the application in Server mode, specifying their IP address and a port: `build/pong -S <ip_address> <port>`
-	- The other player connects to the first player by running in Client mode, specifying the first player's IP address and port: `build/pong -C <ip_address> <port>`.
-	- The server controls the left paddle by default (WIP to allow the user to modify this), and the client controls the right paddle.

create_release_build.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-
-# This script copies required DLLs, and the application itself into a folder called 'release'. It only runs on MinGW.
-
-BASE_DIR=$(dirname $0)
-REL_DIR="$BASE_DIR/release/dist"
-
-mkdir -p "$REL_DIR"
-
-# Parse the output of the 'ldd' command, and create a file with the required DLL paths.
-ldd build/pong.exe | awk ' NF == 4 {print $3}' > "$BASE_DIR/tmp_file.txt"
-
-# Copy the required DLLs.
-cp $(cat "$BASE_DIR/tmp_file.txt") "$REL_DIR"
-
-# Copy the executable itself
-cp "$BASE_DIR/build/pong" "$REL_DIR"
-
-# Remove the temporary file.
-rm "$BASE_DIR/tmp_file.txt"
-

includes/easysock.hpp

@@ -6,7 +6,7 @@
 	#include <winsock.h>
 	#include <ws2tcpip.h>
 #endif
-#ifdef __unix__
+#ifdef linux
 	#include <sys/types.h>
 	#include <sys/socket.h>
 	#include <netdb.h>

includes/numeric_base.hpp

@@ -3,10 +3,10 @@
 #include <string>
 
 /* Convert the given value from the given base, to base 10 */
-unsigned int to_decimal(std::string num, int from_base);
+int to_decimal(std::string num, int from_base);
 
 /* Convert the given value from base 10 to the given base */
-std::string from_decimal(unsigned int num, int to_base);
+std::string from_decimal(int num, int to_base);
 
 /* Convert the given value from 'from_base', to 'to_base' */
 std::string base_convert(std::string num, int from_base, int to_base);

includes/serialization.h

@@ -6,19 +6,17 @@ 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; // X-coordinate of sending paddle
+	uint16_t pad_x;
-	uint16_t pad_y; // Y-coordinate of sending paddle
+	uint16_t pad_y;
-	uint16_t ball_x; // X-coordinate of ball (only the server fills this in)
+	uint16_t ball_x;
-	uint16_t ball_y; // Y-coordinate of ball (only the server fills this in)
+	uint16_t ball_y;
-	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, bool should_quit);
+Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y);
 
 /* Serialize a struct into a byte array, that can be sent through a socket */
 uint8_t* Serial_serialize(Serial_Data data);

includes/sock.hpp

@@ -2,7 +2,7 @@
 #define _SOCK_CLASS
 
 #include <string>
-#ifdef __unix__
+#ifdef linux
 	#include <sys/socket.h>
 #endif
 #ifdef _WIN32

main.cpp

@@ -211,7 +211,7 @@ int main(int argc, char** argv) {
 	SetTraceLogLevel(LOG_NONE);
 	raylib::Window window = raylib::Window(WIDTH, HEIGHT, "Pong");
 	window.ClearBackground(BLACK);
-	SetTargetFPS(60);
+	SetTargetFPS(10);
 	SetExitKey(KEY_Q);
 	std::string points_str = std::string("0\t\t0");
 	bool game_started = false;
@@ -264,35 +264,33 @@ 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.
+				/* 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.*/
-				 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);
-				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, false);
+				to_send_data = Serial_create_data(pad1.getRect().x, pad1.getRect().y, 0, 0);
 			}
 			/* 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;
 				}
+
 			}
 			
-			/* Check to see if peer has quit the game */
+			/* When updating the paddle positions, update the peer paddle's positions based on the vector set earlier */
-			if (response_data.should_quit == true) {
+
-				std::cout << "Peer unexpectedly quit game." << std::endl;
+			std::string to_send = "";
-				break; // Break out of main game loop
+			/* Update paddle velocity */
-			}
 
 			/* 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
@@ -329,8 +327,7 @@ int main(int argc, char** argv) {
 				pad2.velocity.y = 0;
 			}
 
-			/* Why did I use 'type.mode != M_CLIENT'? - The client should set the ball position solely based
+			/* 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. */
-			 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 */
@@ -369,8 +366,7 @@ int main(int argc, char** argv) {
 				ball.vel.y = ball.vel.y * -1;
 			}
 
-			/* Update positions based on velocities - Client only updates pad1 (and receives data for pad2), 
+			/* Update positions based on velocities - Client only updates pad1, server updates pad2 and ball */
-			server updates pad2 and ball (and receives data for pad1) */
 			if (type.mode != M_CLIENT) {
 				ball.updatePosition();
 				pad2.updatePosition();
@@ -395,14 +391,8 @@ int main(int argc, char** argv) {
 		window.EndDrawing();
 	}
 
-	/* If the game has been quit, ask the peer to quit as well */
-	if (type.mode != M_SINGLE) {
-		to_send_data = Serial_create_data(0, 0, 0, 0, true);
-		type.netsock->sendAll((char *)Serial_serialize(to_send_data), sizeof(Serial_Data) + 1);
-		sock_quit();
-	}
-	
 	window.Close();
+	sock_quit();
 
 	return 0;
 }

meson.build

@@ -1,36 +1,11 @@
-project('Pong', ['cpp', 'c'], version: '0.1')
+project('Pong', ['cpp', 'c'])
-add_global_arguments('-g', '-Wall', '-pedantic', '-Wno-unused-function', language : ['cpp', 'c'])
+add_global_arguments('-g', '-Wall', '-pedantic', '-Wno-unused-function', '-Werror', language : ['cpp', 'c'])
-compiler = meson.get_compiler('cpp')
-cmake = import('cmake')
 
-if get_option('default_library') == 'shared'
+raylib = dependency('raylib', native: true)
-	raylib = dependency('raylib', required: false) # Try to find dependency with pkg-config
+static_lib_path = ''
-	if not raylib.found()
-		raylib = compiler.find_library('raylib', has_headers: ['raylib.h', 'raymath.h'], required: true) # Try to manually search for the dependency
-	endif
-#	if not raylib.found()
-#		opt_var = cmake.subproject_options()
-#		opt_var.add_cmake_defines({'BUILD_SHARED_LIBS' : true})
-#		opt_var.add_cmake_defines({'CMAKE_SKIP_RPATH' : true})
-#		raylib_proj = cmake.subproject('raylib', options: opt_var)
-#		raylib = raylib_proj.dependency('raylib')
-#	endif
-endif
-if get_option('default_library') == 'static'
-	raylib_proj = cmake.subproject('raylib')
-	raylib = raylib_proj.dependency('raylib')
-endif
-
-#For Windows only
-	ws2_dep = compiler.find_library('ws2_32', required: false)
-	winmm = compiler.find_library('winmm', required: false)
-if build_machine.system() == 'windows'
-	add_global_arguments('-Wl,--subsystem,windows', '-mwindows', language: ['cpp', 'c']) # Prevent opening console when game is run
-
-endif
 
 executable('pong', 
 	'main.cpp', 'easysock.cpp', 'sock.cpp','paddle.cpp', 'ball.cpp', 'numeric_base.cpp', 'connect_code.cpp', 'server.cpp', 'client.cpp',
 	'serialization.c',
-	dependencies: [raylib, ws2_dep, winmm]
+	dependencies: raylib,
 )

numeric_base.cpp

@@ -5,10 +5,10 @@
 
 std::string possible_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-unsigned int to_decimal(std::string num, int from_base) {
+int to_decimal(std::string num, int from_base) {
 	char current_char = 0;
 	int index = 0;
-	unsigned int value = 0;
+	int value = 0;
 
 	/* Here, we convert 'num' to decimal (base 10) - Find the index of
 	every character in the string, in 'possible_chars' and
@@ -23,7 +23,7 @@ unsigned int to_decimal(std::string num, int from_base) {
 }
 
 /* Convert the given value from base 10 to the given base */
-std::string from_decimal(unsigned int num, int to_base) {
+std::string from_decimal(int num, int to_base) {
 	std::string return_val;
 	int val = 0;
 	while (num > 0) {
@@ -40,7 +40,7 @@ std::string from_decimal(unsigned int num, int to_base) {
 
 /* Convert the given value from 'from_base', to 'to_base' */
 std::string base_convert(std::string num, int from_base, int to_base) {
-	unsigned int temp = to_decimal(num, from_base);
+	int temp = to_decimal(num, from_base);
 	std::string result = from_decimal(temp, to_base);
 
 	return result;

serialization.c

@@ -1,8 +1,7 @@
 #include <stdint.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
-#ifdef __unix__
+#ifdef linux
 	#include <arpa/inet.h>
 #endif
 #ifdef _WIN32
@@ -12,32 +11,29 @@
 
 
 /* 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, bool should_quit) {
+Serial_Data Serial_create_data(float pad_x, float pad_y, float ball_x, float ball_y) {
 	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(sizeof(Serial_Data) + 1);
+	uint8_t* serialized = malloc(4 * sizeof(uint16_t) + 1);
 	uint8_t* pad_x_ptr;
 	uint8_t* pad_y_ptr;
 	uint8_t* ball_x_ptr;
 	uint8_t* ball_y_ptr;
-	uint8_t* should_quit_ptr;
+	memset(serialized, 0, 4 * sizeof(uint16_t) + 1); // Zero out the memory
-	
-	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));
@@ -50,9 +46,7 @@ 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;
 }
@@ -65,7 +59,6 @@ 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);
@@ -80,8 +73,6 @@ 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;
 }
 

server.cpp

@@ -1,4 +1,4 @@
-#ifdef __unix__
+#ifdef linux
 	#include <sys/socket.h>
 #endif
 #ifdef _WIN32