Code Review for upcoming contest

[Darryl]

Ok on the suggestion of Blackroot I am doing a Risk contest. I have everything completed, but before I post I wanted to get some feedback first on the player_interface. Basically, I want to make sure there aren't any other member functions you need to be able to easily create an AI for it? Other suggestion are fine as well.

#ifndef PLAYER_INTERACE_H
#define PLAYER_INTERACE_H
#include "helpers.h"
#include "player.h"

class PlayerInterface
{
	friend class Player;

public:
	//virtual methods must be overidden

	virtual std::string getName()const =0;
	// This is used by the framework to get the preferred name
	// for your AI player.  You should return a string container the name of your player.
	// If you duplicate an existing name extra letters will be tacked onto your name
	// to make it unique.


	virtual void init()=0;
	// This method is call after all players have been added and the 
	// players have been "shuffled" to start choosing countries.
	// please note that the play order changes again, after all initial
	// armies are place before play begin.
	// You can use it for whatever initialization your player needs to do that can't
	// be done in the constructor



	virtual std::string chooseCountry()=0;
	// This method is called when there are unclaimed countries available to claim
	// You should return a string containing the name of the unclaimed country you wish
	// claim.  If you return an invalid name (spelling/case or already claimed) one will
	// be chosen for you at random.  For comparison purposes, it's recommend you use the 
	// country names as defined in helpers.h.  There are several arrays, enums etc at your
	// disposable.



	virtual std::string placeArmy ()=0;
	// This function is called in 2 circumstances
	// 1st at the beginning after all countries have been claimed
	// this function is called to place your remaining armies on 
	// countries you own

	// 2nd This function is called at the beginning of your turn when you have new armies
	// to place.

	// Again, you should return a string containing the name of the country you wish to place the army
	// One army is placed at a time.  Invalid names will result in an army being randomly placed in 
	// a country you control



	virtual std::vector<const Card> redeemCards()=0;
	// This method is called if you are in possesion of cards that can be redeemed
	// (Either a matched set - 3 like card, or an unmatched set - 3 unlike cards, or
	// 2 cards and a wild card.  If you wish to redeem your set, return a std::vector<const Card>
	// to the framework with the 3 cards from your hand you wish to redeem.  You are not 
	// required to redeem your cards unless you have 5 or more cards.  If you do not wish to redeem
	// just return an empty vector.
	// If you return an invalid set, and you hold less than 5 cards, no action will be taken.
	// If you hold 5 or more cards, a valid set will be chosen for you.  

	// Also not that the order the cards are entered into the vector is important:
	// If the country on the card matches a country you control, you receive a bonus of 2 armies
	// on that country (They will be placed automatically).  You can only receive 1 bonus of 2
	// armies per trade-in.  Therefore, if more than one of your cards have countries that
	// you control and you want the 2 armies to go on a particular country
	// put that country first into your vector.
	
	
	
	virtual Action getAction()=0;
	// This method gets your actions for your turn.  There is no set turn length as long
	// as you have armies to attack with.  Therefore you determine most of the time when
	// your turn is over by submitting the apporpriate action.  (See helpers.h for actions)
	// Basically you complete an action struct with your action and submit it to the framework.
	// If you submit an invalid action, it will be treated as an end of turn without fortification.



	virtual int defendCountry(Action A)=0;
	// When your are on the defending end of an attack, you have the choice 
	// of defending with 1 or 2 armies (1 or 2 dice)  return your choice here.
	// If you return a number greater than 2, or if you only have 1 army in the country
	// and return 2 then 1 will be used.




	virtual int captureCountry(Action A)=0;
	// If you defeat all the armies in a country you must now claim that country
	// by moving armies into it from the attacking country
	// you must move minimum the same number that you attacked with and maximum 1 less
	// than the number of armies you have in the attacking country.
	// return the number you wish to move.  An invalid number results in the minimum move.




	virtual void notify(Action A)=0;
	// After every action a notification is went to all of the players
	// showing the results.  Invalid submissions will have been corrected
	// so that the actual results are shown here.
	// This is information only, use as you see fit.


	//non-virtual must NOT!!! be overidden
	std::vector<std::string> getCountriesByPlayer(std::string owner_name);
	// return a vector of the names of the countries controlled
	// by owner_name

	std::vector<std::string> getAdjacent(std::string country_name);
	// returns a vector of the names of the countries touching/adjacent to country_name
	// useful for deciding attacks/fortifications etc.

	std::string me();
	// Since the framework may change your player name to guarantee uniqueness
	// use this function if you need to submit a function with your players name. 
	// ex: std::vector<std::string> myCountries = getCountriesByPlayer(me());

	size_t getArmyCount(std::string country_name);
	// returns the number of Armies in country_name

	std::string getOwner(std::string country_name);
	// returns the owner of countr_name

	std::vector<std::string> getPlayers();
	// return a vector of the names of the player and their current order
	// orders is set twice, once before countries are chosen
	// and once before play begins


private:
	Player* mpPlayer;
	// this is no concern to you and you should not try to use this, but since it's here
	// This is a pointer to the real player class where most of the player info is stored
	// The Player class also acts as a go between for the player_interface (this class)
	// and the main game class.  It handles all the validations so the game class only
	// gets good inputs and doesn't have to do a lot of error checking

};
#endif

