Merge remote-tracking branch 'origin/road_implementation' into serialization

Conflicts:
	include/GameBoard.h
	include/Player.h
	include/Road.h
	src/GameBoard.cpp
	src/Road.cpp
	tests/test_GameBoard.cpp

Author: Databean

include/GameBoard.h

@@ -22,14 +22,25 @@ class GameBoard {
 private:
 	std::map<Coordinate, std::unique_ptr<GamePiece>> corners;
 	std::map<Coordinate, std::unique_ptr<GamePiece>> resources;
-	
-	std::vector<std::unique_ptr<Road>> roads;
 	std::vector<std::unique_ptr<Player>> players;
 
     void addResource(int x, int y, resourceType res, int val);
     bool checkRolls(int* rolls);
-    
 
+	std::map<Coordinate, std::vector<Road*>> roads;
+	
+	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);
+
+	int constructBoardFromFile(std::ifstream &file);
+	int constructFileFromBoard(std::ofstream &file);
+
+	void freeRoads();
+	void removeRoadEnd(Road * startRoad);
+	int FindLongestRoad_FromPoint(Coordinate curr, Player & owner, std::map<Coordinate, bool>& marked, int length);
+
 public:
 	GameBoard(std::vector<std::unique_ptr<Player>>&& players);
 	GameBoard(std::istream& in);
@@ -40,10 +51,15 @@ class GameBoard {
 	void save(std::ostream& out);
 
 	const std::map<Coordinate, std::unique_ptr<GamePiece>>& getResources() const;
+	Road * getRoad(Coordinate start, Coordinate end);
 
+	int FindLongestRoad(Player & owner);
+
 	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location);
 
 	void PlaceSettlement(Coordinate location, Player& Owner);
+	void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
+
 
 	void init_resources();
 

include/Player.h

