Began working on placing Roads. Code is still untested. Roads are added

through interacting with the GameBoard

Author: PickledMonkey

include/GameBoard.h

@@ -20,8 +20,14 @@ class GameBoard {
 private:
 	std::map<Coordinate, std::unique_ptr<GamePiece>> corners;
 	std::map<Coordinate, std::unique_ptr<GamePiece>> resources;
-	std::vector<std::unique_ptr<const Road>> roads;
+
+	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);
 public:
@@ -33,10 +39,13 @@ class GameBoard {
 	int save_Board(std::string filename);
 	int load_Board(std::string filename);
 	const std::map<Coordinate, std::unique_ptr<GamePiece>>& getResources() const;
+	const Road& getRoad(int start, int end);
 
 	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

@@ -60,7 +60,6 @@ class Player {
     void setWheat(int resource);
     void setWool(int resource);
 
-
 };
 
 #endif

include/Road.h

@@ -2,16 +2,32 @@
 #define ROAD_H
 
 #include "Util.h"
+#include "Player.h"
+#include <vector>
+#include <cmath>
 
 class Road {
 private:
-	Coordinate start;
-	Coordinate end;
+	bool checkRoad();
+
 public:
-	Road(Coordinate start, Coordinate end);
+	Road(Coordinate start, Coordinate end, Player& Owner);
 	Road(Road&) = delete;
 	~Road();
 	Road& operator=(Road&) = delete;
+
+	//Made these public because I couldn't get getters to work, maybe someone else knows how. Paul
+	Coordinate start;
+	Coordinate end;
+
+	Coordinate getStart();
+
+	bool equals(const Road& otherRoad);
+	bool equals(const Coordinate& otherStart, const Coordinate& otherEnd);
+
+	Player* owner;
+
+
 };
 
 #endif

src/GameBoard.cpp

@@ -21,11 +21,10 @@ GameBoard::GameBoard() {
 }
 
 GameBoard::~GameBoard() {
-	
-}
 
+}
 
