added robber, changed resources to be a map of resourcetiles

Author: apolitakis

include/Deck.h

@@ -9,20 +9,26 @@
 #define DECK_H_
 
 #include <vector>
+#include <ctime>
 #include <algorithm>
 #include "DevelopmentCard.h"
 
 class Deck {
 
 private:
 	std::vector<DevelopmentCard*> deck;
+    std::vector<DevelopmentCard*> discardPile;
+    
+    void shuffleDeck();
+    void reshuffleDeck();
 
 public:
 	Deck();
 	virtual ~Deck();
 
 	int getSize();
 	DevelopmentCard* drawCard();
+    void discard(DevelopmentCard* toDiscard);
 };
 
 #endif /* DECK_H_ */

include/GameBoard.h

@@ -22,51 +22,70 @@ class GameVisitor;
 class GameBoard {
 private:
 	std::map<Coordinate, std::unique_ptr<CornerPiece>> corners;
+
 	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);
 
-	std::map<Coordinate, std::vector<std::shared_ptr<Road>>> roads;
+	bool isValidBoard() const;
 
-	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);
+	bool verifyRoadPlacement(Coordinate start, Coordinate end, Player& Owner) const;
+	bool outOfBounds(const Coordinate& coord) const;
+	bool roadExists(Coordinate start, Coordinate end) const;
+	bool isRoadConnectionPoint(Coordinate point, Player& Owner) const;
 
 	int constructBoardFromFile(std::ifstream &file);
 	int constructFileFromBoard(std::ofstream &file);
 
 	void removeRoadEnd(std::shared_ptr<Road> startRoad);
-	int FindLongestRoad_FromPoint(Coordinate curr, Player & owner, std::map<Coordinate, bool>& marked, int length);
-
+	int FindLongestRoad_FromPoint(Coordinate curr, const Player & owner, std::map<Coordinate, bool>& marked, std::map<Road*, bool>& markedRoads, int length) const;
+	
+	void createRing(Coordinate topRight, int sideLength, std::vector<resourceType>& resources, std::vector<int>& rolls);
+	void insertTile(Coordinate location, std::vector<resourceType>& resources, std::vector<int>& rolls);
 public:
 	GameBoard(std::vector<std::unique_ptr<Player>>&& players);
+	GameBoard(std::vector<std::unique_ptr<Player>>&& players, const std::map<Coordinate, std::pair<resourceType, int>>& resourceLocations);
 	GameBoard(std::istream& in);
 	GameBoard(GameBoard&) = delete;
 	~GameBoard();
 	GameBoard& operator=(GameBoard&) = delete;
 
 	void save(std::ostream& out);
 
+
 	const std::map<Coordinate, std::unique_ptr<ResourceTile>>& getResources() const;
-	std::shared_ptr<Road> getRoad(Coordinate start, Coordinate end);
+
+
+
+	const std::shared_ptr<Road> getRoad(Coordinate start, Coordinate end) const;
+
 
-	int FindLongestRoad(Player & owner);
+	int FindLongestRoad(const Player & owner) const;
 
 	std::vector<Settlement*> GetNeighboringSettlements(Coordinate location) const;
 	std::vector<CornerPiece*> GetNeighboringCorners(Coordinate location) const;
 
 
+
 	void PlaceSettlement(Coordinate location, Player& Owner);
 	void UpgradeSettlement(Coordinate location);
-	void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
+	//void PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
+
+
+	bool buyRoad(Coordinate start, Coordinate end, Player& Owner);
 
 
-	void init_resources();
+	//void PlaceSettlement(Coordinate location, Player& Owner);
+	void PlaceCity(Coordinate location, Player& Owner);
+	bool PlaceRoad(Coordinate start, Coordinate end, Player& Owner);
 
 	void accept(GameVisitor& visitor);
 

include/GameController.h

@@ -0,0 +1,17 @@
+#ifndef GAME_CONTROLLER_H
+#define GAME_CONTROLLER_H
+
+class GameBoard;
+
+class GameController {
+private:
+	GameBoard& board;
+	
+	GameController(const GameController& o) : board(o.board) {} //deleted
+	GameController& operator=(const GameController& o) { return *this; } //deleted
+public:
+	GameController(GameBoard&);
+	~GameController();
+};
+
+#endif

include/GamePiece.h

