代写INFO-5060 WordleTM Game 2024代做R语言

日期：2024-03-25 03:12

Program:	CPA3-5
Course:	INFO-5060
Project:	WordleTM Game
Due Date:	Thursday, March 28, 2024  (by 11:59 pm)
Last Update:	March 4, 2024

Description

You will create a version of the game Wordle^TM involving a pair of gRPC services and console or GUI client. All components must be implemented using C#. You’ll also submit a video demonstration of it!

Purpose

On completing this project, you should be able to:

1. Develop a basic gRPC service.

2. Develop a gRPC service that:

a. Incorporates a bidirectional stream.

b. Operates as both a service and a client.

3. Develop a client application which consumes a gRPC service.

4. Configure/deploy a multiply-assembly application involving the above components.

Background

Wordle^TM is a popular, single-player word-guessing game made famous by the New York Times. If you aren’t familiar with it, here is a link to the game. Our version will also be a single-player game, but the user will receive statistics at the end of the game which will inform. them how well they did compared to other users.

Functional Requirements

Your overall submission will implement the game of Wordle^TM. The following game description includes illustrations which mimic the official game’s user-interface. However, you aren’t required to exactly mimic this UI. In fact, some sample output has also been provided illustrating a sample console UI.

1. The user is challenged to guess a valid*, five-letter English word (the wordtoguess).

Before the first guess. No letters have yet been entered or revealed.

2. Letters may be revealed after each guess if the user’s guess contains one or more of the letters contained in the wordtoguess. The wordtoguess will be identical for all users using the application on the same calendar day. Each day the game will challenge users with another wordtoguess which is randomly selected.

3. The user will be allowed up to a maximum of six guesses to uncover the wordtoguess. A valid guess consists of a five-letter English word that is contained in the file wordle.json (provided). If a guess does not represent a valid word, it will be rejected, and the guess won’t count as one of the six guesses.

4. For each guess, any letters in the guessed word that also appear in the wordtoguess will be flagged in one of two ways. If a letter in the user’s guess matches a letter in the wordtoguess and is in the correct position, it will be identified in one way (shown below on a green background). Whereas if a letter in the guess is also in the wordtoguess but is not in the correct position it will be identified differently (shown below on a yellow background).

5. The UI will also inform. the user of which letters of the alphabet have been guessed incorrectly, which have been guessed correctly, which have not been used yet in any guesses.

C

L

O

U

D

Guess #1: O is in the word and is in the right position. C, L, U, D are not in the word.

 

P

H

O

T

O

Guess #2: P, O(x2) are in the word. Only 1st O is in the right position. H, T are wrong.

 

S

W

O

O

P

Guess #3: S and both O’s are in position. P is in the wrong position. W is wrong.

 

S

P

O

O

F

Guess #4: S, P and both O’s are correct and in position. F is not in the word.

 

S

P

O

O

N

Guess #5: Guessed the word.

6. At the end of the game, it will state whether the user has won or lost. It will also show some statistics for all users who have played today’s game, including:

a. The number of users/players who have played today’s game.

b. The percent of players who have won the game.

c. A distribution of how many guesses (from 1 to 6) it took users to guess the word.

7. When the local time passes midnight, the user-statistics must reset, and the word-to-guess must be changed.

8. For this simplified version, if a user attempts to replay the game on the same day they should been treated like a different user and should be allowed to play.

9. The application must support concurrent users/players.

Here is some sample output that illustrates similar functionality using a monochromatic console UI. The user-inputs have been highlighted in yellow text.

+-------------------+

|   W O R D L E D   |

+-------------------+

 

You have 6 chances to guess a 5-letter word.

Each guess must be a 'playable' 5 letter word.

After a guess the game will display a series of

characters to show you how good your guess was.

x - means the letter above is not in the word.

? - means the letter should be in another spot.

* - means the letter is correct in this spot.

 

     Available: a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z

 

(1): cloud

     xx*xx

 

     Included:  o

     Available: a,b,e,f,g,h,i,j,k,m,n,p,q,r,s,t,v,w,x,y,z

     Excluded:  c,d,l,u

 

(2): photo

     ?x*x?

 

     Included:  o,p

     Available: a,b,e,f,g,i,j,k,m,n,q,r,s,v,w,x,y,z

     Excluded:  c,d,h,l,t,u

 

(3): swoop

     *x**?

 

     Included:  o,p,s

     Available: a,b,e,f,g,i,j,k,m,n,q,r,v,x,y,z

     Excluded:  c,d,h,l,t,u,w

 

