INFO-5060代做、代写C++程序语言

项目预算：开发周期：发布时间：要求地区：

Program: CPA3-5
Course: INFO-5060
Professor: Tony Haworth
Project: WordleTM Game
Due Date: Thursday, March 28, 2024 (by 11:59 pm)
Last Update: March 4, 2024
To be completed in a group of two or three students.
You may work with students in another section of the course.
BE SURE TO CREDIT ALL STUDENTS in the submission & comments!
Description
You will create a version of the game WordleTM 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
WordleTM 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 WordleTM. 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 WordleTM.
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 WordleTM. 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.
Submit your own work and keep it to yourself!
You must not submit code written by another person or obtained from another source such as an AIbased cognitive-offloading tool like ChatGPT. You must not share your code with another student. These activities are academic offenses. If you cheat, you may get a mark of zero. Repeat offenses carry even more severe penalties such as receiving an F grade or being expelled. Submit your own code and benefit academically from having made the effort! Note that students are encouraged to share ideas and to work together on practice exercises since this enhances learning.
Project Corrections
If any corrections or changes are necessary, they will be posted on the course web site, and you will be notified of any changes via FanshaweOnline. It is your responsibility to check the site periodically for changes to the project. Additional resources relating to the project may also be posted.

Acknowledgements
The JSON file provided with this project was downloaded via the following link:
https://gist.github.com/mrhead/f0ced2726394588e8d9863e0568b6473