-int GameBoard::save_Board(std::string filename){
+int GameBoard::save_Board(std::string filename) {
 	std::ofstream file;
 	file.exceptions(std::ofstream::failbit | std::ofstream::badbit);
 	try {
@@ -40,7 +39,7 @@ int GameBoard::save_Board(std::string filename){
 	return -1;
 }
 
-int GameBoard::load_Board(std::string filename){
+int GameBoard::load_Board(std::string filename) {
 	std::ifstream file;
 	try {
 		filename = filename + ".wocs";
@@ -54,7 +53,7 @@ int GameBoard::load_Board(std::string filename){
 	return -1;
 }
 
-int GameBoard::constructBoardFromFile(std::ifstream &file){
+int GameBoard::constructBoardFromFile(std::ifstream &file) {
 	//Parse and construct the board from the file
 	//@ TODO
 	std::string line;
@@ -66,8 +65,7 @@ int GameBoard::constructBoardFromFile(std::ifstream &file){
 	return 0;
 }
 
-
-int GameBoard::constructFileFromBoard(std::ofstream &file){
+int GameBoard::constructFileFromBoard(std::ofstream &file) {
 	//Construct the file based on the structure of the board
 	//@ TODO
 	file << "Hello World!";
@@ -78,16 +76,20 @@ 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));
 			}
 		}
@@ -96,41 +98,133 @@ std::vector<Settlement*> GameBoard::GetNeighboringSettlements(Coordinate locatio
 }
 
 /* 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.
-    @todo Change the dummy board to the actual board
+ @todo Change the dummy board to the actual board
  */
 
-void GameBoard::init_resources()
-{
-    std::srand(std::time(0));
-    
-    resourceType resources[] = {BRICK, BRICK, BRICK, STONE, STONE, STONE, WHEAT, WHEAT, WHEAT, WHEAT, WOOD, WOOD, WOOD, WOOD, SHEEP, SHEEP, SHEEP, SHEEP, DESERT};
-    random_shuffle(&resources[0], &resources[19]);
-    
-    int rolls[] = {2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11};
-    random_shuffle(&rolls[0], &rolls[18]);
-    
-    int xcoords[] = {0, -2, 2, -3, -1, 1, 3, -4, -2, 0, 2, 4, -3, -1, 1, 3, -2, 0, 2};
-    int ycoords[] = {1,  2, 0,  4,  3, 2, 1,  6, 5,  4, 3, 2,  7,  6, 5, 4,  8, 7, 6};
-	
-    
-    #ifdef DUMMY_BOARD
-    int rollCount = 0;
-    for (int i = 0; i<19; i++)
-    {
-        if (resources[i]==DESERT)
-        {
-            ADD_RESOURCE(xcoords[i], ycoords[i], resources[i], 0);
-        }
-        else
-        {
-            ADD_RESOURCE(xcoords[i], ycoords[i], resources[i], rolls[rollCount]);
-            rollCount++;
-        }
-    }
-    #endif
+void GameBoard::init_resources() {
+	std::srand(std::time(0));
+
+	resourceType resources[] = { BRICK, BRICK, BRICK, STONE, STONE, STONE,
+			WHEAT, WHEAT, WHEAT, WHEAT, WOOD, WOOD, WOOD, WOOD, SHEEP, SHEEP,
+			SHEEP, SHEEP, DESERT };
+	random_shuffle(&resources[0], &resources[19]);
+
+	int rolls[] = { 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11 };
+	random_shuffle(&rolls[0], &rolls[18]);
+
+	int xcoords[] = { 0, -2, 2, -3, -1, 1, 3, -4, -2, 0, 2, 4, -3, -1, 1, 3, -2,
+			0, 2 };
+	int ycoords[] = { 1, 2, 0, 4, 3, 2, 1, 6, 5, 4, 3, 2, 7, 6, 5, 4, 8, 7, 6 };
+
+#ifdef DUMMY_BOARD
+	int rollCount = 0;
+	for (int i = 0; i < 19; i++) {
+		if (resources[i] == DESERT) {
+			ADD_RESOURCE(xcoords[i], ycoords[i], resources[i], 0);
+		} else {
+			ADD_RESOURCE(xcoords[i], ycoords[i], resources[i],
+					rolls[rollCount]);
+			rollCount++;
+		}
+	}
+#endif
+}
+
+void GameBoard::PlaceSettlement(Coordinate location, Player& Owner) {
+	corners[location] = std::unique_ptr < GamePiece
+			> (new Settlement(*this, location, Owner));
 }
 
-void GameBoard::PlaceSettlement(Coordinate location, Player& Owner){
-	corners[location] = std::unique_ptr<GamePiece>(new Settlement(*this, location, Owner));
+/**
+ * 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.
+	 */
+	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 false;
+}
+
+bool GameBoard::roadExists(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 true;
+	}
+	return false;
+}
+
+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;
+}
+
+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;
+}
+
+void GameBoard::PlaceRoad(Coordinate start, Coordinate end, Player& Owner) {
+	verifyRoadPlacement(start, end, Owner);
+	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);
+
+	roadVector = roads[end];
+	roadVector.push_back(newRoad);
 }
 

src/Player.cpp

@@ -63,7 +63,6 @@ void Player::playCard(DevelopmentCard *card)
 
 
 
-
 int Player::getWood()
 {
     return resources[0];

src/Road.cpp

@@ -1,15 +1,47 @@
 #include "Road.h"
 
-Road::Road(Coordinate start, Coordinate end) {
+Road::Road(Coordinate start, Coordinate end, Player& Owner) {
 	if(start < end) {
 		this->start = start;
 		this->end = end;
 	} else {
 		this->end = start;
 		this->start = end;
 	}
+	owner = &Owner;
+
+	//If the input is bad, throw an exception so bad roads won't be built
+	if(!checkRoad())
+		throw -1;
+
+}
+
+/**
+ * Valid roads must start in one point and end in another point a distance of 1 away.
+ */
+bool Road::checkRoad(){
+
+	int dist = std::abs(start.first - end.first) + std::abs(start.second - end.second);
+	return dist == 1;
 }
 
 Road::~Road() {
 
-}
+}
+
+Coordinate Road::getStart(){
+	return start;
+}
+
+bool Road::equals(const Road& otherRoad){
+	Coordinate otherstart = otherRoad.start;
+	Coordinate otherend = otherRoad.end;
+	return equals(otherstart, otherend);
+}
+
+bool Road::equals(const Coordinate& otherStart, const Coordinate& otherEnd){
+	if((otherStart == start && otherEnd == end) || (otherStart == end && otherEnd == start))
+		return true;
+	return false;
+}
+

src/main.cpp

@@ -43,7 +43,7 @@ int main(int argc, char *argv[]) {
 	SDL_Window* displayWindow;
 	SDL_Renderer* displayRenderer;
 	SDL_RendererInfo displayRendererInfo;
-	SDL_CreateWindowAndRenderer(900, 900, SDL_WINDOW_OPENGL, &displayWindow, &displayRenderer);
+	SDL_CreateWindowAndRenderer(900, 800, SDL_WINDOW_OPENGL, &displayWindow, &displayRenderer);
 	SDL_GetRendererInfo(displayRenderer, &displayRendererInfo);
 	/*TODO: Check that we have OpenGL */
 	if ((displayRendererInfo.flags & SDL_RENDERER_ACCELERATED) == 0 || 

tests/test_Roads.cpp

@@ -0,0 +1,15 @@
+/*
+ * test_Roads.cpp
+ *
+ *  Created on: Mar 1, 2014
+ *      Author: The Pickle
+ */
+#include "UnitTest++.h"
+#include "Road.h"
+#include "Util.h"
+
+TEST(road_constructor_1){
+	Coordinate start = Coordinate(0,0);
+	Coordinate end = Coordinate(0,1);
+}
+