The Philippines has vast minerals that are still untapped. It has one of the world's largest deposits of gold, nickel, copper and chromite. Through responsible mining, we intend to generate more revenues from the extraction of these resources.

— Benigno Aquino III

The mining industry might make wealth and power for a few men and women, but the many would always be smashed and battered beneath its giant treads

— Katharine Susannah Prichard

It goes without saying, but your Crazy Eights game engine was a blockuster hit! People across the globe are uninstalling their triple-A titles just so they can focus on beating your killer strategies! Fiction Interactive has made a name for itself in countless online communities, all thanks to your help. And it seems they're not the only ones taking notice...

An announcement came from the CEO of Fiction Interactive today: the company has been acquired by tech behemoth Minisoft for $26.3 billion! After getting settled in to your new Portland office, you notice an email with your first week project specifications. Recently, Minisoft has been rampantly acquiring IP, and one of the games they picked up was the popular resource-gathering Java game Mine-opoly! Your new manager has personally asked you to improve their rather lackluster single player mode by beefing up its AI strategy.

This time, however, you're not alone! Fellow brilliant coworkers, also formerly from Fiction Interactive, have been given the same assignment, and they are hungry for victory! (Or maybe just hungry for pizza...) Show them what you can do, and we wish you the best of luck!

Goals

• Finding your way in an unfamiliar codebase
• Writing modular code
• Testing code that is difficult to test

Assignment Spec

Getting Started

For this assignment, you will be creating at least one intelligent player strategy for a strategy game based on exhilarating concepts like mining and economics. This game is called Mine-opoly. Unlike previous assignments, we are giving you a significant amount of code. We have taken care of everything needed to run the game. This includes a game engine, graphics, and of course an interface for your strategy implementation. You are not allowed to modify this MinePlayerStrategy interface. You are however free to modify any other files including the game engine and graphics, but you do so at your own risk, and we will be using the original copy that we gave you to run the competition. You should create your Github repository from this link:

Click here to generate your repository

The Game

The game is a turn based mining competition played on an NxN square set of tiles which is considered the Game Board. There are 3 types of tiles on the board:

• Empty tiles: These tiles contain nothing
• Resource tiles: These tiles contain a type of ore you can mine
• Market tiles: Stepping on the market tile for your player's color will sell all gathered resources

There are two players per game, a red player and a blue player. Both players start in the center of the board on their lower market tile. Each turn both players will receive information about the board state. This information contains where all the resources are, where your opponent is, prices for each resource, and other such information. Each turn both players will be required to return a TurnAction. This TurnAction is an enum value which indicates what your strategy wants your player to do for the current turn. TurnActions are one of the following:

• MOVE_UP, MOVE_DOWN, MOVE_LEFT, or MOVE_RIGHT all indicate that your player would like to move in that direction on this turn. Movement is relative to the bottom left tile, so MOVE_UP will move your player towards the top of your screen and MOVE_RIGHT will move your player towards the right of your screen.

• MINE indicates that you would like to mine the tile your player's current tile. How many turns it takes to finish mining a resource depends on the resource type. Diamond takes 3 turns to mine, emerald takes 2 turns to mine, and ruby only takes 1 turn to mine. When you have mined a resource enough, it will drop a gem on the tile your player is standing on.

• PICK_UP indicates you would like to add an item to your inventory. If your player is standing on a tile that has a mined gem, it will add the gem to your inventory. The maximum inventory size for your player will always be 5. Attempting to pick up an item when your inventory is full will leave the item on the ground.

As previously mentioned, market tiles are where you can sell your gathered gems for points. Stepping on one of these tiles will immediately sell every gem in your inventory at the current price for each type of gem. The price for each gem will then decrease depending on the amount of each type sold. Prices for gems will steadily increase over time again until reaching the max value for the gem type.

Finally, since players execute turns "at the same time", potential conflicts such as moving into the same tile will be handled by the concept of red turns and blue turns. On a red turn, the red player will have priority for these types of moves. On a blue turn, the blue player will have priority. Red turns and blue turns will alternate throughout the game. The first turn will be a red turn. So if two players are trying to move into the same tile, and it is currently a red turn, the red player has priority and will successfully move into that tile. The blue player will be blocked from moving and therefore do nothing.

The Interface

We have given you an interface that your player strategy should implement. You need to implement this interface without modifications, otherwise your strategy will not run in the provided game engine or the competition. This interface is called MinePlayerStrategy. It has the following methods:

1. initialize() - This function will be called at the start of every round, passing in the size of the board, the maximum items that a player can carry in their inventory, the score to reach to win a single round, the starting tile location for the player, whether the player is a red player and a Random object for the player to use for generating random numbers if their strategy needs that.
2. getTurnAction() - This function is the primary purpose of your strategy. It is called every turn to get the action your player should execute. A PlayerBoardView object is passed in which represents the state of the board, along with a boolean to say if the current turn is a red priority turn or not. This function returns a TurnAction for the action the player wants to execute. Returning null from this function will cause the player to do nothing.
3. onReceiveItem() - This function is called whenever the player successfully executed a PICK_UP TurnAction on their last turn. The only parameter for this function is a reference to the InventoryItem picked up. This function is not called when the player inventory is full because the item is not picked up in that case.
4. onSoldInventory() - This function is called whenever the player steps on a market tile of their color with at least one gem in their inventory. The only parameter for this function is an int for the total number of points received by selling everything in the inventory.
5. getName() - This function is super simple, just return the name that you want to give your player on the GUI and in the competition. Can be as simple as a string constant like "ExampleName". Note that if you somehow manage to throw an exception in this function, your player's name will be the exception that you threw. That's super embarrassing for everyone involved.
6. endRound() - This function is called at the end of every round. This passes in the number of points that your player scored and the number of points that the opposing player scored. You should also use this method to reset the state of your strategy class. Every semester we get complaints from people that their strategy acts buggy in the competition, and it turns out their strategy is still using variables set in the previous round.

