Assignment Rock Paper Scissors
This problem will be a fun application of interfaces. It revolves around the game of Rocks, Paper, Scissors (also known in some parts of the world as RoShamBo). For those of you who are not familiar with the game, it is played between two people who we will refer to as A and B. Person A makes a selection of either rock, scissor, or paper with person B being unaware of what A will choose. Similarly, person B will make a selection of either rock, scissor, or paper with person A being unaware of what B will choose. Then, based on the selection of each, a winner is decided based on the following selection matrix:
|
|
B selects ROCK
|
B selects PAPER
|
B selects SCISSOR
|
|
A selects ROCK
|
TIE
|
B WINS
|
A WINS
|
|
A selects PAPER
|
A WINS
|
TIE
|
B WINS
|
|
A selects SCISSOR
|
B WINS
|
A WINS
|
TIE
|
This can be summarized as "rocks beat scissors" (since a rock can break a pair of scissors), "scissors beat paper" (since scissors can cut paper), and "paper beats rock" (since paper can cover a rock). Typically, the game is repeated many times so that players can exploit patterns in their opponents' playing styles in order to accumulate more wins.
In this exercise, you will be implementing your own strategy for playing this game. Then, I will take every student's strategy and implement a tournament to evaluate which strategy is best. THE TOURNAMENT WILL JUST BE FOR FUN AND THE OUTCOME WILL NOT AFFECT YOUR GRADE ON THIS ASSIGNMENT.
1. Consider the following interface:
importjava.util.ArrayList;
public interface RPS_Player {
/**
* integer constant representing the selection rock
*/
static final int ROCK = 0;
/**
* integer constant representing the selection scissor
*/
static final int PAPER = 1;
/**
* integer constant representing the selection paper
*/
static final int SCISSOR = 2;
/**
* method that utilizes an arraylist of an opponent's previous choices to
* make a selection of whether to play rock, scissor, or paper next.
* @paramprev an arraylist of previous selections made by the opponent
* @return the integer RSP_Player.ROCK, RSP_Player.SCISSOR, or
* RSP_Player.PAPER
*/
intmakeSelection(ArrayListprev);
/**
* method that returns name of the student who provided the
* implementation
* @return student's name as a string
*/
String getStudentName();
}
Write a class RPS_YOUR_FULL_NAME (e.g., RPS_TONY_WILLS) that implements the above interface. In the makeSelection method, you should provide an implementation of a strategy for playing this game. A simple, yet unexploitable, strategy would be to return rock, paper, or scissor (as an integer) completely at random. However, this strategy will not generally be a winning strategy since you will tie on average. The only way to consistently win is to take advantage of predictabilities/patterns in your opponent's previous selections (which will be given to you as an integer array list). An example of a more sophisticated strategy might be one that keeps count of how many times the opponent makes each choice and then makes the selection which beats the most occurring choice (i.e., if your opponent selects rock 60% of the time, your best selection might be paper). Your class should also include a default constructor that takes no parameters. I will be using this constructor to instantiate your strategy in the tournament.
ADDED CONSTRAINT: YOU ARE NOT ALLOWED TO IMPLEMENT THE RANDOM CHOICE STRATEGY AS IT IS TOO SIMPLE. I AM REQUIRING THAT YOU SOMEHOW USE YOUR OPPONENT'S PREVIOUS MOVES IN YOUR STRATEGY, I.E. DON'T IGNORE THE ARRAYLIST prev.
Your class may add additional functionalities as you see fit. One recommendation would be to add an instance field my_prev, which will keep track of your previous selections. Each match between classes will consist of 1,000 repetitions of the game. The lifetime of your RPS_Player object will be the entire duration of these 1,000 repetitions, so you will be able to keep a history of your selections should you choose to do so.
You are all very intelligent and I'm excited to see the strategies that you will come up with!
As a side note, a copy of this interface will be posted under Doc Sharing. Students are expected to adhere to this interface for credit. If I cannot create an instance of your class using the statement
RPS_Player strategy = new RPS_YOUR_FULL_NAME();
Then you will not receive credit on this assignment.
2. In this exercise, you will write a class that contains a method to simulate Ntrial (a constant defined in your class, default = 1,000) repetitions of the game between two RPS_Player objects. This method should return the difference between the number of repetitions that the first player won and the number of repetitions that the second player won. Write a main function that constructs two RPS_Player objects and runs a match of 10,000 repetitions between them.
3. Prepare a UML class diagram that shows the relationships between the classes that you have created in this homework and the two interfaces that they implement.
Submission: Please submit only java source files, word documents, and or pdf files into the appropriate dropbox. Do not place these files into any kind of container (i.e. no zip or rar files).
Tournament Method: I will be writing my own class similar to the one that you will write in problem 2. Then I will implement a round-robin style tournament in which every possible pair of student strategies will face off against each other for 1000 repetitions. Each student will receive 1 point for every win, 0 points for every tie, and -1 point for every loss. The student with the highest score will be deemed to have the best strategy.
I will be creating my own strategy and competing with you (just for fun, of course). I will also be adding some benchmark strategies including (1) a completely random strategy with all choices being equal, (2) a random strategy in which no two consecutive selections can be the same (which is very exploitable), and (3) a trivial strategy that always selects "rock."
