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

Author: apolitakis

Makefile

@@ -7,7 +7,7 @@ export EXECUTABLE := warsofcatan
 ALLFILES := $(wildcard $(SRC_HOME)/*) $(wildcard $(INCL_HOME)/*)
 export CXX := g++
 export LD := g++
-export CXXFLAGS := -g -I$(INCL_HOME) -std=c++0x -I/usr/include/SDL -Wall
+export CXXFLAGS := -g -I$(INCL_HOME) -std=c++0x -I/usr/include/SDL2 -I/usr/local/include/SDL2 -Wall
 export LDFLAGS := -L/usr/local/lib -lSDL2 -lSDL2_ttf -lGL -lGLU -Wl,-R/usr/local/lib
 
 .PHONY: all

include/GameController.h

@@ -3,9 +3,12 @@
 
 #include "Util.h"
 
+#include <array>
+
 class GameBoard;
 class ClickCoordinateEvent;
 class GameView;
+class Player;
 
 /**
  * Takes interpreted Catan events from the View and calls the appropriate functions on the model to changee the state
@@ -29,6 +32,8 @@ class GameController {
 	bool handleBoardEvent(ScreenCoordinate);
 	bool handleRoadButtonEvent(ScreenCoordinate);
 	bool handleSettlementButtonEvent(ScreenCoordinate);
+	bool handlePlayerClick(ScreenCoordinate, Player&);
+	bool handleTradeOffer(ScreenCoordinate, Player& initiating, std::array<int, 5>, Player& receiving, std::array<int, 5>);
 };
 
 #endif

include/GameView.h

@@ -3,12 +3,14 @@
 
 #include <vector>
 #include <memory>
+#include <array>
 
 #include "SDL2/SDL.h"
 #include "SDL2/SDL_opengl.h"
 #include "GL/gl.h"
 
 #include "GameVisitor.h"
+#include "Renderer.h"
 #include "Util.h"
 
 class GameBoard;
@@ -46,10 +48,10 @@ class GameView {
 private:
 	GameBoard& model;
 
-	std::vector<std::unique_ptr<ViewElement>> viewElements;
+	std::map<int, std::unique_ptr<ViewElement>> viewElements;
 
-	GameView(const GameView& o) : model(o.model) {} //deleted
-	GameView& operator=(const GameView& o) { return *this; } //deleted
+	GameView(const GameView& o) = delete;
+	GameView& operator=(const GameView& o) = delete;
 public:
 	GameView(GameBoard&);
 	~GameView();
@@ -58,6 +60,11 @@ class GameView {
 	bool acceptInput(SDL_Event& event);
 
 	void addElement(std::unique_ptr<ViewElement>);
+	void addElement(int priority, std::unique_ptr<ViewElement>);
+	
+	std::unique_ptr<ViewElement> removeElement(int priority);
+	std::unique_ptr<ViewElement> removeElement(const ViewElement*);
+	std::unique_ptr<ViewElement> removeElement(const ViewElement&);
 };
 
 /**
@@ -67,8 +74,8 @@ class DrawingGameVisitor : public GameVisitor {
 private:
 	GameView& view;
 
-	DrawingGameVisitor(const DrawingGameVisitor& o) : view(o.view) {} //deleted
-	DrawingGameVisitor& operator=(const DrawingGameVisitor& o) { return *this; } //deleted
+	DrawingGameVisitor(const DrawingGameVisitor& o) = delete;
+	DrawingGameVisitor& operator=(const DrawingGameVisitor& o) = delete;
 public:
 	DrawingGameVisitor(GameView& view);
 	~DrawingGameVisitor();
@@ -87,22 +94,19 @@ class DrawingGameVisitor : public GameVisitor {
 /**
  * A view element that is invisible and calls a callback function when it is clicked.
  */
-template<class Fn>
 class ViewButton : public ViewElement {
 private:
-	Fn action;
+	std::function<bool(ScreenCoordinate)> action;
 
-	ViewButton(const ViewButton& vb) : ViewElement(vb) {} //deleted
-	ViewButton& operator=(const ViewButton&) { return *this; } //deleted
+	ViewButton(const ViewButton& vb) = delete;
+	ViewButton& operator=(const ViewButton&) = delete;
 protected:
-	virtual bool clicked(ScreenCoordinate coord) {
-		return action(coord);
-	}
+	virtual bool clicked(ScreenCoordinate coord);
 public:
-	ViewButton(Fn action, std::pair<ScreenCoordinate, ScreenCoordinate> rect) : ViewElement(rect), action(action) {}
-	virtual ~ViewButton() {}
+	ViewButton(std::function<bool(ScreenCoordinate)> action, std::pair<ScreenCoordinate, ScreenCoordinate> rect);
+	virtual ~ViewButton();
 
-	virtual void render() {}
+	virtual void render();
 };
 
 /**
@@ -114,35 +118,23 @@ class ViewButton : public ViewElement {
  */
 template<class Fn>
 std::unique_ptr<ViewElement> makeViewButton(Fn fn, std::pair<ScreenCoordinate, ScreenCoordinate> rect) {
-	return std::unique_ptr<ViewElement>(new ViewButton<Fn>(fn, rect));
+	return std::unique_ptr<ViewElement>(new ViewButton(fn, rect));
 }
 
 /**
  * A view element drawn as a solid color that has a callback function that is called when it is clicked.
  */
-template<class Fn>
-class ViewButtonColor : public ViewButton<Fn> {
+class ViewButtonColor : public ViewButton {
 private:
 	std::tuple<float, float, float> color;
 
-	ViewButtonColor(const ViewButtonColor& vb) : ViewElement(vb) {} //deleted
-	ViewButtonColor& operator=(const ViewButtonColor& vb) { return *this; }
+	ViewButtonColor(const ViewButtonColor& vb) = delete;
+	ViewButtonColor& operator=(const ViewButtonColor& vb) = delete;
 public:
-	ViewButtonColor(Fn action, std::pair<ScreenCoordinate, ScreenCoordinate> rect, std::tuple<float, float, float> color) : ViewButton<Fn>(action, rect), color(color) {}
-	virtual ~ViewButtonColor() {}
-	
-	virtual void render() {
-		glBindTexture(GL_TEXTURE_2D, 0);
-		glColor3f(std::get<0>(color), std::get<1>(color), std::get<2>(color));
-		auto topLeft = ViewElement::getRect().first;
-		auto bottomRight = ViewElement::getRect().second;
-		glBegin(GL_QUADS);
-		glVertex2f(topLeft.first, topLeft.second);
-		glVertex2f(bottomRight.first, topLeft.second);
-		glVertex2f(bottomRight.first, bottomRight.second);
-		glVertex2f(topLeft.first, bottomRight.second);
-		glEnd();
-	}
+ 	ViewButtonColor(std::function<bool(ScreenCoordinate)> action, std::pair<ScreenCoordinate, ScreenCoordinate> rect, std::tuple<float, float, float> color);
+	virtual ~ViewButtonColor();
+	
+	virtual void render();
 };
 
 /**
@@ -155,7 +147,60 @@ class ViewButtonColor : public ViewButton<Fn> {
  */
 template<class Fn>
 std::unique_ptr<ViewElement> makeViewButtonColor(Fn fn, std::pair<ScreenCoordinate, ScreenCoordinate> rect, std::tuple<float, float, float> color) {
-	return std::unique_ptr<ViewElement>(new ViewButtonColor<Fn>(fn, rect, color));
+	return std::unique_ptr<ViewElement>(new ViewButtonColor(fn, rect, color));
 }
 
+/**
+ * A view element drawn as some text on the screen that has a callback function when it is clicked.
+ */
+class ViewButtonText : public ViewButton {
+private:
+	GLuint texture;
+	
+	ViewButtonText(const ViewButtonText& vb) = delete;
+	ViewButtonText& operator=(const ViewButtonText& vb) = delete;
+public:
+	ViewButtonText(std::function<bool(ScreenCoordinate)> action, std::pair<ScreenCoordinate, ScreenCoordinate> rect, const std::string& font, int fontSize, const std::string& text);
+	virtual ~ViewButtonText();
+	
+	void setText(const std::string& font, int fontSize, const std::string& text);
+	
+	virtual void render();
+};
+
+/**
+ * Constructs a ViewButtonText using the same parameters as the ViewButtonText. Exists because template inference exists only
+ * for functions, not classes.
+ * @param fn The callback function to be called with the ScreenCoordinate clicked and returning a boolean on if it was handled.
+ * @param rect The location on screen to draw to and receive clicks from.
+ * @param font The path to the font to use to draw the text.
+ * @param fontSize The font size of the text.
+ * @param text The text to render.
+ */
+template<class Fn>
+std::unique_ptr<ViewElement> makeViewButtonText(Fn fn, std::pair<ScreenCoordinate, ScreenCoordinate> rect, const std::string& font, int fontSize, const std::string& text) {
+	return std::unique_ptr<ViewElement>(new ViewButtonText(fn, rect, font, fontSize, text));
+}
+
+class TradingView : public ViewElement {
+private:
+	Player& initiating;
+	Player& receiving;
+	
+	ViewButtonText trade;
+	ViewButtonText cancel;
+	
+	std::array<int, 5> offer;
+	
+	TradingView(TradingView& o) = delete;
+	TradingView& operator=(TradingView& o) = delete;
+protected:
+	virtual bool clicked(ScreenCoordinate coord);
+public:
+	TradingView(Player& initiating, Player& receiving, std::function<bool(std::array<int, 5>, ScreenCoordinate)> trade, std::function<bool(ScreenCoordinate)> cancel, std::array<int, 5> offer);
+	virtual ~TradingView();
+	
+	void render();
+};
+
 #endif

include/Player.h

@@ -13,6 +13,7 @@
 #include <vector>
 #include <string>
 #include <memory>
+#include <array>
 
 #include "tinyxml2.h"
 
@@ -45,7 +46,7 @@ class Player {
     int tradeModifiers[5];
 
 
-    void tradeWithBank(int offer[], int demand[]);
+    void tradeWithBank(std::array<int, 5> offer, std::array<int, 5> demand);
 
 public:
 
@@ -93,11 +94,9 @@ class Player {
 
     void setGeneralModifier();			//3:1 port
 
-    bool offerBankTrade(int offer[], int demand[]);
+    bool offerBankTrade(std::array<int, 5> offer, std::array<int, 5> demand);
 
-    bool offerTrade(Player* p, int offer[], int demand[]);
-    bool recieveOffer(Player* p, int offer[], int demand[]);
-    bool acceptOffer(Player* p, int offer[], int demand[]);
+    bool acceptOffer(Player& p, std::array<int, 5> offer, std::array<int, 5> demand);
 
     int getRandomResource();
 

src/GameController.cpp

@@ -2,10 +2,12 @@
 
 #include <iostream>
 #include <functional>
+#include <memory>
 
 #include "GameBoard.h"
 #include "GameView.h"
 #include "Renderer.h"
+#include "Player.h"
 
 /**
  * Initialize the game controller. Adds the buttons for user control to the view, binding them to GameController methods.
@@ -15,8 +17,20 @@
 GameController::GameController(GameBoard& model, GameView& view) : model(model), view(view), placingRoads(false), placingCities(false) ,lastCoordClick(-100, -100) {
 	using namespace std::placeholders;
 
-	view.addElement(makeViewButtonColor(std::bind(&GameController::handleRoadButtonEvent, this, _1), {{0, 0}, {0.1, 0.1}}, std::make_tuple(1.f, 0.f, 0.f)));
-	view.addElement(makeViewButtonColor(std::bind(&GameController::handleSettlementButtonEvent, this, _1), {{0, 0.1}, {0.1, 0.2}}, std::make_tuple(0.f, 1.0f, 0.f)));
+	auto font = "resources/TypeWritersSubstitute-Black.ttf";
+	auto fontSize = 50;
+	
+	view.addElement(makeViewButtonText(std::bind(&GameController::handleRoadButtonEvent, this, _1), {{0, 0}, {0.1, 0.1}}, font, fontSize, "Road"));
+	view.addElement(makeViewButtonText(std::bind(&GameController::handleSettlementButtonEvent, this, _1), {{0, 0.1}, {0.1, 0.2}}, font, fontSize, "Settlement"));
+	
+	auto playerTopY = 0.9;
+	for(auto i = 0; i < model.getNoOfPlayers(); i++) {
+		auto width = 0.2;
+		Player& player = model.getPlayer(i);
+		view.addElement(makeViewButtonText(std::bind(&GameController::handlePlayerClick, this, _1, std::ref(player)), {{1.0 - width, playerTopY - 0.1}, {1.0, playerTopY}}, font, fontSize, player.getName()));
+		playerTopY -= 0.05;
+	}
+	
 	view.addElement(makeViewButton(std::bind(&GameController::handleBoardEvent, this, _1), {{0, 0}, {1, 1}}));
 }
 
@@ -69,3 +83,76 @@ bool GameController::handleSettlementButtonEvent(ScreenCoordinate coord) {
 	return true;
 }
 
+template<int size>
+auto negativeArr(std::array<int, size> arr) -> std::array<int, size> {
+	for(auto& it : arr) {
+		it = -it;
+	}
+	return arr;
+}
+
+/**
+ * Handles a click on one of the Player names at the top right of the screen.
+ * @param coord The coordinate clicked on.
+ * @param player The player whose name was clicked on.
+ */
+bool GameController::handlePlayerClick(ScreenCoordinate coord, Player& player) {
+	using namespace std::placeholders;
+	Player& initiating = *model.getPlayers()[0];
+	Player& receiving = player;
+	auto priority = -10;
+	
+	std::array<int, 5> initial{{0, 0, 0, 0, 0}};
+	
+	//std::function<bool(std::array<int, 5>, ScreenCoordinate)> tradeFunction(std::bind(&GameController::handleTradeOffer, this, _2, std::ref(initiating), _1, std::ref(receiving)));
+	std::function<bool(std::array<int, 5>, ScreenCoordinate)> tradeFunction([this, &initiating, &receiving](std::array<int, 5> offer, ScreenCoordinate coord) {
+		std::array<int, 5> initial{{0, 0, 0, 0, 0}};
+		std::array<int, 5> reverseOffer = negativeArr<5>(offer);
+		handleTradeOffer(coord, receiving, initial, initiating, reverseOffer);
+		return true;
+	});
+	std::function<bool(ScreenCoordinate)> cancelFunction([this, priority](ScreenCoordinate coord) {
+		view.removeElement(priority); 
+		return true;
+	});
+	
+	view.addElement(priority, std::unique_ptr<ViewElement>(new TradingView(initiating, receiving, tradeFunction, cancelFunction, initial)));
+	std::cout << player.getName() << std::endl;
+	return true;
+}
+
+/**
+ * Handle a trade offer from a player.
+ * @param coord The coordinate clicked on to initiate the trade.
+ * @param initiating The player initiating the trade.
+ * @param offer The offer the player is giving.
+ * @param receiving The other player in the trade.
+ */
+bool GameController::handleTradeOffer(ScreenCoordinate coord, Player& initiating, std::array<int, 5> offer, Player& receiving, std::array<int, 5> counterOffer) {
+	auto priority = -10;
+	if(offer == negativeArr<5>(counterOffer)) {
+		view.removeElement(priority);
+		std::array<int, 5> splitOffer;
+		std::array<int, 5> splitDemand;
+		for(int i = 0; i < 5; i++) {
+			splitOffer[i] = counterOffer[i] < 0 ? 0 : -counterOffer[i];
+			splitDemand[i] = counterOffer[i] < 0 ? 0 : counterOffer[i];
+		}
+		initiating.acceptOffer(receiving, splitOffer, splitDemand);
+	} else {
+		//std::function<bool(std::array<int, 5>, ScreenCoordinate)> tradeFunction(std::bind(&GameController::handleTradeOffer, this, _2, std::ref(initiating), _1, std::ref(receiving)));
+		std::function<bool(std::array<int, 5>, ScreenCoordinate)> tradeFunction([this, &initiating, &receiving, counterOffer](std::array<int, 5> offer, ScreenCoordinate coord) {
+			std::array<int, 5> reverseOffer = negativeArr<5>(offer);
+			handleTradeOffer(coord, receiving, counterOffer, initiating, reverseOffer);
+			return true;
+		});
+		std::function<bool(ScreenCoordinate)> cancelFunction([this, priority](ScreenCoordinate coord) {
+			view.removeElement(priority); 
+			return true;
+		});
+		
+		view.addElement(priority, std::unique_ptr<ViewElement>(new TradingView(initiating, receiving, tradeFunction, cancelFunction, counterOffer)));
+	}
+	return true;
+}
+