The Competition

Participation in the competition is completely optional. Your grade is not impacted in any way by your decision not to participate or your placement in the competition. However, we make no guarantees about the impact of these things on your sense of self-worth. The top 8 strategies will be immortalized in a Hall of Fame on the website. The losing strategies... will not be. The top 8 will also be invited to a pizza party hosted by Professor Woodley. Everyone else will just get to hear about it. The choice is up to you!

How to submit code

Push code to your master branch. This is the branch we will pull from when we run the competition.

In order for us to run your player strategy in the tournament, you must put a single class that implements the MinePlayerStrategy in the competition package. You may also put any other classes you need in that package. This package is package mineopoly.competition;

How to make sure your code compiles in the competition

Do not include any subpackages in the competition package. These will not get compiled or run. Do not reference any classes that you personally created which are outside the competition package.

• References to classes we provided like MinePlayerStrategy or TurnAction are perfectly fine
• If you have other classes you wrote that your strategy needs, they need to be in the competition package
• This means you either need to move them to the competition package, or make a copy of the class to put in the competition package
• Yes, repeating code is bad, but points will not be taken off for having duplicate classes in the competition package.
• Your class must also implement a constructor that takes no arguments. You may have logic in this constructor and you may have other constructors, but you need at least one constructor method that does not take any arguments. This is the constructor that will be used in the competition engine.

How to ensure your code is valid

Put only one player strategy in the competition package, otherwise we will not know which strategy to run. There should only be one class in the competition package that implements MinePlayerStrategy

• Do not print things in your player strategy: This clogs up our logging of the games being run and we will not execute your code if your strategy prints to console
• Don't cheat: Do not use things like using reflection to directly modify your score. This is just an example, reflection and other similar techniques have been disabled.
• Don't write malicious code: Things like calling System.exit() in your player strategy will not work and will result in a 0 for this assignment.

Competition Runs

We will be auto-running the competition starting this Tuesday, October 8th. Indeed, this is on the due date, but we won't be closing the competition until the following Tuesday, October 15th. Note that you will still have an assignment due that week, and it will be our first C++ assignment. However, the workload should be smaller, so you can spend some time tweaking your strategy if you'd like.

Assignment Requirements

To fully complete this assignment, you must write at least one MinePlayerStrategy that meets the following requirements:

• Your strategy must not crash. For instance, it should not throw an exception when all the rubies have been mined and it tries to find a ruby.
• You must achieve a minimum score of 30 * (boardSize * boardSize) for any boardSize between 16 and 30 playing your strategy against the RandomStrategy.

The provided implementation of RandomStrategy cannot pick up gems, so it cannot score any points. It will therefore only make things easier for you to score more points.

You are entirely allowed to write more than one strategy. In fact it probably makes sense to have a strategy that maximizes your points against a RandomStrategy for the assignment, and then another strategy that does more complicated actions against a smarter human-programmed opponent for the competition.

Recommended approach

Part of this assignment is becoming familiar with an unfamiliar codebase. IntelliJ has built-in tools to allow you to more easily explore code

• Right click on variable, method, or class -> Find Usages will show everywhere it is used
• Right click on variable, method, or class -> Go to -> Declaration will show where it is declared
• At least on Windows crtl + shift + F will search the whole project for text

By all means feel free to ask questions on Piazza or in office hours if you get stuck, but you have all the code running the game in front of you. If you look around enough, you can probably find the answer to any question you may have, and develop a useful skill in the process.

Consider exploring around before you ever attempt to write a strategy. Are there some parts that seem more important than others (like the main method in MineopolyMain, or runGameLoop() in GameEngine)? Are there some parts that seem irrelevant to your needs (like anything dealing with the graphics or the paint() methods)?

When you do feel like you are ready to write a strategy, are there certain helper methods it would makese sense to have? If you do decide to write a more complex strategy for the competition, are there some design choices you could make to implement complicated conditional behavior more easily? Can an interface or abstract base class you write help you do that?

Other things we will take into consideration:

• Is the code well organized? Are more complex chunks of code decomposed out into helper methods?
• Are there tests for any helper methods being used in your strategy/strategies?
• Is indentation, whitespace, and brace placement consistent with the Google Style Guide? Are lines kept under 100 characters long?

Test suites for this assignment are expected to be a bit slim, since of course you are only writing a strategy, and all of the game engine functionality has been done for you. That being said, if you write helper methods that you reuse ( which is a good idea in general), you should be testing them.

Try to make commits at regular intervals. You want to leave a clear trail of discrete pieces of progress that you've made as you work. Commits are cheap! Make lots of them. Once again, try to involve testing in your code development process; you don't have to write all of your tests before the code, but you should try to develop your code alongside your tests and vice versa.

Use your best judgement to write the cleanest code you can; make sure you can justify any design decisions you make in code review.

This is a test of your problem-solving skills: if you don't know how to do something (for example, writing an abstract class,) you should try your favorite search engine. (Make sure you follow our policy on citing online code.) If you're still stuck, consider Piazza and office hours.