Merge branch 'master' into dice_operations

Author: malecki1

include/GameBoard.h

@@ -66,7 +66,7 @@ class GameBoard {
 
 
 	const std::shared_ptr<Road> getRoad(Coordinate start, Coordinate end) const;
-
+	const std::vector<std::shared_ptr<Road>>& getRoads(Coordinate loc) const;
 
 	int FindLongestRoad(const Player & owner) const;
 
@@ -90,6 +90,8 @@ class GameBoard {
 	void accept(GameVisitor& visitor);
 
 	bool operator==(const GameBoard& other) const;
+	
+	const std::vector<std::unique_ptr<Player>>& getPlayers() const;
 
     bool testRollChecking(int* rolls);
 

include/GameController.h

@@ -2,16 +2,19 @@
 #define GAME_CONTROLLER_H
 
 class GameBoard;
+class ClickCoordinateEvent;
 
 class GameController {
 private:
-	GameBoard& board;
+	GameBoard& model;
 
-	GameController(const GameController& o) : board(o.board) {} //deleted
+	GameController(const GameController& o) : model(o.model) {} //deleted
 	GameController& operator=(const GameController& o) { return *this; } //deleted
 public:
 	GameController(GameBoard&);
 	~GameController();
+	
+	void handleEvent(const ClickCoordinateEvent&);
 };
 
 #endif

include/GameView.h

@@ -4,6 +4,7 @@
 #include "SDL2/SDL.h"
 
 #include "GameVisitor.h"
+#include "Util.h"
 
 class GameBoard;
 class GameController;
@@ -42,4 +43,16 @@ class DrawingGameVisitor : public GameVisitor {
 	virtual void visit(DevelopmentCard&);
 };
 
+class ClickCoordinateEvent {
+private:
+	Coordinate clicked;
+public:
+	ClickCoordinateEvent(const Coordinate& clicked);
+	ClickCoordinateEvent(const ClickCoordinateEvent&);
+	~ClickCoordinateEvent();
+	ClickCoordinateEvent& operator=(const ClickCoordinateEvent&);
+	
+	Coordinate getCoordinate() const;
+};
+
 #endif

include/Renderer.h

@@ -13,6 +13,7 @@ void renderBoard(const GameBoard& board, const Player& perspective);
 GLuint loadImageAsTexture(const std::string& name);
 
 std::pair<float, float> coordToScreen(const Coordinate& coord);
+Coordinate screenToCoord(const std::pair<float, float>&);
 
 void vertexPair(const Coordinate& coord);
 

src/GameBoard.cpp

@@ -288,7 +288,6 @@ bool GameBoard::roadExists(Coordinate start, Coordinate end) const {
 	return bool(getRoad(start, end)); // shared_ptr can convert to bool
 }
 
-
 /**
  * Checks to make sure the road being placed at a valid point according to the rules
  */
@@ -397,6 +396,14 @@ const std::shared_ptr<Road> GameBoard::getRoad(Coordinate start, Coordinate end)
 	return NULL;
 }
 
+const std::vector<std::shared_ptr<Road>>& GameBoard::getRoads(Coordinate coord) const {
+	static const std::vector<std::shared_ptr<Road>> empty;
+	if(roads.find(coord) != roads.end()) {
+		return roads.find(coord)->second;
+	}
+	return empty;
+}
+
 /**
  * Parent function for the find longest road traversal. Note that longest path is NP-Hard, so there is no simple algorithm for this.
  */
@@ -586,3 +593,7 @@ bool GameBoard::isValidBoard() const {
 	}
 	return true;
 }
+
+const std::vector<std::unique_ptr<Player>>& GameBoard::getPlayers() const {
+	return players;
+}

src/GameController.cpp

@@ -1,12 +1,31 @@
 #include "GameController.h"
 
+#include <iostream>
+
 #include "GameBoard.h"
+#include "GameView.h"
 
