All Dev cards are now implemented with tests except for Knight. That is

blocked because getNeighboringCorners() does not work and is untested.

Author: PickledMonkey

include/GameBoard.h

@@ -114,6 +114,7 @@ class GameBoard {
 
     void moveRobber(Coordinate newRobber);
     Coordinate getRobber() const;
+    bool canRobberRob(Player& opponent, Coordinate location);
 
 };
 

include/Player.h

@@ -17,11 +17,12 @@
 #include "Util.h"
 #include "GameVisitor.h"
 
-const int WOOD_INDEX = 0;
-const int BRICK_INDEX = 1;
+// WHEAT, SHEEP, STONE, BRICK, WOOD is the order because it matches the enum in GamePiece.h
+const int WHEAT_INDEX = 0;
+const int WOOL_INDEX = 1;
 const int ORE_INDEX = 2;
-const int WHEAT_INDEX = 3;
-const int WOOL_INDEX = 4;
+const int BRICK_INDEX = 3;
+const int WOOD_INDEX = 4;
 
 
 class DevelopmentCard;
@@ -79,7 +80,7 @@ class Player {
 
     //KNIGHT, VICTORYPOINT, YEAROFPLENTY, MONOPOLY, ROADBUILDING
     bool playVictoryCard();
-    bool playKnight(Coordinate location);
+    bool playKnight(Coordinate location, Player& opponent);
     bool playYearOfPlenty(int resource);
     bool playMonopoly(int resource);
     bool playRoadBuilding(Coordinate start1, Coordinate end1, Coordinate start2, Coordinate end2);

src/GameBoard.cpp

@@ -422,11 +422,27 @@ bool GameBoard::verifyRoadPlacement(Coordinate start, Coordinate end, Player& Ow
  */
 void GameBoard::moveRobber(Coordinate newRobber) {
 
-	robber = newRobber;
+	//Bounds check
+	if(resources.count(newRobber) > 0)
+		robber = newRobber;
+}
+
+/**
+ * DOES NOT WORK BECAUSE getNeighboringCorners() does not work
+ */
+bool GameBoard::canRobberRob(Player& opponent, Coordinate location){
+	std::cout << GetNeighboringCorners(location).size() << "\n";
 
-	//force trade	
+	for(auto corner : GetNeighboringCorners(location)){
+		std::cout << corner->getOwner().getName() << "derp\n";
+		if(corner->getOwner() == opponent){
+			return true;
+		}
+	}
+	return false;
 }
 
+
 /**
  * The robber's location on the board.
  * @return The robber's location.

src/GameController.cpp

@@ -131,7 +131,7 @@ bool GameController::handleBoardEvent(ScreenCoordinate screenCoord) {
 		}
 		break;
 	case KNIGHT_DEVCARD:
-		model.getCurrentPlayer().playKnight(coord);
+		//model.getCurrentPlayer().playKnight(coord, opponent);
 		break;
 	case YEAROFPLENTY_DEVCARD:
 		//@ TODO Need to select a resource

src/Player.cpp

@@ -320,18 +320,25 @@ bool Player::playVictoryCard(){
 	return false;
 }
 
-bool Player::playKnight(Coordinate location){
-	if(developmentCards[KNIGHT] > 0){
-		developmentCards[KNIGHT]--;
-		armySize++;
-		board.moveRobber(location);
-		//@ TODO need to steal resources
+bool Player::playKnight(Coordinate location, Player& opponent){
+	if(developmentCards[KNIGHT] > 0 && board.canRobberRob(opponent, location)){
+				board.moveRobber(location);
+		int resourceToSteal = opponent.getRandomResource();
+		if(resourceToSteal >= 0){
+			addResource(resourceToSteal, 1);
+			opponent.addResource(resourceToSteal, -1);
+		}
 
+		armySize++;
+		developmentCards[KNIGHT]--;
 		return true;
 	}
 	return false;
 }
 bool Player::playYearOfPlenty(int resourceType){
+	if(resourceType >= 5)
+		return false;
+
 	if(developmentCards[YEAROFPLENTY] > 0){
 		developmentCards[YEAROFPLENTY]--;
 		addResource(resourceType, 2);
@@ -340,6 +347,9 @@ bool Player::playYearOfPlenty(int resourceType){
 	return false;
 }
 bool Player::playMonopoly(int resourceType){
+	if (resourceType >= 5)
+		return false;
+
 	if(developmentCards[MONOPOLY] > 0){
 		developmentCards[MONOPOLY]--;
 		for(auto& player : board.getPlayers()) {

tests/test_DevelopmentCards.cpp

@@ -139,6 +139,167 @@ TEST(VictoryPointCard){
 	testVictoryPointCard(test_player, false);
 }
 
+void testMonopolyCard(Player& test_player, bool correct_result, int resource_type, int expected_gain){
+	int prevCard = test_player.getMonopolyCards();int prevReso = -1;
+	try{
+		prevReso = test_player.getResource(resource_type);
+	}catch (std::runtime_error & e){
+		CHECK(resource_type >= 5);
+		return;
+	}
+
+	CHECK(test_player.playMonopoly(resource_type) == correct_result);
+	if(correct_result){
+		CHECK(prevCard == test_player.getMonopolyCards()+1);
+		CHECK(prevReso == test_player.getResource(resource_type)-expected_gain);
+	}else{
+		CHECK(prevCard == test_player.getMonopolyCards());
+		CHECK(prevReso == test_player.getResource(resource_type));
+	}
+
+}
+
+
+TEST(MonopolyCard){
+	GameBoard test_board({"tester1", "tester2", "tester3"});
+	Player& test_player1 = test_board.getPlayer(0);
+	Player& test_player2 = test_board.getPlayer(1);
+	Player& test_player3 = test_board.getPlayer(2);
+
+	std::unique_ptr<DevelopmentCard> test_card = std::unique_ptr<DevelopmentCard>(new MonopolyCard());
+
+	test_player1.addOre(3);
+	test_player1.addWheat(3);
+	test_player1.addWool(3);
+	test_player1.buyCard(test_card);
+	test_player1.buyCard(test_card);
+	test_player1.buyCard(test_card);
+
+	testMonopolyCard(test_player1, true, ORE_INDEX, 0);
+
+	test_player2.addWool(7);
+	test_player3.addWool(28);
+	testMonopolyCard(test_player1, true, WOOL_INDEX, 35);
+
+	test_player2.addWood(5);
+	test_player3.addOre(10);
+	testMonopolyCard(test_player1, false, 300, 0);
+	testMonopolyCard(test_player1, true, WOOD_INDEX, 5);
+
+	testMonopolyCard(test_player1, false, WHEAT_INDEX, 0);
+}
+
+
+void testYearOfPlenty(Player& test_player, bool correct_result, int resource_type){
+	int prevCard = test_player.getYearOfPlentyCards();
+	int prevReso = -1;
+	try{
+		prevReso = test_player.getResource(resource_type);
+	}catch (std::runtime_error & e){
+		CHECK(resource_type >= 5);
+		return;
+	}
+
+	CHECK(test_player.playYearOfPlenty(resource_type) == correct_result);
+	if(correct_result){
+		CHECK(prevCard == test_player.getYearOfPlentyCards()+1);
+		CHECK(prevReso == test_player.getResource(resource_type)-2);
+	}else{
+		CHECK(prevCard == test_player.getYearOfPlentyCards());
+		CHECK(prevReso == test_player.getResource(resource_type));
+	}
+
+
+}
+
+TEST(YearOfPlentyCard){
+	GameBoard test_board({"tester1"});
+	Player& test_player = test_board.getPlayer(0);
+
+	std::unique_ptr<DevelopmentCard> test_card = std::unique_ptr<YearOfPlentyCard>(new YearOfPlentyCard());
+
+	test_player.addOre(2);
+	test_player.addWheat(2);
+	test_player.addWool(2);
+	test_player.buyCard(test_card);
+	test_player.buyCard(test_card);
+
+	testYearOfPlenty(test_player, true, ORE_INDEX);
+	testYearOfPlenty(test_player, false, 300);
+	testYearOfPlenty(test_player, true, WOOD_INDEX);
+	testYearOfPlenty(test_player, false, WOOL_INDEX);
+}
+
+
+int getResourceSum(Player& player){
+	int sum = 0;
+	for(int i = 0; i < 5; i++){
+		sum += player.getResource(i);
+	}
+	return sum;
+}
+
+void testKnightCard(Player& test_player, bool correct_result, GameBoard& test_board, Coordinate newLocation, Player& opponent, int gain_expected){
+	Coordinate prevRobber = test_board.getRobber();
+	int prevArmy = test_player.getArmySize();
+	int prevCards = test_player.getKnightCards();
+	int player_prevResourceSum = getResourceSum(test_player);
+	int opponent_prevResourceSum = getResourceSum(opponent);
+
+	std::cout << test_player.getName() << "| NL:(" << newLocation.first << ", " << newLocation.second << ") O:" << opponent.getName() << "\n";
+
+	CHECK(test_player.playKnight(newLocation, opponent) == correct_result);
+	if(correct_result){
+		CHECK(newLocation == test_board.getRobber());
+		CHECK(prevArmy+1 == test_player.getArmySize());
+		CHECK(prevCards-1 == test_player.getKnightCards());
+		CHECK(player_prevResourceSum+gain_expected == getResourceSum(test_player));
+		CHECK(opponent_prevResourceSum-gain_expected == getResourceSum(opponent));
+	}else{
+		CHECK(prevRobber == test_board.getRobber());
+		CHECK(prevArmy == test_player.getArmySize());
+		CHECK(prevCards == test_player.getKnightCards());
+		CHECK(player_prevResourceSum == getResourceSum(test_player));
+		CHECK(opponent_prevResourceSum == getResourceSum(opponent));
+	}
+
+
+}
+
+TEST(KnightCard){
+	GameBoard test_board({"tester1", "tester2", "tester3"});
+	Player& test_player1 = test_board.getPlayer(0);
+	Player& test_player2 = test_board.getPlayer(1);
+	Player& test_player3 = test_board.getPlayer(2);
+
+	std::unique_ptr<DevelopmentCard> test_card = std::unique_ptr<DevelopmentCard>(new KnightCard());
+
+	test_player1.addOre(3);
+	test_player1.addWheat(3);
+	test_player1.addWool(3);
+	test_player1.buyCard(test_card);
+	test_player1.buyCard(test_card);
+	test_player1.buyCard(test_card);
+
+	test_board.moveRobber(Coordinate(0,1));
+
+	testKnightCard(test_player1, false, test_board, Coordinate(0,4), test_player2, 0);
+/**DOES NOT WORK BECAUSE getNeighboringCorners() does not work
+	test_player2.addWood(1);
+	test_board.PlaceSettlement(Coordinate(0,3), test_player2);
+	testKnightCard(test_player1, true, test_board, Coordinate(0,4), test_player2, 1);
+
+	test_player3.addWood(1);
+	test_player3.addOre(1);
+	test_board.PlaceSettlement(Coordinate(0,0), test_player3);
+	testKnightCard(test_player1, true, test_board, Coordinate(0,1), test_player3, 1);
+
+	testKnightCard(test_player1, true, test_board, Coordinate(0,4), test_player2, 0);
+**/
+
+	testKnightCard(test_player1, false, test_board, Coordinate(0,4), test_player3, 0);
+}
+
 
 
 

tests/test_GameBoard.cpp

@@ -259,6 +259,9 @@ TEST(buy_road_good){
 
 
 	test_board.PlaceSettlement(start, test_player);
+
+	test_player.addBrick(1);
+	test_player.addWood(1);
 	test_board.buyRoad(start, end, test_player);
 
 	std::shared_ptr<Road> test_road = test_board.getRoad(start, end);
@@ -354,8 +357,20 @@ TEST(updateLongestRoadPlayer){
 	CHECK(test_player2.hasLongestRoad() == false);
 }
 
+/**
+TEST(canRobberRob){
+	GameBoard test_board({"tester1", "tester2"});
+	Player& test_player1 = test_board.getPlayer(0);
+	Player& test_player2 = test_board.getPlayer(1);
 
 
+	CHECK(test_board.canRobberRob(test_player1, Coordinate(0,1)) == false);
+
+	test_board.PlaceSettlement(Coordinate(0,0), test_player1);
+	CHECK(test_board.canRobberRob(test_player1, Coordinate(0,1)) == true);
+}
+**/
+