added functionality for cities and settlements

Author: apolitakis

include/City.h

@@ -10,10 +10,14 @@ class City : public CornerPiece {
 	City(GameBoard& board, Coordinate location, Player& owner);
 	City(City&) = delete;
 	~City();
+	City(CornerPiece& sett);
 	City& operator=(City&) = delete;
 
 	virtual void accept(GameVisitor&);
 	virtual bool operator==(const GamePiece& piece) const;
+
+	int getResourceModifier();
+	int getVictoryPoints();
 };
 
 #endif

include/CornerPiece.h

@@ -15,6 +15,10 @@ class CornerPiece : public GamePiece {
 
 	Player& getOwner();
 	const Player& getOwner() const;
+
+	virtual int getResourceModifier();
+
+	virtual int getVictoryPoints();
 };
 
 #endif

include/GameBoard.h

@@ -20,8 +20,8 @@ class GameVisitor;
 
 class GameBoard {
 private:
-	std::map<Coordinate, std::unique_ptr<GamePiece>> corners;
-	std::map<Coordinate, std::unique_ptr<GamePiece>> resources;
+	std::map<Coordinate, std::unique_ptr<CornerPiece>> corners;
+	std::map<Coordinate, std::unique_ptr<ResourceTile>> resources;
 	std::vector<std::unique_ptr<Player>> players;
 
     void addResource(int x, int y, resourceType res, int val);
@@ -49,14 +49,17 @@ class GameBoard {
 
 	void save(std::ostream& out);
 
-	const std::map<Coordinate, std::unique_ptr<GamePiece>>& getResources() const;
+	const std::map<Coordinate, std::unique_ptr<ResourceTile>>& getResources() const;
 	std::shared_ptr<Road> getRoad(Coordinate start, Coordinate end);
 
 	int FindLongestRoad(Player & owner);
 
-	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location);
+	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location) const;
+	std::vector<CornerPiece*> GetNeighboringCorners(Coordinate location) const;
+
 
 	void PlaceSettlement(Coordinate location, Player& Owner);
+	void UpgradeSettlement(Coordinate location);
 	void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
 
 

include/GamePiece.h