-GameController::GameController(GameBoard& board) : board(board) {
+GameController::GameController(GameBoard& model) : model(model) {
 
 }
 
 GameController::~GameController() {
 
 }
 
+void GameController::handleEvent(const ClickCoordinateEvent& event) {
+	//std::cout << "user clicked at " << event.getCoordinate().first << ", " << event.getCoordinate().second << std::endl;
+	if(model.getRoads(event.getCoordinate()).size() > 0) {
+		model.PlaceSettlement(event.getCoordinate(), *model.getPlayers()[0]);
+	} else {
+		static Coordinate adjacentCoordDiffs[] = {Coordinate(0, 1), Coordinate(1, 0), Coordinate(1, -1), Coordinate(0, -1), Coordinate(-1, 0), Coordinate(-1, 1)};
+		for(auto& adjacent : adjacentCoordDiffs) {
+			Coordinate start {event.getCoordinate().first + adjacent.first, event.getCoordinate().second + adjacent.second}; 
+			if(model.getRoads(start).size() > 0) {
+				model.PlaceRoad(start, event.getCoordinate(), *model.getPlayers()[0]);
+				break;
+			}
+		}
+	}
+}
+

src/GameView.cpp

@@ -8,6 +8,7 @@
 #include "GameBoard.h"
 #include "GameController.h"
 #include "Renderer.h"
+#include "City.h"
 
 using std::make_pair;
 using std::pair;
@@ -34,6 +35,8 @@ void GameView::render() {
 bool GameView::acceptInput(SDL_Event& event) {
 	if(event.type == SDL_QUIT) {
 		return false;
+	} else if(event.type == SDL_MOUSEBUTTONUP) {
+		controller.handleEvent(ClickCoordinateEvent(screenToCoord({(float) event.button.x / 900.f, 1.f - (float) event.button.y / 800.f})));
 	}
 	return true;
 }
@@ -98,7 +101,18 @@ void DrawingGameVisitor::visit(Settlement& settlement) {
 }
 
 void DrawingGameVisitor::visit(City& city) {
+	static const auto cityRadius = 0.03;
 
+	auto centerScreenPos = coordToScreen(city.getLocation());
+	
+	glBindTexture(GL_TEXTURE_2D, 0);
+	glColor3d(0., 0., 0.);
+	glBegin(GL_QUADS);
+	glVertex2d(centerScreenPos.first + cityRadius, centerScreenPos.second + cityRadius);
+	glVertex2d(centerScreenPos.first + cityRadius, centerScreenPos.second - cityRadius);
+	glVertex2d(centerScreenPos.first - cityRadius, centerScreenPos.second - cityRadius);
+	glVertex2d(centerScreenPos.first - cityRadius, centerScreenPos.second + cityRadius);
+	glEnd();
 }
 
 void DrawingGameVisitor::visit(Player& player) {
@@ -180,3 +194,24 @@ void DrawingGameVisitor::visit(ResourceTile& tile) {
 void DrawingGameVisitor::visit(DevelopmentCard& card) {
 
 }
+
+ClickCoordinateEvent::ClickCoordinateEvent(const Coordinate& clicked) : clicked(clicked) {
+	
+}
+
+ClickCoordinateEvent::ClickCoordinateEvent(const ClickCoordinateEvent& event) : clicked(event.clicked) {
+	
+}
+
+ClickCoordinateEvent::~ClickCoordinateEvent() {
+	
+}
+
+ClickCoordinateEvent& ClickCoordinateEvent::operator=(const ClickCoordinateEvent& event) {
+	clicked = event.clicked;
+	return *this;
+}
+
+Coordinate ClickCoordinateEvent::getCoordinate() const {
+	return clicked;
+}

src/Renderer.cpp

@@ -47,11 +47,21 @@ pair<float, float> coordToScreen(const Coordinate& coord) {
 	using std::sin;
 	using std::cos;
 	// TODO not magic numbers
-	float scale = 0.1f;
-	float angle = M_PI / 3.f;
-	float x = .5f + (scale * coord.first) + (scale * coord.second) * cos(angle);
-	float y = .5f + (scale * coord.second) * sin(angle);
-	return std::make_pair(x - 0.25f, y - 0.4f);
+	static const float scale = 0.1f;
+	static const float angle = M_PI / 3.f;
+	float x = .25f + (scale * coord.first) + ((scale * coord.second) * cos(angle));
+	float y = .1f + (scale * coord.second) * sin(angle);
+	return std::make_pair(x, y);
+}
+
+Coordinate screenToCoord(const pair<float, float>& screen) {
+	static const float scale = 0.1;
+	static const float angle = M_PI / 3.f;
+	Coordinate ret;
+	float y_approx = (screen.second - 0.1f) / std::sin(angle) / scale;
+	ret.second = std::round(y_approx);
+	ret.first = std::round((screen.first - 0.2f) / scale - (screen.second - 0.1f) / scale / std::sin(angle) * std::cos(angle)) - 1;
+	return ret;
 }
 
 void vertexPair(const Coordinate& coord) {

src/main.cpp

@@ -75,6 +75,8 @@ int main(int argc, char *argv[]) {
 	model.PlaceRoad(Coordinate{0, 0}, Coordinate{1, 0}, firstPlayer);
 	model.PlaceRoad(Coordinate{1, 0}, Coordinate{1, 1}, firstPlayer);
 	model.PlaceRoad(Coordinate{1, 1}, Coordinate{0, 2}, firstPlayer);
+	model.PlaceSettlement(Coordinate{0, 2}, firstPlayer);
+	model.UpgradeSettlement(Coordinate{0, 2});
 
 	bool running = true;
 	while(running) {