Updates road checks to include the check that the road is built off

another road or a settlement. Added buying road functions in Player and
GameBoard. Changed the corners variable in GameBoard to use CornerPieces
instead of GamePieces. Renamed "setters" in Player class, they are now
called adders like their functionality.

Author: PickledMonkey

include/GameBoard.h

@@ -20,7 +20,7 @@ class GameVisitor;
 
 class GameBoard {
 private:
-	std::map<Coordinate, std::unique_ptr<GamePiece>> corners;
+	std::map<Coordinate, std::unique_ptr<CornerPiece>> corners;
 	std::map<Coordinate, std::unique_ptr<GamePiece>> resources;
 	std::map<Coordinate, std::vector<std::shared_ptr<Road>>> roads;
 	std::vector<std::unique_ptr<Player>> players;
@@ -33,7 +33,7 @@ class GameBoard {
 	bool verifyRoadPlacement(Coordinate start, Coordinate end, Player& Owner);
 	bool outOfBounds(const Coordinate& coord);
 	bool roadExists(Coordinate start, Coordinate end);
-	bool isRoadConnectionPoint(Coordinate start, Coordinate end, Player& Owner);
+	bool isRoadConnectionPoint(Coordinate point, Player& Owner);
 
 	int constructBoardFromFile(std::ifstream &file);
 	int constructFileFromBoard(std::ofstream &file);
@@ -58,9 +58,11 @@ class GameBoard {
 
 	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location);
 
+	bool buyRoad(Coordinate start, Coordinate end, Player& Owner);
+
 	void PlaceSettlement(Coordinate location, Player& Owner);
 	void PlaceCity(Coordinate location, Player& Owner);
-	void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
+	bool PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
 
 	void accept(GameVisitor& visitor);
 

include/GamePiece.h

@@ -22,7 +22,7 @@ class GamePiece {
 	Coordinate getCoordinates() const;
 	GameBoard& getBoard();
 	const GameBoard& getBoard() const;
-	
+
 	Coordinate location;
 
 	virtual void accept(GameVisitor&) = 0;

include/Player.h

@@ -65,24 +65,26 @@ class Player {
 
     void playCard(DevelopmentCard* card);
 
+    bool canBuyRoad();
+    bool buyRoad();
+
     bool offerTrade(Player* p, int offer[], int demand[]);
     bool recieveOffer(Player* p, int offer[], int demand[]);
     bool acceptOffer(Player* p, int offer[], int demand[]);
 
     bool checkResources(int resourceList[]);
 
-
     int getWood() const;
     int getBrick() const;
     int getOre() const;
     int getWheat() const;
     int getWool() const;
 
-    void setWood(int resource);
-    void setBrick(int resource);
-    void setOre(int resource);
-    void setWheat(int resource);
-    void setWool(int resource);
+    void addWood(int resource);
+    void addBrick(int resource);
+    void addOre(int resource);
+    void addWheat(int resource);
+    void addWool(int resource);
 
 	void accept(GameVisitor& visitor);
 	bool operator==(const Player& player) const;

include/Road.h

@@ -35,7 +35,7 @@ class Road {
 	void unmark();
 
 	Player& getOwner();
-	const Player& getOwner() const;
+	Player& getOwner() const;
 
 	Player* owner;
 

src/GameBoard.cpp

@@ -233,6 +233,8 @@ bool GameBoard::outOfBounds(const Coordinate& coord) {
 	 * Discussed that we can just do a find in the map, and if it's not found then it's out of bounds
 	 */
 
+
+
 	switch (coord.second) {
 	case 0:
 		return !(coord.first >= 0 && coord.first <= 4);
@@ -277,23 +279,34 @@ bool GameBoard::roadExists(Coordinate start, Coordinate end) {
 	return true;
 }
 
+
 /**
  * Checks to make sure the road being placed at a valid point according to the rules
  */
-bool GameBoard::isRoadConnectionPoint(Coordinate start, Coordinate end, Player& Owner){
-	/** Need to figure out the CornerPiece/GamePiece predicament
-	CornerPiece * corner = corners[start];
-	if(corner != NULL){
-		if (corner->getOwner() == Owner)
+bool GameBoard::isRoadConnectionPoint(Coordinate point, Player& Owner){
+	//is there a settlement we can build off of
+	if(corners.count(point) > 0){
+		CornerPiece * corner = corners[point].get();
+		if(corner != NULL){
+			if (corner->getOwner() == Owner)
+				return true;
+		}
+	}
+
+	//is there a road we can build off of
+	std::vector<shared_ptr<Road>> roadVector = roads[point];
+	for (std::vector<shared_ptr<Road>>::iterator road = roadVector.begin(); road != roadVector.end(); ++road) {
+		if ((*road)->getOwner() == Owner)
 			return true;
 	}
+
 	return false;
-	**/
-	return true;
+
 }
 
 /**
  * Runs a series of checks to make sure the road can be placed
+ * new Roads must be in bounds, unique, and connected to an existing road or settlement
  */
 bool GameBoard::verifyRoadPlacement(Coordinate start, Coordinate end, Player& Owner) {
 	if (outOfBounds(start) || outOfBounds(end))
@@ -302,35 +315,52 @@ bool GameBoard::verifyRoadPlacement(Coordinate start, Coordinate end, Player& Ow
 	if (roadExists(start, end))
 		return false;
 
-	if (!isRoadConnectionPoint(start, end, Owner))
+	if (!isRoadConnectionPoint(start, Owner) && !isRoadConnectionPoint(end, Owner)) //need to XOR
 		return false;
 
 	return true;
 }
 
 /**
  * Places a road at the specified coordinates that will be owned by the given player
+ * returns true if the road was placed, false otherwise
  */
-void GameBoard::PlaceRoad(Coordinate start, Coordinate end, Player& Owner) {
+bool GameBoard::PlaceRoad(Coordinate start, Coordinate end, Player& Owner) {
 	if (!verifyRoadPlacement(start, end, Owner))
-		return;
+		return false;
 
 	std::shared_ptr<Road> newRoad;
 	try {
 		newRoad = std::shared_ptr<Road>(new Road(start, end, Owner));
 	} catch (int n) {
 		//Coordinates did not meet the criteria for a valid road
-		return;
+		return false;
 	}
+
 	std::vector<shared_ptr<Road>> roadVector = roads[start];
 	roadVector.push_back(newRoad);
 	roads[start] = roadVector;
-
 	roadVector = roads[end];
 	roadVector.push_back(newRoad);
 	roads[end] = roadVector;
+	return true;
+
+
+}
+
+/**
+ * Will purchase a road for the given Player if it is possible.
+ * returns true if the road was purchased and placed, false otherwise
+ */
+bool GameBoard::buyRoad(Coordinate start, Coordinate end, Player& Owner){
+	if(Owner.canBuyRoad() && PlaceRoad(start, end, Owner)){
+		Owner.buyRoad();
+		return true;
+	}
+	return false;
 }
 
+
 /**
  * returns a pointer to the road located at the specified coordinates. Will return NULL if the road is not found
  */
@@ -394,11 +424,11 @@ int GameBoard::FindLongestRoad_FromPoint(Coordinate curr, Player & owner, std::m
 }
 
 void GameBoard::PlaceSettlement(Coordinate location, Player& Owner){
-	corners[location] = std::unique_ptr<GamePiece>(new Settlement(*this, location, Owner));
+	corners[location] = std::unique_ptr<CornerPiece>(new Settlement(*this, location, Owner));
 }
 
 void GameBoard::PlaceCity(Coordinate location, Player& Owner){
-	corners[location] = std::unique_ptr<GamePiece>(new City(*this, location, Owner));
+	corners[location] = std::unique_ptr<CornerPiece>(new City(*this, location, Owner));
 }
 
 void GameBoard::accept(GameVisitor& visitor) {

src/Player.cpp

@@ -39,11 +39,11 @@ Player::Player(XMLElement* elem)
 		r = 0;
 	}
 	name = elem->FirstChildElement("name")->FirstChild()->Value();
-	setWood(fromString<int>(elem->FirstChildElement("wood")->FirstChild()->Value()));
-	setBrick(fromString<int>(elem->FirstChildElement("brick")->FirstChild()->Value()));
-	setOre(fromString<int>(elem->FirstChildElement("ore")->FirstChild()->Value()));
-	setWheat(fromString<int>(elem->FirstChildElement("wheat")->FirstChild()->Value()));
-	setWool(fromString<int>(elem->FirstChildElement("wool")->FirstChild()->Value()));
+	addWood(fromString<int>(elem->FirstChildElement("wood")->FirstChild()->Value()));
+	addBrick(fromString<int>(elem->FirstChildElement("brick")->FirstChild()->Value()));
+	addOre(fromString<int>(elem->FirstChildElement("ore")->FirstChild()->Value()));
+	addWheat(fromString<int>(elem->FirstChildElement("wheat")->FirstChild()->Value()));
+	addWool(fromString<int>(elem->FirstChildElement("wool")->FirstChild()->Value()));
 	XMLElement* cardsElement = elem->FirstChildElement("cards");
 	for(auto cardElem = cardsElement->FirstChildElement("card"); cardElem; cardElem = cardElem->NextSiblingElement("card")) {
 		static const map<std::string, std::function<std::unique_ptr<DevelopmentCard>(void)>> typeToCard = {
@@ -73,6 +73,27 @@ int Player::getDevCardsInHand()
 	return developmentCards.size();
 }
 
+/**
+ * Returns true if the player has enough resources to buy a road, false otherwise
+ */
+bool Player::canBuyRoad(){
+	return getWood() > 0 && getBrick() > 0;
+}
+
+/**
+ * Subtracts the cost of a road from a player's resources if they have enough
+ * returns true if the resources were subtracted, false otherwise
+ */
+bool Player::buyRoad(){
+	if(canBuyRoad()){
+		addWood(-1);
+		addBrick(-1);
+		return true;
+	}
+	//insufficient funds
+	return false;
+}
+
 
 void Player::updateVictoryPoints()
 {
@@ -150,17 +171,17 @@ bool Player::recieveOffer(Player* p, int offer[], int demand[])
 
 bool Player::acceptOffer(Player* p, int offer[], int demand[])
 {
-	p->setWood(demand[WOOD_INDEX] - offer[WOOD_INDEX]);
-	p->setBrick(demand[BRICK_INDEX] - offer[BRICK_INDEX]);
-	p->setOre(demand[ORE_INDEX] - offer[ORE_INDEX]);
-	p->setWheat(demand[WHEAT_INDEX] - offer[WHEAT_INDEX]);
-	p->setWool(demand[WOOL_INDEX] - offer[WOOL_INDEX]);
-
-	this->setWood(offer[WOOD_INDEX] - demand[WOOD_INDEX]);
-	this->setBrick(offer[BRICK_INDEX] - demand[BRICK_INDEX]);
-	this->setOre(offer[ORE_INDEX] - demand[ORE_INDEX]);
-	this->setWheat(offer[WHEAT_INDEX] - demand[WHEAT_INDEX]);
-	this->setWool(offer[WOOL_INDEX] - demand[WOOL_INDEX]);
+	p->addWood(demand[WOOD_INDEX] - offer[WOOD_INDEX]);
+	p->addBrick(demand[BRICK_INDEX] - offer[BRICK_INDEX]);
+	p->addOre(demand[ORE_INDEX] - offer[ORE_INDEX]);
+	p->addWheat(demand[WHEAT_INDEX] - offer[WHEAT_INDEX]);
+	p->addWool(demand[WOOL_INDEX] - offer[WOOL_INDEX]);
+
+	this->addWood(offer[WOOD_INDEX] - demand[WOOD_INDEX]);
+	this->addBrick(offer[BRICK_INDEX] - demand[BRICK_INDEX]);
+	this->addOre(offer[ORE_INDEX] - demand[ORE_INDEX]);
+	this->addWheat(offer[WHEAT_INDEX] - demand[WHEAT_INDEX]);
+	this->addWool(offer[WOOL_INDEX] - demand[WOOL_INDEX]);
 
 	return true;
 }
@@ -207,39 +228,39 @@ int Player::getWool() const
 
 
 
-void Player::setWood(int resource)
+void Player::addWood(int resource)
 {
 	if(resources[WOOD_INDEX] < (0-resource))
 		resources[WOOD_INDEX] = 0;
 	else
 		resources[WOOD_INDEX] += resource;
 }
 
-void Player::setBrick(int resource)
+void Player::addBrick(int resource)
 {
 	if(resources[BRICK_INDEX] < (0-resource))
 			resources[BRICK_INDEX] = 0;
 	else
 		resources[BRICK_INDEX] += resource;
 }
 
-void Player::setOre(int resource)
+void Player::addOre(int resource)
 {
 	if(resources[ORE_INDEX] < (0-resource))
 			resources[ORE_INDEX] = 0;
 	else
 		resources[ORE_INDEX] += resource;
 }
 
-void Player::setWheat(int resource)
+void Player::addWheat(int resource)
 {
 	if(resources[WHEAT_INDEX] < (0-resource))
 		resources[WHEAT_INDEX] = 0;
 	else
 		resources[WHEAT_INDEX] += resource;
 }
 
-void Player::setWool(int resource)
+void Player::addWool(int resource)
 {
 	if(resources[WOOL_INDEX] < (0-resource))
 		resources[WOOL_INDEX] = 0;

src/Road.cpp

@@ -104,6 +104,6 @@ Player& Road::getOwner() {
 	return *owner;
 }
 
-const Player& Road::getOwner() const {
+Player& Road::getOwner() const {
 	return *owner;
 }

tests/testSerialization.cpp

@@ -73,6 +73,8 @@ TEST(roadSerialization) {
 
 	GameBoard testBoard(std::move(players));
 
+	testBoard.PlaceSettlement(Coordinate(0,0), firstPlayer);
+	testBoard.PlaceSettlement(Coordinate(-1,1), secondPlayer);
 	testBoard.PlaceRoad(Coordinate(0,0), Coordinate(-1,1), firstPlayer);
 	testBoard.PlaceRoad(Coordinate(-1,1), Coordinate(-1,2), secondPlayer);