@@ -13,6 +13,7 @@ class GameBoard;
 class GamePiece {
 private:
 	GameBoard& board;
+
 public:
 	GamePiece(GameBoard& board, Coordinate location);
 	GamePiece(GamePiece&) = delete;
@@ -29,6 +30,7 @@ class GamePiece {
 	virtual bool operator==(const GamePiece& other) const = 0;
 
 	Coordinate getLocation() const;
+
 };
 
 class ResourceTile : public GamePiece {
@@ -39,7 +41,7 @@ class ResourceTile : public GamePiece {
 	//virtual ResourceTile& operator=(ResourceTile&) = delete;
 
 	//dispense resource cards to owning players
-	void Payout();
+	void Payout() const;
 
 	resourceType resource;
 	int value;

include/Player.h

@@ -84,6 +84,8 @@ class Player {
     void setWheat(int resource);
     void setWool(int resource);
 
+    void addResource(int resourceType, int delta);
+
 	void accept(GameVisitor& visitor);
 	bool operator==(const Player& player) const;
 };

include/Settlement.h

@@ -14,6 +14,8 @@ class Settlement : public CornerPiece {
 
 	virtual void accept(GameVisitor&);
 	virtual bool operator==(const GamePiece&) const;
+	int getResourceModifier();
+	int getVictoryPoints();
 };
 
 #endif

src/City.cpp

@@ -1,5 +1,5 @@
 #include "City.h"
-
+#include "Settlement.h"
 #include "GameVisitor.h"
 
 City::City(GameBoard& board, Coordinate location, Player& owner) : CornerPiece(board, location, owner) {
@@ -17,3 +17,15 @@ void City::accept(GameVisitor& visitor) {
 bool City::operator==(const GamePiece& p) const {
 	return false;
 }
+
+int City::getResourceModifier() {
+	return 2; //TODO: implement robber check here
+}
+
+int City::getVictoryPoints() {
+	return 2; //TODO: implement robber check here
+}
+
+City::City(CornerPiece& sett) : CornerPiece(sett.getBoard(), sett.getLocation(), sett.getOwner()) {
+
+}

src/CornerPiece.cpp

@@ -15,3 +15,12 @@ Player& CornerPiece::getOwner() {
 const Player& CornerPiece::getOwner() const {
 	return owner;
 }
+
+
+int CornerPiece::getVictoryPoints() {
+	return 0;
+}
+
+int CornerPiece::getResourceModifier() {
+	return 0;
+}

src/GameBoard.cpp

@@ -10,6 +10,8 @@
 #include "GameVisitor.h"
 #include "Serialization.h"
 #include "tinyxml2.h"
+#include "CornerPiece.h"
+#include "City.h"
 
 using std::shared_ptr;
 using std::random_shuffle;
@@ -111,12 +113,12 @@ void GameBoard::save(ostream& out) {
 	out << printer.CStr();
 }
 
-const map<Coordinate, unique_ptr<GamePiece>>& GameBoard::getResources() const {
+const map<Coordinate, unique_ptr<ResourceTile>>& GameBoard::getResources() const {
 	return resources;
 }
 
 std::vector<Settlement*> GameBoard::GetNeighboringSettlements(
-		Coordinate location) {
+		Coordinate location) const {
 	static Coordinate adjacentCoordDiffs[] = { Coordinate(0, 1), Coordinate(1,
 			0), Coordinate(1, -1), Coordinate(0, -1), Coordinate(-1, 0),
 			Coordinate(-1, 1) };
@@ -125,8 +127,8 @@ std::vector<Settlement*> GameBoard::GetNeighboringSettlements(
 		const Coordinate& diff = adjacentCoordDiffs[i];
 		Coordinate adjacentPoint(location.first + diff.first,
 				location.second + diff.second);
-		auto it = resources.find(adjacentPoint);
-		if (it != resources.end()) {
+		auto it = corners.find(adjacentPoint);
+		if (it != corners.end()) {
 			GamePiece* piece = it->second.get();
 			if (dynamic_cast<Settlement*>(piece)) {
 				v.push_back(static_cast<Settlement*>(piece));
@@ -136,6 +138,28 @@ std::vector<Settlement*> GameBoard::GetNeighboringSettlements(
 	return v;
 }
 
+std::vector<CornerPiece*> GameBoard::GetNeighboringCorners(
+		Coordinate location) const{
+	static Coordinate adjacentCoordDiffs[] = { Coordinate(0, 1), Coordinate(1,
+			0), Coordinate(1, -1), Coordinate(0, -1), Coordinate(-1, 0),
+			Coordinate(-1, 1) };
+	std::vector<CornerPiece*> v;
+	for (unsigned int i = 0; i < 6; i++) {
+		const Coordinate& diff = adjacentCoordDiffs[i];
+		Coordinate adjacentPoint(location.first + diff.first,
+				location.second + diff.second);
+		auto it = resources.find(adjacentPoint);
+		if (it != resources.end()) {
+			GamePiece* piece = it->second.get();
+			if (dynamic_cast<CornerPiece*>(piece)) {
+				v.push_back(static_cast<CornerPiece*>(piece));
+			}
+		}
+	}
+	return v;
+}
+
+
 /**
  * Checks to make sure the coordinate is within bounds of the board
  */
@@ -195,15 +219,15 @@ bool GameBoard::roadExists(Coordinate start, Coordinate end) {
  * 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)
+	
+	//std::unique_ptr<GamePiece> corner = corners[start];
+	if(corners[start] != NULL){
+		if (corners[start]->getOwner() == Owner)
 			return true;
 	}
 	return false;
-	**/
-	return true;
+	
+	
 }
 
 /**
@@ -347,9 +371,15 @@ void GameBoard::init_resources()
 }
 
 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::UpgradeSettlement(Coordinate location){
+	corners[location] = std::unique_ptr<CornerPiece>(new City(*corners[location])); //TODO test for memory leak
 }
 
+
+
 void GameBoard::accept(GameVisitor& visitor) {
 	visitor.visit(*this);
 	for(auto& it : corners) {
@@ -430,7 +460,7 @@ bool GameBoard::operator==(const GameBoard& other) const {
  */
 void GameBoard::addResource(int x, int y, resourceType res, int val)
 {
-    this->resources[Coordinate(x,y)] = std::unique_ptr<GamePiece>(new ResourceTile(*this, Coordinate(x,y), res, val));
+    this->resources[Coordinate(x,y)] = std::unique_ptr<ResourceTile>(new ResourceTile(*this, Coordinate(x,y), res, val));
 }
 
 /*

src/GamePiece.cpp

@@ -3,7 +3,8 @@
 #include "GameBoard.h"
 #include "GameVisitor.h"
 
-GamePiece::GamePiece(GameBoard& board, Coordinate location) : board(board), location(location) {
+GamePiece::GamePiece(GameBoard& board, Coordinate location) :
+board(board), location(location){
 
 }
 
@@ -58,12 +59,14 @@ bool ResourceTile::operator==(const GamePiece& other) const {
 }
 
 //pay resource cards to owners of this tile
-/*
-void ResourceTile::Payout() {
-	std::vector<GamePiece> neighbors = board.GetNeighbors(location);
-	for (int i = 0; i < neighbors.size; i++) //someone tell me how to traverse a vector less stupidly
+
+void ResourceTile::Payout() const{
+	std::vector<CornerPiece*> neighbors = getBoard().GetNeighboringCorners(location);
+	std::vector<CornerPiece*>::iterator it = neighbors.begin();
+	while (it != neighbors.end())
 	{
-		neighbors[i].owner.addresource(resource, 1 + neighbors[i].city)
+		(*it)->getOwner().addResource(resource, (*it)->getResourceModifier());
+		it++;
 	}
 }
-*/
+