@@ -52,6 +52,8 @@ class Player {
     int getDevCardsInHand();
 
     void buyCard(std::unique_ptr<DevelopmentCard> card);
+    std::string getName() const;
+
     void playCard(DevelopmentCard* card);
 
     int getWood() const;
@@ -66,8 +68,6 @@ class Player {
     void setWheat(int resource);
     void setWool(int resource);
 
-    std::string getName() const;
-	
 	void accept(GameVisitor& visitor);
 	bool operator==(const Player& player) const;
 };

include/Road.h

@@ -2,28 +2,44 @@
 #define ROAD_H
 
 #include "Util.h"
+#include "Player.h"
+#include <vector>
+#include <cmath>
 
 #include "Player.h"
 
 class GameVisitor;
 
 class Road {
 private:
-	Player& owner;
+	bool checkRoad();
+	
 	Coordinate start;
 	Coordinate end;
+
+	bool marker;
 public:
-	Road(Player& owner, Coordinate start, Coordinate end);
+	Road(Coordinate start, Coordinate end, Player& Owner);
 	Road(Road&) = delete;
-	~Road();
+	virtual ~Road();
 	Road& operator=(Road&) = delete;
-	
-	virtual void accept(GameVisitor& visitor);
+
 	Coordinate getStart() const;
 	Coordinate getEnd() const;
+
+	bool equals(const Road& otherRoad);
+	bool equals(const Coordinate& otherStart, const Coordinate& otherEnd);
+
+	bool isMarked();
+	void mark();
+	void unmark();
+	
 	Player& getOwner();
 	const Player& getOwner() const;
+
+	Player* owner;
 
+	virtual void accept(GameVisitor& visitor);
 	bool operator==(const Road&) const;
 };
 

src/GameBoard.cpp

@@ -66,7 +66,46 @@ GameBoard::GameBoard(istream& in) {
 }
 
 GameBoard::~GameBoard() {
-	
+	freeRoads();
+}
+
+/*
+ * Frees the roads data structure to prevent memory leaks
+ */
+
+void GameBoard::freeRoads(){
+	//Iterate over all the points in the roads map
+	for (auto roadVector = roads.begin(); roadVector != roads.end(); ++roadVector)
+	{
+		//Iterate all the roads at a given point
+		for (std::vector<Road*>::iterator road = roadVector->second.begin(); road != roadVector->second.end(); ++road) {
+			Road * roadPtr = *road;
+
+			//If this is the start of the road we want to remove it, but we must first erase it the list at the other end of the road
+			//If we don't then we may try to access a road which has already been freed
+			if(roadPtr != NULL && roadPtr->getStart() == roadVector->first){
+				removeRoadEnd(roadPtr);
+				roadVector->second.erase(road);
+				//Need to decrement the iterator to account for the lost item
+				road--;
+				delete roadPtr;
+			}
+		}
+	}
+}
+
+/**
+ * Find and remove the road that matches startRoad
+ */
+void GameBoard::removeRoadEnd(Road * startRoad){
+	std::vector<Road*> endRoadVector = roads[startRoad->getEnd()];
+	for(std::vector<Road*>::iterator endRoad = endRoadVector.begin(); endRoad != endRoadVector.end(); ++endRoad){
+		if((*endRoad) == startRoad){
+			endRoadVector.erase(endRoad);
+			//Need to decrement the iterator to account for the lost item
+			endRoad--;
+		}
+	}
 }
 
 void GameBoard::save(ostream& out) {
@@ -81,29 +120,203 @@ const map<Coordinate, unique_ptr<GamePiece>>& GameBoard::getResources() const {
 	return resources;
 }
 
-std::vector<Settlement*> GameBoard::GetNeighboringSettlements(Coordinate location) {
-	static Coordinate adjacentCoordDiffs[] = {Coordinate(0, 1), Coordinate(1, 0), Coordinate(1, -1), Coordinate(0, -1), Coordinate(-1, 0), Coordinate(-1, 1)};
+std::vector<Settlement*> GameBoard::GetNeighboringSettlements(
+		Coordinate location) {
+	static Coordinate adjacentCoordDiffs[] = { Coordinate(0, 1), Coordinate(1,
+			0), Coordinate(1, -1), Coordinate(0, -1), Coordinate(-1, 0),
+			Coordinate(-1, 1) };
 	std::vector<Settlement*> v;
-	for(unsigned int i = 0; i < 6; i++) {
+	for (unsigned int i = 0; i < 6; i++) {
 		const Coordinate& diff = adjacentCoordDiffs[i];
-		Coordinate adjacentPoint(location.first + diff.first, location.second + diff.second);
+		Coordinate adjacentPoint(location.first + diff.first,
+				location.second + diff.second);
 		auto it = resources.find(adjacentPoint);
-		if(it != resources.end()) {
+		if (it != resources.end()) {
 			GamePiece* piece = it->second.get();
-			if(dynamic_cast<Settlement*>(piece)) {
+			if (dynamic_cast<Settlement*>(piece)) {
 				v.push_back(static_cast<Settlement*>(piece));
 			}
 		}
 	}
 	return v;
 }
 
+/**
+ * Checks to make sure the coordinate is within bounds of the board
+ */
+bool GameBoard::outOfBounds(const Coordinate& coord) {
+	/**
+	 * This code is embarrassing, but I couldn't really figure out how to easily check for out of bounds
+	 * I'm sure there is a simple algebraic function that does it, but I went for the hacky way.
+	 *
+	 * 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);
+		break;
+	case 1:
+		return !(coord.first >= -2 && coord.first <= 5);
+		break;
+	case 2:
+		return !(coord.first >= -3 && coord.first <= 5);
+		break;
+	case 3:
+		return !(coord.first >= -3 && coord.first <= 4);
+		break;
+	case 4:
+		return !(coord.first >= -4 && coord.first <= 4);
+		break;
+	case 5:
+		return !(coord.first >= -4 && coord.first <= 3);
+		break;
+	case 6:
+		return !(coord.first >= -5 && coord.first <= 3);
+		break;
+	case 7:
+		return !(coord.first >= -5 && coord.first <= 2);
+		break;
+	case 8:
+		return !(coord.first >= -4 && coord.first <= 0);
+		break;
+	default:
+		break;
+	}
+	return true;
+}
+
+/**
+ * Checks to make sure the road doesn't already exist. If it does, then we don't want to add it again
+ */
+bool GameBoard::roadExists(Coordinate start, Coordinate end) {
+	Road * isRoad = getRoad(start, end);
+	if (isRoad == NULL)
+		return false;
+	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)
+			return true;
+	}
+	return false;
+	**/
+	return true;
+}
+
+/**
+ * Runs a series of checks to make sure the road can be placed
+ */
+bool GameBoard::verifyRoadPlacement(Coordinate start, Coordinate end, Player& Owner) {
+	if (outOfBounds(start) || outOfBounds(end))
+		return false;
+
+	if (roadExists(start, end))
+		return false;
+
+	if (!isRoadConnectionPoint(start, end, Owner))
+		return false;
+
+	return true;
+}
+
+/**
+ * Places a road at the specified coordinates that will be owned by the given player
+ */
+void GameBoard::PlaceRoad(Coordinate start, Coordinate end, Player& Owner) {
+	if (!verifyRoadPlacement(start, end, Owner))
+		return;
+
+	Road * newRoad;
+	try {
+		newRoad = new Road(start, end, Owner);
+	} catch (int n) {
+		//Coordinates did not meet the criteria for a valid road
+		return;
+	}
+	std::vector<Road*> roadVector = roads[start];
+	roadVector.push_back(newRoad);
+	roads[start] = roadVector;
+
+	roadVector = roads[end];
+	roadVector.push_back(newRoad);
+	roads[end] = roadVector;
+}
+
+/**
+ * returns a pointer to the road located at the specified coordinates. Will return NULL if the road is not found
+ */
+Road * GameBoard::getRoad(Coordinate start, Coordinate end){
+	std::vector<Road*> roadVector = roads[start];
+	for (std::vector<Road*>::iterator road = roadVector.begin(); road != roadVector.end(); ++road) {
+		if ((*road)->equals(start, end))
+			return *road;
+	}
+	return NULL;
+}
+
+/**
+ * Parent function for the find longest road traversal. Note that longest path is NP-Hard, so there is no simple algorithm for this.
+ */
+int GameBoard::FindLongestRoad(Player & owner){
+	int longest_path = 0;
+	//for each road vertex v on the board
+	for (auto roadVector = roads.begin(); roadVector != roads.end(); ++roadVector){
+		//find the longest path from v
+		std::map<Coordinate, bool> marked;
+		Coordinate start = roadVector->first;
+		int temp_longest_path = FindLongestRoad_FromPoint(start, owner, marked, 0);
+
+		//if that path is longer than the current longest, set to the longest
+		if (temp_longest_path > longest_path)
+			longest_path = temp_longest_path;
+	}
+
+	return longest_path;
+}
+
+
+int GameBoard::FindLongestRoad_FromPoint(Coordinate curr, Player & owner, std::map<Coordinate, bool>& marked, int length){
+	marked[curr] = true;
+	int longest_path = length;
+	//traverse all the surrounding edges and vertices
+	std::vector<Road*> roadVector = roads[curr];
+	for (std::vector<Road*>::iterator road = roadVector.begin(); road != roadVector.end(); ++road) {
+		int temp_longest_path = length;
+
+		//if the owner is correct and the road is unmarked
+		if ( !(*road)->isMarked() && (*road)->owner->getName().compare(owner.getName()) == 0){
+
+			temp_longest_path++;
+			(*road)->mark();
+			//Check if you can traverse to the next vertex and make that step if you can
+			if(curr != (*road)->getStart() && !marked[(*road)->getStart()]){
+				temp_longest_path = FindLongestRoad_FromPoint((*road)->getStart(), owner, marked, temp_longest_path);
+			}else if (curr != (*road)->getEnd() && !marked[(*road)->getEnd()]){
+				temp_longest_path = FindLongestRoad_FromPoint((*road)->getEnd(), owner, marked, temp_longest_path);
+			}
+			(*road)->unmark();
+		}
+
+		if(temp_longest_path > longest_path)
+			longest_path = temp_longest_path;
+	}
+	marked[curr] = false;
+	return longest_path;
+}
+
 /* 
  *   Initialize board with a set of resources. 
  *   Currently only the standard configuration (no custom shapes or expansion packs) is implemented.
  *   Board tiles and roll numbers are randomized.
  */
-
 void GameBoard::init_resources()
 {
     std::srand(std::time(0));
@@ -150,9 +363,6 @@ void GameBoard::accept(GameVisitor& visitor) {
 	for(auto& it : resources) {
 		it.second->accept(visitor);
 	}
-	for(auto& it : roads) {
-		it->accept(visitor);
-	}
 	for(auto& it : players) {
 		it->accept(visitor);
 	}
@@ -180,17 +390,6 @@ bool GameBoard::operator==(const GameBoard& other) const {
 			return false;
 		}
 	}
-	for(auto& it : roads) {
-		bool hasIt = false;
-		for(auto& otherIt : other.roads) {
-			if(*it == *otherIt) {
-				hasIt = true;
-			}
-		}
-		if(hasIt == false) {
-			return false;
-		}
-	}
 	if(players.size() != other.players.size()) {
 		return false;
 	}