代做CS3357A、代写Python设计编程

日期：2023-12-08 10:26

CS3357A COMPUTER NETWORKING

Assignment #4: Building a multi-player server-client snake game.

Assignment Purpose

The goal of this assignment is to extend the functionality of the previously developed Snake

game to support three additional features:

1- The server should handle multiple clients/snakes simultaneously. Each client will have its

own snake, enabling a multiplayer environment where multiple snakes share the field.

Each client will receive a game state that includes the position of all snakes to display

them. You can decide colors. Check the “Communication Protocol and Game State”

section for instruction on implementing the multi-player feature.

2- While playing, Clients can send a public message to the server to be broadcasted to all

clients. Check the chatting section for instruction on implementing the public messaging

part.

3- Both the server and the clients encrypt their messages using RSA encryption algorithm.

In the RSA algorithm, each party generates a key pair (public key, private key), where the

private key is kept as a secret at the sender and is used to encrypt the sender messages,

and the public key is publicly shared with the receiver and is used to decrypt the

messages at the receiver side. Check the Encryption section for instruction on

implementing messages and control inputs encryption.

The image below shows the game window that should be displayed on the client side in this

assignment.

Figure 1 A screenshot showing the graphical interface of the snake game on the client side, containing three snakes and 4 snacks.

The screenshot also shows the terminal of one of the three connected clients with messages exchanged between clients.

The server is responsible for:

1. Accepting multiple client connections.

2. Managing the game's logic for all connected clients.

3. Broadcasting the game state to all clients.

4. Receiving and parsing each client's input commands.

5. Applying the received game controls to update the game state.

6. Receive public messages from clients and broadcast them to all clients.

7. Encrypting outgoing public messages.

8. Decrypting incoming controls inputs and public messages.

The snake client is responsible for:

1. Connecting to the server.

2. Sending control inputs to the server.

3. Receive and parse the game state.

4. Displaying the game interface with all the snakes based on the received game state.

5. Send public messages to the server.

6. Receive the public messages broadcasted by the server and display them on the terminal.

7. Encrypts outgoing control inputs and public messages before sending them to the server.

8. Decrypts incoming public messages received from the server.

Assignment Description

Modify the snake_server.py and snake_client.py files of assignment 3 to support handling multiple players,

RSA-based secure communication, and public messaging between clients. Each client will be assigned a

snake where he will be able to control it by sending encrypted control inputs to the server. On the other

hand, the server managesthe game logic including recording snakes and snacks positions; applying control

inputs; and returning the game state.

