Answer the following in Java:

Write a simple a fight simulator. Information about the simulation will take the form of text descriptions of the attacks and defenses (more on this later).

Your program will have two opponents: an attacker (that only launches attacks) and a defender (that can only defend against the attacks). There's three types of attacks categorized by height: high, medium and low. Typically you should use class constants for unchanging values (i.e., public final static int HIGH = 1;) but this requirement is waived for you, constants that are local to a particular method may be used instead).

Similar to the attacks, there's three types of defenses: high, medium and low. If the height of an attack and a defense match then the attack is blocked. Otherwise the attack is counted as a 'hit'. The simulation runs a fixed number of attack-defenses sequences (from 1 - 100 'rounds' of attacks and defenses). The user will determine the number of rounds when the simulation first runs. If a value outside the range is entered then the default number of rounds (ten) will be executed (no re-querying for a new value needed).

Attacker control: The basic version of the program will have an attacker which has an equal probability at attacking at the three heights - you can use integer rather than real number distributions for determining the probabilities. That is, you can call the 'nextInt' method instead of the 'nextFloat' method of class Random. The advanced version will allow user input to specify the probabilities: When the program first runs, the user can also determine the proportion of attacks that originate at the three different heights (e.g., high = 50%, medium = 30%, low = 20%). These three proportions must sum to 100% otherwise the program will use the defaults (again there's an equal probability of each type of attack). Hint: you don't need to use percentages to have an even three way split between the 3 heights (image if you were able simulate the rolling of a 9 sided dice with a Java program...).

Defender control: The defender will be entirely controlled by the computer. The 'unskilled' defender has an equal chance of employing one of the three types of defenses. A program that implements an 'intelligent' defender will analyze the pattern of attacks and adjust the probability of each type of defense being employed over time. (For example if the attacker always throws high attacks then the defender will eventually extrapolate the pattern and use high defenses more frequently). It is up to you to decide how many rounds are needed before the defender begins to adjust to the pattern of attacks. And the value determining the adjustment period can be hard-coded (fixed) into the program (no user input needed at run-time). The minimum number of rounds needed to adapt should be one (with zero attacks thrown there is no pattern to analyze). Prior to analyzing and determining the pattern of attacks the defender should have an equal probability of employing each type of defense.

Exactly what constitutes 'intelligent' for this assignment? Because this isn't a formal class in Artificial Intelligence the definition is fairly broad: as long the program demonstrates the ability to somehow adapt to the pattern of attackers and the marker can clearly see the pattern as the program executes (the display of statistics each round will be very useful for communicating this). If for instance the attacker throws only medium attacks, after the learning period is over the defender should eventually employ only medium height defenses (or at least have an extremely high probability of employing this type of defense).

You can either come up with your own algorithm for the defender or you can freely research algorithms online. In the latter case make sure you clearly cite all your sources.

The program will tally a number of statistics and display them during each round *and* at the end of the simulation. Here's the information that your program MUST display.

Statistics displayed each round: the round number, the type of attack and defense chosen, the result of the attack-defense combination (hit or block).

Statistics displayed when the program ends: the total number of successful attacks and blocks and the probabilities of each type of attack-defense at the end (the values for the attacker won't change but an intelligent defender's proportions should go from equal values to more closely reflect the proportions of the attacker).

These outputs must not only present the needed information but must also be reasonably formatted. Real number values must display with two places of precision. The program output is even more crucial when you have implemented an intelligent defender. You must be able to see the effects of the defender adapting to the pattern of attacks. Make things explicit in your output.

Program design [Click here for overview]: the program will consist of 3 Java source code files (Attacker, Defender, Manager). Each class definition must be in it's own file with the file name matching the class name.

• The 'Manager' is not just the start or the 'driver' of the program (contains the 'main()' method) but as the name implies it also acts as an intermediary between the other two classes (e.g., communicates to the defender the type of attack generated by the attacker). The other two classes can send messages (invoke methods) to each other if necessary.

• The 'Attacker' will be responsible for generating attacks so it should track all information associated with attacking (e.g., numbers of each attack type generated).

• Likewise the 'Defender' will receive the attack generated by the attacker, generate a defense and determine the result of the attack-defense combination. Also the defender should track information associated with defense (e.g., the numbers of each type of defense used). Since the information for the attacks and defenses must be tracked by this class the methods for displaying the round-by-round report and the end of simulation report should be displayed here.

Manager module: 'Manager.java' Pass the attack info to... Attacker module: cker.java' . Characteristics: Contains the starting 'main' function Creates instances of the attacker and defender Gets information about the simulation from the user (e.g., number of rounds etc.) Runs the main loop (runs a 'round' of kombat) Defender module: 'Defender.java' . Communicate attack type Generate attack type: high/ medium/low, Generate defense type and determine result of attack, generate reports Alternate: communicate attack type directly Sound effects courtesy of: Fox "The Simpson" FTL "Dungeon Master Manager module: 'Manager.java' Pass the attack info to... Attacker module: cker.java' . Characteristics: Contains the starting 'main' function Creates instances of the attacker and defender Gets information about the simulation from the user (e.g., number of rounds etc.) Runs the main loop (runs a 'round' of kombat) Defender module: 'Defender.java' . Communicate attack type Generate attack type: high/ medium/low, Generate defense type and determine result of attack, generate reports Alternate: communicate attack type directly Sound effects courtesy of: Fox "The Simpson" FTL "Dungeon Master