and helpers.h

#ifndef HELPERS_H
#define HELPERS_H

#include <string>

enum CARD_TYPE {INFANTRY, CAVALRY, ARTILLERY, WILD};

const std::string CONTINENTS[] = {"North America","Europe","Asia","Africa","Australia","South America"};

const std::string COUNTRY_NAMES[] = {"Alaska","Alberta","Central America","Eastern United States","Greenland","Northwest Territory","Ontario","Quebec","Western United States",
									"Great Britain","Iceland","Northern Europe","Scandinavia","Southern Europe","Ukraine","Western Europe",
									"Afghanistan","China","India","Irkutsk","Japan","Kamchatka","Middle East","Mongolia","Siam","Siberia","Ural","Yakutsk",
									"Congo","East Africa","Egypt","Madagascar","North Africa","South Africa",
									"Eastern Australia","Indonesia","New Guinea","Western Australia",
									"Argentina","Brazil","Peru","Venezuela"};
enum COUNTRY_INDEX
{
	Alaska,	Alberta, Central_America, Eastern_United_States, Greenland, Northwest_Territory, Ontario, Quebec, Western_United_States,	
	Great_Britain, Iceland, Northern_Europe, Scandinavia, Southern_Europe, Ukraine, Western_Europe,	
	Afghanistan, China, India, Irkutsk, Japan, Kamchatka, Middle_East, Mongolia, Siam, Siberia, Ural, Yakutsk,	
	Congo, East_Africa, Egypt, Madagascar, North_Africa, South_Africa,
	Eastern_Australia, Indonesia, New_Guinea, Western_Australia,	
	Argentina, Brazil, Peru, Venezuela, Wild, Bad_Index
};

const COUNTRY_INDEX NORTH_AMERICA[] =	{Alaska, Alberta, Central_America, Eastern_United_States, Greenland, Northwest_Territory, Ontario, Quebec, Western_United_States};
const COUNTRY_INDEX EUROPE[] =			{Great_Britain, Iceland, Northern_Europe, Scandinavia, Southern_Europe, Ukraine, Western_Europe};
const COUNTRY_INDEX ASIA[] =			{Afghanistan, China, India, Irkutsk, Japan, Kamchatka, Middle_East, Mongolia, Siam, Siberia, Ural, Yakutsk};
const COUNTRY_INDEX AFRICA[] =			{Congo, East_Africa, Egypt, Madagascar, North_Africa, South_Africa};
const COUNTRY_INDEX AUSTRALIA[] =		{Eastern_Australia, Indonesia, New_Guinea, Western_Australia};
const COUNTRY_INDEX SOUTH_AMERICA[] =	{Argentina, Brazil, Peru, Venezuela};

const size_t NORTH_AMERICA_SIZE =	9;
const size_t NORTH_AMERICA_AWARD =	5;

const size_t EUROPE_SIZE =			7;
const size_t EUROPE_AWARD =			5;

const size_t ASIA_SIZE =			12;
const size_t ASIA_AWARD =			7;

const size_t AFRICA_SIZE =			6;	
const size_t AFRICA_AWARD =			3;	

const size_t AUSTRALIA_SIZE =		4;	
const size_t AUSTRALIA_AWARD =		2;	

const size_t SOUTH_AMERICA_SIZE =	4;
const size_t SOUTH_AMERICA_AWARD =	2;

const size_t COUNTRIES_SIZE =		42;

struct Action
{
	enum ACTION {ATTACK, FORTIFY, ENDTURN, CAPTURE, ADD, REMOVE, PLACEMENT};//

	// ATTACK	- attack ToCountry from FromCountry wint n number of armers. n = Armies with value of 1, 2 or 3
	// FORTIFY	- move n armies from FromCountry to ToCountry and ends turn.
	//			n = Armies with value 1 to AllInCountry-1
	// ENDTURN	- ends turn without fortifying position. Other values are ignored.
	ACTION action;// one of three above
	std::string FromCountry;
	std::string ToCountry;
	unsigned Armies; //1, 2 or 3 for attack, n-1 for fortify with n being number of armies
					// in FromCountry

	//RESULTS (to be filled in by framework, not player)
	int AttackerLosses;
	int DefenderLosses;
	bool CountryCaptured;
	std::string PlayerName;
	std::string FromPlayerName;
	std::string ToPlayerName;
};
//
struct Card
{
	Card(CARD_TYPE t, COUNTRY_INDEX c):type(t),country(c){}
	bool operator==(const Card& card)const{return this->type == card.type;}
	bool operator!=(const Card& card)const{return !((*this) == card);}
	bool operator< (const Card& card)const{return (int)type < (int)card.type;}

	CARD_TYPE type;
	COUNTRY_INDEX country;
};
//
COUNTRY_INDEX getCountryIndex(std::string Name);

//...removed for posting purposes... not relavent anyway

bool isAdjacent(std::string c1, std::string c2);




#endif