Merge branch 'dice_operations' of https://github.com/Databean/warsofcatan into dice_operations

Author: malecki1

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

@@ -16,14 +16,21 @@
 #include "tinyxml2.h"
 #include "Road.h"
 
+
 class GameVisitor;
 
 class GameBoard {
 private:
 	std::map<Coordinate, std::unique_ptr<CornerPiece>> corners;
-	std::map<Coordinate, std::unique_ptr<GamePiece>> resources;
+
+	std::map<Coordinate, std::unique_ptr<ResourceTile>> resources;
+
+
 	std::map<Coordinate, std::vector<std::shared_ptr<Road>>> roads;
+
 	std::vector<std::unique_ptr<Player>> players;
+	Coordinate robber;
+
 
     void addResource(int x, int y, resourceType res, int val);
     bool checkRolls(int* rolls);
@@ -53,16 +60,30 @@ 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;
+
+
+
 	const std::shared_ptr<Road> getRoad(Coordinate start, Coordinate end) const;
+
 
 	int FindLongestRoad(const Player & owner) const;
 
-	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location);
+	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location) const;
+	std::vector<CornerPiece*> GetNeighboringCorners(Coordinate location) const;
+
 
-	bool buyRoad(Coordinate start, Coordinate end, Player& Owner);
 
 	void PlaceSettlement(Coordinate location, Player& Owner);
+	void UpgradeSettlement(Coordinate location);
+	//void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
+
+
+	bool buyRoad(Coordinate start, Coordinate end, Player& Owner);
+
+
+	//void PlaceSettlement(Coordinate location, Player& Owner);
 	void PlaceCity(Coordinate location, Player& Owner);
 	bool PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
 
@@ -71,6 +92,10 @@ class GameBoard {
 	bool operator==(const GameBoard& other) const;
 
     bool testRollChecking(int* rolls);
+
+    void moveRobber(Coordinate newRobber);
+    Coordinate getRobber() const;
+
 };
 
 #endif

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

@@ -86,6 +86,8 @@ class Player {
     void addWheat(int resource);
     void addWool(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;
+}
+
+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

@@ -11,6 +11,9 @@
 #include "GameVisitor.h"
 #include "Serialization.h"
 #include "tinyxml2.h"
+
+#include "CornerPiece.h"
+
 #include "City.h"
 
 using std::shared_ptr;
@@ -82,7 +85,7 @@ void GameBoard::insertTile(Coordinate location, vector<resourceType>& resources,
 
 GameBoard::GameBoard(std::vector<std::unique_ptr<Player>>&& players, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations) : players(std::move(players)) {
 	for(auto& resource : resourceLocations) {
-		resources[resource.first] = std::unique_ptr<GamePiece>(new ResourceTile(*this, resource.first, resource.second.first, resource.second.second));
+		resources[resource.first] = std::unique_ptr<ResourceTile>(new ResourceTile(*this, resource.first, resource.second.first, resource.second.second));
 	}
 	if(!isValidBoard()) {
 		throw std::runtime_error("Board is invalid.");
@@ -217,12 +220,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) };
@@ -231,8 +234,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));
@@ -242,6 +245,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 and not a resource tile.
  */
@@ -267,6 +292,7 @@ bool GameBoard::roadExists(Coordinate start, Coordinate end) const {
 /**
  * Checks to make sure the road being placed at a valid point according to the rules
  */
+
 bool GameBoard::isRoadConnectionPoint(Coordinate point, Player& Owner) const {
 	//is there a settlement we can build off of
 	auto cornerIt = corners.find(point);
@@ -290,6 +316,7 @@ bool GameBoard::isRoadConnectionPoint(Coordinate point, Player& Owner) const {
 
 	return false;
 
+
 }
 
 /**
@@ -309,6 +336,18 @@ bool GameBoard::verifyRoadPlacement(Coordinate start, Coordinate end, Player& Ow
 	return true;
 }
 
+void GameBoard::moveRobber(Coordinate newRobber) {
+
+	robber = newRobber;
+
+	//force trade	
+}
+
+Coordinate GameBoard::getRobber() const {
+	return robber;
+
+}
+
 /**
  * Places a road at the specified coordinates that will be owned by the given player
  * returns true if the road was placed, false otherwise
@@ -412,44 +451,58 @@ int GameBoard::FindLongestRoad_FromPoint(Coordinate curr, const Player & owner,
 	return longest_path;
 }
 
+
+
 void GameBoard::PlaceSettlement(Coordinate location, Player& Owner){
 	corners[location] = std::unique_ptr<CornerPiece>(new Settlement(*this, location, Owner));
 }
 
 void GameBoard::PlaceCity(Coordinate location, Player& Owner){
 	corners[location] = std::unique_ptr<CornerPiece>(new City(*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);
+
+
 	// Drawing needs this to happen in this order. Visitors technically should be order-independent, but this was an easy fix at the moment.
 	// Keep that in mind when modifying this.
 	for(auto& it : resources) {
 		it.second->accept(visitor);
 	}
 	for(auto& it : corners) {
 		it.second->accept(visitor);
+
 	}
 	for(auto& roadCoordVec : roads) {
 		for(auto& road : roadCoordVec.second) {
-			road->accept(visitor);
+			if(road.get()) {
+				road->accept(visitor);
+			}
 		}
 	}
 	for(auto& it : players) {
-		it->accept(visitor);
+		if(it.get()) {
+			it->accept(visitor);
+		}
 	}
 }
 
 bool GameBoard::operator==(const GameBoard& other) const {
-	if(corners.size() != other.corners.size()) {
-		return false;
-	}
 	for(auto& it : corners) {
 		auto otherIt = other.corners.find(it.first);
 		if(otherIt == other.corners.end()) {
-			return false; // This location isn't in the other array
-		}
-		if(!(*(it.second) == *(otherIt->second))) {
+			if(it.second.get()) {
+				return false; // This location isn't in the other array
+			}
+		} else if(!(*(it.second) == *(otherIt->second))) {
 			return false;
 		}
 	}
@@ -481,12 +534,10 @@ bool GameBoard::operator==(const GameBoard& other) const {
 		}
 	}
 	if(players.size() != other.players.size()) {
-		std::cout << "sizes differ" << std::endl;
 		return false;
 	}
 	for(unsigned int i = 0; i < players.size(); i++) {
 		if(!(*(players[i]) == *(other.players[i]))) {
-			std::cout << "player " << i << " differs" << std::endl;
 			return false;
 		}
 	}
@@ -510,7 +561,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));
 }
 
 bool GameBoard::isValidBoard() const {