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.
and helpers.hCode:#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
Code:#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