In the previous assignment (assignment #3), you were given the server side code which is separated into two

files: snake.py and snake_server.py, and you had to implement the client side code. These files will be used

as the starting code for this assignment.

In this assignment, no new files are given, but you are required to use and modify the server/client

code files of the previous assignments to support the new functionalities.

As this assignment builds on previous ones, the following diagrams illustrate the connection between

assignment 2, assignment 3, and assignment 4:

Figure 2 In the chatting application of assignment 2, the server can handle concurrent client connections. A connected client can

send a public message to the server to be broadcasted to all clients. No encryption is used.

Figure 3 In the single-player snake game of assignment 3, the server can accept a connection from a single client. Each cycle, the

client will send a control input, for example “get”, and the server will reply with the game state. Finally, the client uses the game

state to draw the game display. No encryption is applied; the server and client send data as plain text.

Figure 4 In assignment 4, you are required to implement a multi-player snake game. There are few differences between this

version of the game and the version implemented in the previous assignment. First, the server can accept concurrent client

connections. Once a client connects to the server, the server deploys a new snake and assigns it to that user. Second, in addition

to control inputs, clients can send public messages. Third, control inputs and public messages (sent by both the server and

clients) are encrypted using RSA encryption algorithm.

Snake game

The snake game that we will implement in this assignment is similar to the one implemented in the previous

assignment with additional features.

The rules of the game are implemented in the snake.py file which is used by the server script

(snake_server.py).

Game controls

In assignment 3, we implemented seven game controls sent by the client to enable him to control

the snake. Since we are using the code scripts of the previous assignment as a starting code for

this assignment, these seven game controls are still used in this assignment. However, feel free to

change the format of the control messages. For example, instead of sending the get command as

“get”, you can send “control:get” instead. This way the server knows this is a control input and

not a public message that should be broadcasted to all clients.

Chatting

Players will be able to send a message to all other players by sending a message to the server and the server

will broadcast the message to all players. Therefore, in each cycle, the server can receive a control input or a

message from each client. The two conditions apply:

1. A player can only send a public message to all players, he cannotsend a private message to a

particular player. For example, if three players are connected, A, B, and C. Player A can send a

public message to the server and the server will broadcast this message to A, B, and C. Player A

can’t send a private message to player B or C.

2. Instead of having the user type in the message it wants to send to the server, each player should

have a set of predefined messages each associated with a hotkey. When the user presses a hotkey,

the corresponding message should be sent to the server to be broadcasted to all other players. Each

player choosesits unique set of messages. For example, player A can have the following set of

messages: [“Congratulations!”, “It works!”, “Ready?”] assigned to the following keys: [‘z’, ‘x’, ‘c’].

When user A pressesthe key ‘x’, the message “It works!” should be sent to the server. The server

will then broadcast the message to users B and C. Upon receiving player A’s message from the

server, users B and C will display the received message on their terminal. You are required to

implement a client that has a set of three predefined messages each assigned a key.

Encryption

RSA Encryption Workflow

Consider a client k that wants to securely communicate with a server using RSA algorithm. First,

client k must generate its own RSA key pair: (client_k_public_key, client_k_private_key). When

client k connects to the server, it will send its public key to the server. After that, whenever Client

k wants to send a message to the server, it will encrypt the message using its own private key,

and send the encrypted message to the server, the server will then use client_k_public_key to

decrypt the received encrypted message. Similarly, the server will construct its own RSA key

pair: (server_public_key, server_private_key). The server will share its public key with every

client that connects to it. After that, if the server wants to send an encrypted message to client k,

it will encrypt the message using its own private key. Client k will then be able to decrypt the

received message using the server’s public key.

What to encrypt

In this assignment, the server exchanges various types of data with clients. Each cycle, the client

must send a control message and possibly a public message to be broadcasted to all clients. On

the other hand, the server sends the game state and the public messages that it received from any

client to broadcast to other clients. Therefore, the client can send two types of data: control

inputs and public messages, and the server can send two types of data: the game state and public

messages. You are required to encrypt all the exchanged data between the server and client

except the game state which can be sent without encryption. We don’t encrypt the game state

because encryption becomes more expensive (takes a lot of time) as the length of the text to be

encrypted grows.

Communication protocol and game state

In the previous assignment, the exact form of the game state was provided which contains the coordinates of

the snakes and the coordinates of the snacks separated by a “|” character. As this assignment introduces

more features that require adjusting both the server and client scripts, the communication protocol provided

for the previous assignment will not work. For example, in the previous assignment, the server and the client

exchange the control inputs and the game state each cycle. In this assignment, clients can send a public

message to the server to be relayed to the other clients. Therefore, the communication protocol should be

redesigned such that under the new communication protocol, the client can send both types of data (i.e.

control inputs and public messages), and the server can differentiate between both types.

Redesign the game communication protocol. This includes re-formatting of the control inputs and the

game state; and modifying the sequence and contents of exchanged data. Feel free to make any changes in

the client and server scripts of the previous assignment to add the new functionalities (multi-client

connection, public chatting between clients, and message encryption).

Deliverables

Submit four files:

1. snake_server.py: Snake game server-side code which can handle multiple client connections and

public messaging.

2. Snake.py: Helper file for snake_server.py. It contains the functions to handle the game logic.

3. Screenshot.png: Screenshot of the game display showing at least three players (snakes) in the field.

The screenshot should also show the terminal of one of the clients with exchanged messages printed

on the terminal (similar to figure 1).

4. snake_client.py: Snake game client side

Use the snake.py, snake_server.py, and snake_client.py files from the previous assignment as starting

code. Modify these files as you want to implement the features of this assignment.

Rubric

This assignment is out of 50. Marks are distributed as follows:

1. Server can handle multiple client connections concurrently. 5 marks

2. Server manages the game's logic for all clients(the game runs as intended). 10 marks

3. Server receives messages from clients and broadcasts them to all clients. 5 marks

4. Server broadcasts the game state to all clients. 5 marks

5. Server encrypts the public messages it broadcasts to clients. 5 marks

6. Client displays the game with all snakes based on the received game state. 5 marks

7. Client sends movement commands to the server. 5 marks

8. Client sends a message to the server when the user presses the assigned hotkey. 5 marks

9. Client encrypts the control inputs and public messages it sends to the server. 5 marks

Late submission

Late assignments will be accepted for up to two days after the due date, with weekends

counting as a single day; the late penalty is 20% of the available marks per day. Lateness is

based on the time the assignment is submitted.

Extensions will be granted only by your course instructor. If you have serious medical or

compassionate grounds for an extension, you must take supporting documentation to the

Academic Counselling unit of your faculty, who will contact the instructor.

Good luck!