@@ -23,7 +23,7 @@ class GamePiece {
 	Coordinate getCoordinates() const;
 	GameBoard& getBoard();
 	const GameBoard& getBoard() const;
-	
+
 	Coordinate location;
 
 	virtual void accept(GameVisitor&) = 0;

include/GameView.h

@@ -0,0 +1,45 @@
+#ifndef GAME_VIEW_H
+#define GAME_VIEW_H
+
+#include "SDL2/SDL.h"
+
+#include "GameVisitor.h"
+
+class GameBoard;
+class GameController;
+
+class GameView {
+private:
+	GameBoard& model;
+	GameController& controller;
+	
+	GameView(const GameView& o) : model(o.model), controller(o.controller) {} //deleted
+	GameView& operator=(const GameView& o) { return *this; } //deleted
+public:
+	GameView(GameBoard&, GameController&);
+	~GameView();
+	
+	void render();
+	bool acceptInput(SDL_Event& event);
+};
+
+class DrawingGameVisitor : public GameVisitor {
+private:
+	GameView& view;
+	
+	DrawingGameVisitor(const DrawingGameVisitor& o) : view(o.view) {} //deleted
+	DrawingGameVisitor& operator=(const DrawingGameVisitor& o) { return *this; } //deleted
+public:
+	DrawingGameVisitor(GameView& view);
+	~DrawingGameVisitor();
+	
+	virtual void visit(GameBoard&);
+	virtual void visit(Road&);
+	virtual void visit(Settlement&);
+	virtual void visit(City&);
+	virtual void visit(Player&);
+	virtual void visit(ResourceTile&);
+	virtual void visit(DevelopmentCard&);
+};
+
+#endif

include/Player.h

@@ -65,24 +65,26 @@ class Player {
 
     void playCard(DevelopmentCard* card);
 
+    bool canBuyRoad();
+    bool buyRoad();
+
     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 checkResources(int resourceList[]);
 
-
     int getWood() const;
     int getBrick() const;
     int getOre() const;
     int getWheat() const;
     int getWool() const;
 
-    void setWood(int resource);
-    void setBrick(int resource);
-    void setOre(int resource);
-    void setWheat(int resource);
-    void setWool(int resource);
+    void addWood(int resource);
+    void addBrick(int resource);
+    void addOre(int resource);
+    void addWheat(int resource);
+    void addWool(int resource);
 
     void addResource(int resourceType, int delta);
 

include/Renderer.h

@@ -1,9 +1,23 @@
 #ifndef RENDERER_H
 #define RENDERER_H
 
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_opengl.h>
+#include <GL/gl.h>
+
 #include "GameBoard.h"
 #include "Player.h"
 
 void renderBoard(const GameBoard& board, const Player& perspective);
 
+GLuint loadImageAsTexture(const std::string& name);
+
+std::pair<float, float> coordToScreen(const Coordinate& coord);
+
+void vertexPair(const Coordinate& coord);
+
+void texCoordPair(const std::pair<float, float>& p);
+
+std::pair<float, float> averagePoint(const std::vector<std::pair<float, float>>& points);
+
 #endif

include/Road.h

@@ -12,12 +12,11 @@ class GameVisitor;
 
 class Road {
 private:
-	bool checkRoad();
-	
+	Player& owner;
 	Coordinate start;
 	Coordinate end;
-
-	bool marker;
+	
+	bool checkRoad();
 public:
 	Road(Coordinate start, Coordinate end, Player& Owner);
 	Road(Road&) = delete;
@@ -29,15 +28,9 @@ class Road {
 
 	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;

include/UserInput.h

@@ -8,7 +8,8 @@
 #include <iostream>
 #include "Deck.h"
 
-Deck::Deck() {
+Deck::Deck()
+{
 	// TODO Auto-generated constructor stub
 	for(int i = 0; i < 15; i++)
 	{
@@ -35,7 +36,8 @@ Deck::Deck() {
 		DevelopmentCard* card = new RoadBuildingCard(NULL);
 		this->deck.push_back(card);
 	}
-
+    
+    shuffleDeck();
 }
 
 Deck::~Deck() {
@@ -45,7 +47,14 @@ Deck::~Deck() {
 	{
 		delete this->deck.back();
 		this->deck.pop_back();
-		std::cout<<":";
+		//std::cout<<":";
+	}
+    
+    while(!this->discardPile.empty())
+	{
+		delete this->discardPile.back();
+		this->discardPile.pop_back();
+		//std::cout<<":";
 	}
 }
 
@@ -59,8 +68,37 @@ int Deck::getSize()
 DevelopmentCard* Deck::drawCard()
 {
 	if(this->getSize() == 0)
-		return NULL;
+    {
+        reshuffleDeck();
+    }
+    
+    if(this->getSize() == 0)
+    {
+        return NULL;
+    }
+    
 	DevelopmentCard* card = this->deck.back();
 	this->deck.pop_back();
 	return card;
 }
+
+void Deck::shuffleDeck()
+{
+    std::srand(std::time(0));
+    random_shuffle(deck.begin(), deck.end());
+}
+
+void Deck::reshuffleDeck()
+{
+    while(!discardPile.empty())
+    {
+        deck.push_back(discardPile.back());
+        discardPile.pop_back();
+    }
+    shuffleDeck();
+}
+
+void Deck::discard(DevelopmentCard* toDiscard)
+{
+    discardPile.push_back(toDiscard);
+}