Merge pull request #71 from Databean/refactor_deck

PickledMonkey · PickledMonkey · commit 5530204281cf · 2014-05-04T17:48:16.000-05:00
Refactor deck
diff --git a/.project b/.project
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>warsofcatan</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+	</natures>
+</projectDescription>
diff --git a/include/Deck.h b/include/Deck.h
@@ -11,7 +11,11 @@
 #include <vector>
 #include <ctime>
 #include <algorithm>
-#include "DevelopmentCard.h"
+//#include "DevelopmentCard.h"
+
+
+enum DevCardType { KNIGHT, VICTORYPOINT, YEAROFPLENTY, MONOPOLY, ROADBUILDING, NULLTYPE };
+
 
 /**
  * A collection of Settlers of Catan cards, initialized with the cards available in the standard game
@@ -20,8 +24,8 @@
 class Deck {
 
 private:
-	std::vector<DevelopmentCard*> deck;
-    std::vector<DevelopmentCard*> discardPile;
+	std::vector<DevCardType> deck;
+    std::vector<DevCardType> discardPile;
     
     void shuffleDeck();
     void reshuffleDeck();
@@ -31,8 +35,8 @@ class Deck {
 	virtual ~Deck();
 
 	int getSize();
-	DevelopmentCard* drawCard();
-    void discard(DevelopmentCard* toDiscard);
+	DevCardType drawCard();
+    void discard(DevCardType toDiscard);
 };
 
 #endif /* DECK_H_ */
diff --git a/include/DevelopmentCard.h b/include/DevelopmentCard.h
@@ -17,7 +17,7 @@
 #include <stdexcept>
 
 