(4): spoof

     ****x

 

     Included:  o,p,s

     Available: a,b,e,g,i,j,k,m,n,q,r,v,x,y,z

     Excluded:  c,d,f,h,l,t,u,w

 

(5): spoon

     *****

 

You win!

 

Statistics

----------

 

Players:    4

Winners:    75%

Guess Distribution...

 1: 0

 2: 2

 3: 1

 4: 0

 5: 0

 6: 0

Non-Functional Requirements

The system will consist of three executable C# applications targeting .NET 7.0. The identifiers used here are for explanatory purposes. You may rename any application, service, or RPC to suit you. The RPCs may also accept or return additional fields. You may not include additional RPCs.

1. WordServer

a. A supporting gRPC service application which exposes a gRPC service called DailyWord with the following RPCs:

i. GetWord

1. Returns a 5-letter English word from the file wordle.json. 

2. Returns the same 5-letter word anytime it is invoked during the same calendar day.

3. Returns different 5-letter words if invoked on two consecutive calendar days.

ii. ValidateWord

1. Returns a Boolean value of true if the word argument passed-in matches a word in the file wordle.json.

b. This is the only application that will have access to the file wordle.json.

2. WordleGameServer

a. A main gRPC service which implements most of the game rules and exposes a gRPC service called DailyWordle.

b. This server will communicate with the WordServer’s DailyWord service to:

i. Obtain the daily word-to-guess using the GetWord RPC.

ii. Validate each guess submitted by the user using the ValidateWord RPC.

c. This server exposes a gRPC service called DailyWordle with the following RPCs:

i. Play

1. Uses a bidirectional stream to run a complete game of Wordle^TM.

2. The stream will repeatedly accept word guesses from the client until the correct word has been provided or the client has submitted 6 guesses, whichever occurs first.

3. The RPC will return a response to the client for each word played which will indicate whether the guess was correct, whether the game is over and detailed information about which letters of the guess are in the correct position, which letters of the guess are included in the word but are not in the correct position. which letters are incorrect (not in the word-to-guess) and which letters have not yet been used in any guess.

4. When the RPC stream is finishing it will update game statistics for all users in a file (any file format you chose) which will include the number of players that have played the current word, the number of players that guessed the word correctly and the distribution of guesses used by the players who guessed the word correctly (how many players guessed it in one guess, how many guessed it in two guesses, etc.). You should handle any deadlock (e.g. by using a Mutex object) that could occur when two game streams attempt to update the file concurrently.

5. It’s up to you how you handle the rollover from one day to the next. There are some tricky issues here such as what happens if a player starts a game before midnight but finishes the game after midnight. Just know that your game won’t be evaluated this way. However, the word-to-guess should rollover from one day to the next and the user-statistics should also reset.

ii. GetStats

1. Returns all the stored user-statistics for the current daily word as shown at the end of the sample console output.

3. WordleGameClient

a. A console or GUI client

b. Connects to the WordleGameServer’s DailyWordle.service to:

i. Play the daily word game via the Play (bidirectional stream) RPC.

ii. Retrieve and display user-statistics at the end of the game via the GetStats RPC.

Tips and Suggestions

1. Here is a basic algorithm to play Wordle^TM. It doesn’t validate each word-played to ensure it’s a valid word (i.e. that the word is in the file wordle.json). It doesn’t track which letters of the alphabet have been guessed correctly (included) or guessed incorrectly (excluded) or have not been tried yet (available). It doesn’t process the users’ statistics. Nor is an algorithm provided for the countFrequency() function. You’ll need to add these elements yourself. Note that resultsarray in the algorithm uses * to indicate a correct letter in the correct position, ? to indicate a correct letter in the wrong position and x to indicate a letter that doesn’t occur in the word-to-guess.

turns-used = 0

game-won = false

ARRAY results[5]

WHILE NOT game-won AND there is another word-played AND turns-used < 6 DO

turns-used = turns-used + 1

IF word-played = word-to-guess THEN

game-won = true

FOR each index in results

results[index] = ‘*’

END FOR

ELSE

