Video games are a great example of complex programming. Even games as simple asAsteroidsorPac-Mancontain many different elements that must work seamlessly together. As a result, video game programmers spend countless hours coding, testing, and debugging before the public can enjoy their games.

In this Assignment, you recreate a very old, simple computer game calledHammurabi. Before Java existed,Hammurabiwas written in BASIC. Your task is to writeHammurabias a well-structured Java program using a Scanner object to handle input.

Here are the standard instructions for the game:

Congratulations, you are the newest ruler of ancient Samaria, elected for a 10 year term of office. Your duties are to dispense food, direct farming, and buy and sell land as needed to support your people. Watch out for rat infestations and the plague! Grain is the general currency, measured in bushels. The following will help you in your decisions:

• Each person needs at least 20 bushels of grain per year to survive
• Each person can farm at most 10 acres of land
• It takes 2 bushels of grain to farm an acre of land
• The market price for land fluctuates yearly

Rule wisely and you will be showered with appreciation at the end of your term. Rule poorly and you will be kicked out of office!

Define a single class named Hammurabi. Use the following skeleton:

Note:As you know, comments do not affect the program. Therefore, you may either leave the comments in your code or delete them.

/**

*/ public class Hammurabi { //save in a file namedHammurabi.java

Random rand = new Random();

Scanner scanner = new Scanner(System.in);

public static void main(String[] args) { new Hammurabi().playGame();

}

void playGame() {

//define local variables here: grain, population, etc.

// statements go after the declarations

}

//other methods go here

}

Start the game with the following:

• 100 people
• 2800 bushels of grain in storage
• 1000 acres of land
• Land value is 19 bushels/acre

Each year, print out a summary following this format:

O great Hammurabi!

You are in year 1 of your ten year rule.

In the previous year 0 people starved to death.

In the previous year 5 people entered the kingdom.

The population is now 100. We harvested 3000 bushels at 3 bushels per acre.

Rats destroyed 200 bushels, leaving 2800 bushels in storage.

The city owns 1000 acres of land.

Land is currently worth 19 bushels per acre.|

This summary represents the initial state, at thebeginningof the first yearthat is, when the player first takes office and before the program does any of the computations below. For example, the previous year (under a different ruler) started with 95 people; none starved, and five entered the kingdom. So as the player enters office, he/she rules 100 people.

Write a playGame method that calls the following methods each year, for up to 10 years. Each method asks the player one question. Call the methods in the order given, and do not allow the player to back up and change previous answers. Your playGame method must read in all input from the player as strings. You must parse through the strings and determine if the input is valid. Return a value from the method based on the players input, as specified below:

int askHowManyAcresToBuy(int price, int bushels)

Ask the player how many acres of land to buy, and return that number. The player must have enough grain to pay for the purchase.

int askHowManyAcresToSell(int acresOwned)

Ask the player how many acres of land to sell, and return that number. The player cannot sell more land than he/she has. Do not ask this question if the player is buying land; it does not make sense to do both in one turn.

int askHowMuchGrainToFeedPeople(int bushels)

Ask the player how much grain to feed the people, and return that number. The player cannot feed people more grain than he/she has. The playercanfeed people more than they need to survive, but it does not benefit the player.

int askHowManyAcresToPlant(int acresOwned, int population, int bushels)

Ask the player how many acres to plant with grain, and return that number. The player must have enough acres, enough grain, and enough people to do the planting. Any grain left over goes into storage for next year.

For each question, write code that checks the players input. This is known as sanity checking. For example, the program should make sure the player has enough grain, enough people to do the planting, etc. If the player enters an invalid

value, have the program print a message such as, O Great Hammurabi, surely you jest! We have only 3415 bushels left! Have the program keep asking until the player enters an allowable value.

After the above methods are called, the playGame method determines the following, in this order:

2. Is there a plague, and if so, how many people die from it.
4. How many people starve.
6. How many people come to the city.
8. How good the harvest is.
10. Is there a problem with rats, and if so, how much grain they eat.
12. The price of land for the following year.

Keep the above information in local variables in your playGame method. Then use that information to call the following methods, in the specified order, to make the necessary calculations. Use TDDTest-Driven Developmentto test as you go.

int plagueDeaths(int population)

Each year, there is a 15% chance of a horrible plague. When this happens, half of the players people die. Return the number of plague deaths (possibly zero). If a plague happens, print a separate line in the summary to notify the player of the number of plague deaths.

int starvationDeaths(int population, int bushelsFedToPeople)

Each person needs 20 bushels of grain to survive. If the player feeds them more than this, the people are happy, but the grain is still gone. The player does not get any benefit from having happy subjects. Return the number of deaths from starvation (possibly zero).

boolean uprising(int population, int howManyPeopleStarved)

Return true if more than 45% of the people starve. This causes the player to be immediately thrown out of office, ending the game.

int immigrants(int population, int acresOwned, int grainInStorage)

Nobody comes to the city if people are starving (so do not call this method if starvationDeaths is greater than 0). If everyone is well fed, compute how many people come to the city as: (20 *number of acres you have+amount of grain you have in storage) / (100 *population) + 1.

int harvest(int acres)

Choose a random integer between one and six, inclusive. Each acre planted with seed yields this many bushels of grain. For example, if the player plants 50 acres, and the random integer is three, the player harvests 150 bushels of grain. Return the number of bushels harvested.

int grainEatenByRats(int bushels)

Each year, there is a 40% chance of a rat infestation. When this happens, rats eat somewhere between 10% and 30% of the players grain. Return the amount of grain eaten by rats (possibly zero).

int newCostOfLand()

The price of land is random, and ranges from 17 to 23 bushels per acre. Return the new price for the next set of decisions the player has to make. The player needs this information in order to buy or sell land.

Do these computations,in this order,for each of the years that the player holds office, for up to ten years. Perform each computation in a separate method; none of these methods read or print anything unless the user enters an invalid value.

When the computations for the current year are finished, call a method printSummary to print the summary of the current status of the kingdom at the beginning of the next year. This method requires several parameters and its output will be similar to the sample output summary listed at the beginning of this assignment.

When the game ends, use a method finalSummary to print out a summary of the final year of the players rule. This summary prints the same information as the printSummary method, but also includes an overall evaluation of the players rule based on several of the variables in the program. You must decide which variables to include in the evaluation and how to compute the evaluation.

Note that your playGame method is quite long, but very straightforward; it does very little but call other methods.

Students often wonder how to test a method that returns a random result. The answer isthe same way you test any methodcall it and examine the results. For a method that uses random numbers, call it many times and determine if the average result of the method is consistent with your expectations.

For example: If you call plagueDeaths with 1,000 people, 15% of the time it will return

500, and the other 85% of the time it will return zero. The expected result is

0.15*500 + 0.85*0 = 75, so if you call the method 1000 times and add the results, you should get a total close to 75,000. You could then say:

assertTrue(65000

This is not a perfect test, but it is certainly better than no test at all.

Include screenshots of your program running as part of your submission. Show each action being performed and the summary for each year. Also show attempts to enter invalid values. Perform one play-through of the game that results in a successful tenyear rule, and one that results in the people uprising and overthrowing the player. Show screenshots of your program being tested with JUnit.