-enum DevCardType { KNIGHT, VICTORYPOINT, YEAROFPLENTY, MONOPOLY, ROADBUILDING };
+//enum DevCardType { KNIGHT, VICTORYPOINT, YEAROFPLENTY, MONOPOLY, ROADBUILDING };
 
 
 /**
diff --git a/include/GameBoard.h b/include/GameBoard.h
@@ -19,7 +19,8 @@
 #include "GameDice.h"
 #include "Deck.h"
 
-#include "DevelopmentCard.h"
+//#include "DevelopmentCard.h"
+
 
 class GameVisitor;
 
@@ -36,7 +37,7 @@ class GameBoard {
 
 	Deck deck;
 
-	std::map<Coordinate, std::vector<std::shared_ptr<Road>>>roads;
+	std::map<Coordinate, std::vector<std::shared_ptr<Road>>> roads;
 
 	std::vector<std::unique_ptr<Player>> players;
 	Coordinate robber;
@@ -45,11 +46,12 @@ class GameBoard {
 	int maxVictoryPoints;
 	int winner;
 
-	void addResource(int x, int y, resourceType res, int val);
-	bool checkRolls(int* rolls);
+    void addResource(int x, int y, resourceType res, int val);
+    bool checkRolls(int* rolls);
 
 	bool isValidBoard() const;
 
+
 	bool outOfBounds(const Coordinate& coord) const;
 	bool roadExists(Coordinate start, Coordinate end) const;
 	bool isRoadConnectionPoint(Coordinate point, Player& Owner) const;
@@ -63,9 +65,9 @@ class GameBoard {
 	void createRing(Coordinate topRight, int sideLength, std::vector<resourceType>& resources, std::vector<int>& rolls);
 	void insertTile(Coordinate location, std::vector<resourceType>& resources, std::vector<int>& rolls);
 
-	std::pair<int, int> startTurn();
-	void enableRobber();
-	void payoutResources(int roll);
+    std::pair<int, int> startTurn();
+    void enableRobber();
+    void payoutResources(int roll);
 
 public:
 	GameBoard(const std::vector<std::string>& playerNames);
@@ -82,7 +84,7 @@ class GameBoard {
 	void save(std::ostream& out);
 
 	void buyCard(Player& owner);
-	void discardCard(DevelopmentCard * card);
+	void discardCard(DevCardType card);
 
 	ResourceTile& getResourceTile(Coordinate location) const;
 
@@ -138,11 +140,11 @@ class GameBoard {
 	int getNoOfPlayers();
 	Player& getPlayer(int index);
 
-	bool testRollChecking(int* rolls);
+    bool testRollChecking(int* rolls);
 
-	bool moveRobber(Coordinate newRobber);
-	Coordinate getRobber() const;
-	bool canRobberRob(Player& opponent, Coordinate location);
+    bool moveRobber(Coordinate newRobber);
+    Coordinate getRobber() const;
+    bool canRobberRob(Player& opponent, Coordinate location);
 
 };
 
diff --git a/include/Player.h b/include/Player.h
@@ -17,6 +17,7 @@
 #include "tinyxml2.h"
 #include "Util.h"
 #include "GameVisitor.h"
+#include "Deck.h"
 
 // WHEAT, SHEEP, STONE, BRICK, WOOD is the order because it matches the enum in GamePiece.h
 const int WHEAT_INDEX = 0;
@@ -26,8 +27,8 @@ const int BRICK_INDEX = 3;
 const int WOOD_INDEX = 4;
 
 
-class DevelopmentCard;
-class Deck;
+//class DevelopmentCard;
+//class Deck;
 
 
 class Player {
@@ -75,7 +76,7 @@ class Player {
 
     int getDevCardsInHand();
 
-    bool buyCard(std::unique_ptr<DevelopmentCard> &card);
+    bool buyCard(DevCardType card);
     std::string getName() const;
     GameBoard* getBoard();
     void setBoard(GameBoard* newboard);
diff --git a/src/Deck.cpp b/src/Deck.cpp
@@ -13,31 +13,25 @@
  */
 Deck::Deck()
 {
-	// TODO Auto-generated constructor stub
 	for(int i = 0; i < 15; i++)
 	{
-		DevelopmentCard* card = new KnightCard();
-		this->deck.push_back(card);
+		this->deck.push_back(KNIGHT);
 	}
 	for(int i = 0; i < 4; i++)
 	{
-		DevelopmentCard* card = new VictoryPointCard();
-		this->deck.push_back(card);
+		this->deck.push_back(VICTORYPOINT);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new YearOfPlentyCard();
-		this->deck.push_back(card);
+		this->deck.push_back(YEAROFPLENTY);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new MonopolyCard();
-		this->deck.push_back(card);
+		this->deck.push_back(MONOPOLY);
 	}
 	for(int i = 0; i < 2; i++)
 	{
-		DevelopmentCard* card = new RoadBuildingCard();
-		this->deck.push_back(card);
+		this->deck.push_back(ROADBUILDING);
 	}
     
     shuffleDeck();
@@ -49,19 +43,7 @@ Deck::Deck()
 Deck::~Deck() {
 	// TODO Auto-generated destructor stub
 
-	while(!this->deck.empty())
-	{
-		delete this->deck.back();
-		this->deck.pop_back();
-		//std::cout<<":";
-	}
-    
-    while(!this->discardPile.empty())
-	{
-		delete this->discardPile.back();
-		this->discardPile.pop_back();
-		//std::cout<<":";
-	}
+
 }
 
 /**
@@ -77,7 +59,7 @@ int Deck::getSize()
  * Pull a random card from the deck. If the deck is empty, reshuffle it.
  * @return An owning raw pointer to a random card from the deck.
  */
-DevelopmentCard* Deck::drawCard()
+DevCardType Deck::drawCard()
 {
 	if(this->getSize() == 0)
     {
@@ -86,10 +68,10 @@ DevelopmentCard* Deck::drawCard()
     
     if(this->getSize() == 0)
     {
-        return NULL;
+        return NULLTYPE;
     }
     
-	DevelopmentCard* card = this->deck.back();
+    DevCardType card = this->deck.back();
 	this->deck.pop_back();
 	return card;
 }
@@ -120,7 +102,7 @@ void Deck::reshuffleDeck()
  * Return a played card to the discard pile.
  * @param toDiscard An owning raw pointer to the card to discard.
  */
-void Deck::discard(DevelopmentCard* toDiscard)
+void Deck::discard(DevCardType toDiscard)
 {
     discardPile.push_back(toDiscard);
 }
diff --git a/src/GameBoard.cpp b/src/GameBoard.cpp
@@ -1276,47 +1276,20 @@ void GameBoard::payoutResources(int roll) {
 void GameBoard::buyCard(Player& owner) {
 	if (owner.canBuyCard() && deck.getSize() > 0) {
 
-		DevelopmentCard * card_ptr = deck.drawCard();
-
-		std::unique_ptr<DevelopmentCard> knight = std::unique_ptr<
-				DevelopmentCard>(new KnightCard());
-		std::unique_ptr<DevelopmentCard> victorypoint = std::unique_ptr<
-				DevelopmentCard>(new VictoryPointCard());
-		std::unique_ptr<DevelopmentCard> monopoly = std::unique_ptr<
-				DevelopmentCard>(new MonopolyCard());
-		std::unique_ptr<DevelopmentCard> yearofplenty = std::unique_ptr<
-				DevelopmentCard>(new YearOfPlentyCard());
-		std::unique_ptr<DevelopmentCard> roadbuilding = std::unique_ptr<
-				DevelopmentCard>(new RoadBuildingCard());
-
-		switch (card_ptr->getType()) {
-		case KNIGHT:
-			owner.buyCard(knight);
-			break;
-		case VICTORYPOINT:
-			owner.buyCard(victorypoint);
-			break;
-		case MONOPOLY:
-			owner.buyCard(monopoly);
-			break;
-		case YEAROFPLENTY:
-			owner.buyCard(yearofplenty);
-			break;
-		case ROADBUILDING:
-			owner.buyCard(roadbuilding);
-			break;
-		default:
-			break;
-		}
+		DevCardType card = deck.drawCard();
+
+
+		owner.buyCard(card);
 
-		delete (card_ptr);
 	}
 }
 
 /**
  * Discards a card back into the deck
  */
-void GameBoard::discardCard(DevelopmentCard * card) {
+
+void GameBoard::discardCard(DevCardType card){
+
 	deck.discard(card);
 }
 
diff --git a/src/Player.cpp b/src/Player.cpp
@@ -17,7 +17,6 @@
 #include <iostream>
 
 
-#include "DevelopmentCard.h"
 #include "GameBoard.h"
 
 
@@ -325,10 +324,10 @@ int Player::getVictoryPoints()
  * @param card An owning pointer to the card the player acquired.
  * @return True if the player successfully bought a card, or false if the player had insufficient resources
  */
-bool Player::buyCard(std::unique_ptr<DevelopmentCard>& card)
+bool Player::buyCard(DevCardType card)
 {
 	if(getWheat() > 0 && getOre() > 0 && getWool() > 0){
-		developmentCards[card->getType()]++;
+		developmentCards[card]++;
 		addWheat(-1);
 		addOre(-1);
 		addWool(-1);
@@ -489,7 +488,7 @@ bool Player::playYearOfPlenty(int resourceType){
 	if(developmentCards[YEAROFPLENTY] > 0){
 		developmentCards[YEAROFPLENTY]--;
 		addResource(resourceType, 2);
-		board.discardCard(new YearOfPlentyCard());
+		board.discardCard(YEAROFPLENTY);
 		return true;
 	}
 	return false;
@@ -509,7 +508,7 @@ bool Player::playMonopoly(int resourceType){
 		for(auto& player : board.getPlayers()) {
 			addResource(resourceType, player->giveAllResources(resourceType));
 		}
-		board.discardCard(new MonopolyCard());
+		board.discardCard(MONOPOLY);
 		return true;
 	}
 	return false;
@@ -532,7 +531,7 @@ bool Player::playRoadBuilding(Coordinate start1, Coordinate end1, Coordinate sta
 				board.PlaceRoad(start2, end2, *this);
 			}
 			developmentCards[ROADBUILDING]--;
-			board.discardCard(new RoadBuildingCard());
+			board.discardCard(ROADBUILDING);
 			return true;
 		}
 	}
diff --git a/tests/testSerialization.cpp b/tests/testSerialization.cpp
@@ -7,7 +7,6 @@
 
 #include "Serialization.h"
 #include "GameBoard.h"
-#include "DevelopmentCard.h"
 #include "Player.h"
 
 #include "tinyxml2.h"
@@ -41,17 +40,12 @@ TEST(SerializationTest, testCardSerialization) {
 	Player& testPlayer = testBoard.getPlayer(0);
 
 
-	std::unique_ptr<DevelopmentCard> knight_card = unique_ptr<DevelopmentCard>(new KnightCard());
-	std::unique_ptr<DevelopmentCard> victory_card = unique_ptr<DevelopmentCard>(new VictoryPointCard());
-	std::unique_ptr<DevelopmentCard> plenty_card = unique_ptr<DevelopmentCard>(new YearOfPlentyCard());
-	std::unique_ptr<DevelopmentCard> monopoly_card = unique_ptr<DevelopmentCard>(new MonopolyCard());
-	std::unique_ptr<DevelopmentCard> road_card = std::unique_ptr<DevelopmentCard>(new RoadBuildingCard());
 
-	testPlayer.buyCard(knight_card);
-	testPlayer.buyCard(victory_card);
-	testPlayer.buyCard(plenty_card);
-	testPlayer.buyCard(monopoly_card);
-	testPlayer.buyCard(road_card);
+	testPlayer.buyCard(KNIGHT);
+	testPlayer.buyCard(VICTORYPOINT);
+	testPlayer.buyCard(YEAROFPLENTY);
+	testPlayer.buyCard(MONOPOLY);
+	testPlayer.buyCard(ROADBUILDING);
 
 	stringstream stream;
 	testBoard.save(stream);
diff --git a/tests/test_Deck.cpp b/tests/test_Deck.cpp
diff --git a/tests/test_DevelopmentCards.cpp b/tests/test_DevelopmentCards.cpp
diff --git a/tests/test_Player.cpp b/tests/test_Player.cpp

Original file line number	Diff line number	Diff line change
`@@ -13,31 +13,25 @@`
`13`	`13`	`*/`
`14`	`14`	`Deck::Deck()`
`15`	`15`	`{`
`16`		`- // TODO Auto-generated constructor stub`
`17`	`16`	`for(int i = 0; i < 15; i++)`
`18`	`17`	`{`
`19`		`- DevelopmentCard* card = new KnightCard();`
`20`		`- this->deck.push_back(card);`
	`18`	`+ this->deck.push_back(KNIGHT);`
`21`	`19`	`}`
`22`	`20`	`for(int i = 0; i < 4; i++)`
`23`	`21`	`{`
`24`		`- DevelopmentCard* card = new VictoryPointCard();`
`25`		`- this->deck.push_back(card);`
	`22`	`+ this->deck.push_back(VICTORYPOINT);`
`26`	`23`	`}`
`27`	`24`	`for(int i = 0; i < 2; i++)`
`28`	`25`	`{`
`29`		`- DevelopmentCard* card = new YearOfPlentyCard();`
`30`		`- this->deck.push_back(card);`
	`26`	`+ this->deck.push_back(YEAROFPLENTY);`
`31`	`27`	`}`
`32`	`28`	`for(int i = 0; i < 2; i++)`
`33`	`29`	`{`
`34`		`- DevelopmentCard* card = new MonopolyCard();`
`35`		`- this->deck.push_back(card);`
	`30`	`+ this->deck.push_back(MONOPOLY);`
`36`	`31`	`}`
`37`	`32`	`for(int i = 0; i < 2; i++)`
`38`	`33`	`{`
`39`		`- DevelopmentCard* card = new RoadBuildingCard();`
`40`		`- this->deck.push_back(card);`
	`34`	`+ this->deck.push_back(ROADBUILDING);`
`41`	`35`	`}`
`42`	`36`
`43`	`37`	`shuffleDeck();`
`@@ -49,19 +43,7 @@ Deck::Deck()`
`49`	`43`	`Deck::~Deck() {`
`50`	`44`	`// TODO Auto-generated destructor stub`
`51`	`45`
`52`		`- while(!this->deck.empty())`
`53`		`- {`
`54`		`- delete this->deck.back();`
`55`		`- this->deck.pop_back();`
`56`		`- //std::cout<<":";`
`57`		`- }`
`58`		`-`
`59`		`- while(!this->discardPile.empty())`
`60`		`- {`
`61`		`- delete this->discardPile.back();`
`62`		`- this->discardPile.pop_back();`
`63`		`- //std::cout<<":";`
`64`		`- }`
	`46`	`+`
`65`	`47`	`}`
`66`	`48`
`67`	`49`	`/**`
`@@ -77,7 +59,7 @@ int Deck::getSize()`
`77`	`59`	`* Pull a random card from the deck. If the deck is empty, reshuffle it.`
`78`	`60`	`* @return An owning raw pointer to a random card from the deck.`
`79`	`61`	`*/`
`80`		`-DevelopmentCard* Deck::drawCard()`
	`62`	`+DevCardType Deck::drawCard()`
`81`	`63`	`{`
`82`	`64`	`if(this->getSize() == 0)`
`83`	`65`	`{`
`@@ -86,10 +68,10 @@ DevelopmentCard* Deck::drawCard()`
`86`	`68`
`87`	`69`	`if(this->getSize() == 0)`
`88`	`70`	`{`
`89`		`- return NULL;`
	`71`	`+ return NULLTYPE;`
`90`	`72`	`}`
`91`	`73`
`92`		`- DevelopmentCard* card = this->deck.back();`
	`74`	`+ DevCardType card = this->deck.back();`
`93`	`75`	`this->deck.pop_back();`
`94`	`76`	`return card;`
`95`	`77`	`}`
`@@ -120,7 +102,7 @@ void Deck::reshuffleDeck()`
`120`	`102`	`* Return a played card to the discard pile.`
`121`	`103`	`* @param toDiscard An owning raw pointer to the card to discard.`
`122`	`104`	`*/`
`123`		`-void Deck::discard(DevelopmentCard* toDiscard)`
	`105`	`+void Deck::discard(DevCardType toDiscard)`
`124`	`106`	`{`
`125`	`107`	`discardPile.push_back(toDiscard);`
`126`	`108`	`}`