Merge pull request #5 from Databean/road_implementation

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

Author: Databean

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);