DICTIONARY matches = {‘a’: 0, ‘b’: 0, ‘c’: 0, ‘d’: 0, ‘e’: 0, ‘f’: 0, ‘g’: 0, ‘h’: 0, ‘I’: 0,’ ‘j’: 0, ‘l’: 0, ‘m’: 0, ‘n’: 0, ‘o’: 0, ‘p’: 0, ‘q’: 0,
‘r’: 0, ‘s’: 0, ‘t’: 0, ‘u’: 0, ‘v’: 0, ‘w’: 0, ‘x’: 0, ‘y’: 0, ‘z’: 0} 

# Search word-played for letters that are in the correct position

FOR each index in word-played

letter = word-played[index]

IF letter = word-to-guess[index] THEN

results[index] = ‘*’  

matches[letter] = matches[letter] + 1

END IF

END FOR

# Search word-played for additional correct letters that are not in
# the correct position

FOR each index in word-played

letter = word-played[index]

IF countFrequency(word-to-guess, letter) = 0 THEN

results[index] = ‘x’

ELSE IF letter != word-to-guess[index] THEN

IF matches[letter] < countFrequency(word-to-guess, letter) THEN

results[index] = ‘?’

matches[letter] = matches[letter] + 1

END IF

END IF

END FOR

END IF

END WHILE

2. You may want to create a separate client application to test your WordServer separately before you integrate it into the rest of the combined application. This additional client should not be submitted with your project.

Grading Scheme

1. The School of I.T. Policy on Missed Evaluations and Evaluation Deadlines applies to this project.

2. Projects submitted by the submission deadline will be evaluated as follows:

Description	Marks
Video Demo submitted addressing all required elements (See the next section Demonstrations & Submissions for information).	4
Project submission includes both required gRPC service applications and a client application. All three projects are implemented in C# and target .NET 7.	2
WordServer:
· Implements one RPC to return a word from the file wordle.json.	2
· Implements a second RPC to validate a word, verifying that the word is contained in wordle.json.	1
WordleGameServer:
· Implements one RPC call which uses a bidirectional service stream to play an entire game, accepting and providing feedback on no more than six valid guesses (i.e. 5-letter words) from the client. This RPC uses the WordServer to validate each guess. It also updates the user-statistics file at the end of the game.	3
· Implements a second RPC call to provide current user-statistics to the client.	1
· Uses WordServer to obtain the word-to-guess and to validate user guesses	2
The Client:
· Uses the two WordleGameServer RPCs and appropriate UI functionality to allow the user to play the game. Does not use the WordServer directly and does not access any other data sources directly such as wordle.json	2
The combined application:
· Allows the user to play a game of WordleTM. · Uses the same word-to-guess throughout a day and different words on consecutive days. · Reports correct user-statistics at the end of each game which are based only on games played during the current day.	1 1   1
Deduction for not complying with the project group requirement.	20%
Maximum deduction for poor coding style. (unclear and inconsistent or undescriptive naming of code elements, poor code alignment, missing and/or  inadequate inline and header comments)	-2
Maximum deduction for an incomplete submission (missing source code or required VS project files)	-100%
Maximum Total	20

Demonstrations & Submission

Project Demonstration (by recorded video):

You must demonstrate your project via a short, recorded video that you will submit with your project code. A link to a video is preferred to a file! Your video demonstration must not be edited. This means you must do it in one continuous recording. It must show the following elements:

1. Load the client application and try to use it, which should show that the game is not playable without the WordleGameService running.

2. Load the WordleGameService and again try to use the client, which should show that the game is still not playable without the WordService running.

3. Now make sure all three applications are running.

4. Play two consecutive games, showing all of the following elements:

a. The same word-to-guess is used on the same day.

b. A user-input that is not five characters in length is correctly handled as an invalid input.

c. A user-input that is not a proper word that will be validated by the WordServer (like “aaaaa”) is handled correctly and does not count as a guess.

d. The user-statistics at the end of each game as displayed by the UI.

e. The user-statistics at the end of each game as stored in the data file maintained by the WordleGameService.

5. Move your computer’s system date forward to the next day, showing this clearly in the video, and play a third game. This should demonstrate that a different word-to-guess is used and that the user-statistics have been reset.

Submission:

Submit one archive file (zip, rar or 7z file) containing your complete Visual Studio solution(s) with all your source code. I should only have to rebuild your project before testing without changing any project settings or source code.

If working with other students, only one of you needs to submit your solution. However, you will all be responsible for ensuring you submit it on time.

Submit your project on time!

A deduction will apply to late submissions as follows:

· A penalty of 20% will be deducted if your submission is received < 24 hours late.

· Your project will receive a mark of 0 (zero) if it is more than 24 hours late.