First stable fusionning

.gitignore

@@ -1,6 +1,15 @@
 CMakeFiles
+<<<<<<< HEAD
 *.sh
 2P11
+=======
+*.a
+*.o
+>>>>>>> develop
 cmake_install.cmake
 Makefile
 CMakeCache.txt
+*.app
+2P11
+clear.sh
+*.vim

CMakeLists.txt

@@ -3,7 +3,7 @@ project(2P11)
 
 #Assign Modules path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
-
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FGS} -std=c++11")
 #Defined project VERSION
 set(VERSION_MAJOR 0)
 set(VERSION_MINOR 1)
@@ -14,5 +14,5 @@ set(VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REV}")
 cmake_minimum_required(VERSION 2.6)
 
 #Add source directory
-add_subdirectory(src)
+add_subdirectory(./src)
 

src/CMakeLists.txt

@@ -7,9 +7,12 @@ add_executable(
 #Find all libraries
 find_package(SFML 2.2 COMPONENTS system window graphics audio REQUIRED)
 
+set_property(GLOBAL PROPERTY SFML_LIBRARIES "${SFML_LIBRARIES}")
+set_property(GLOBAL PROPERTY SFML_INCLUDE_DIR "${SFML_INCLUDE_DIR}")
 
 #Include "Includes" and "Libraries"
 include_directories(${SFML_INCLUDE_DIR})
-target_link_libraries(2P11 ${SFML_LIBRARIES})
+target_link_libraries(2P11 ${SFML_LIBRARIES} Model ConsoleController)
 
-message("${SFML_LIBRARIES}")
+add_subdirectory(./Model)
+add_subdirectory(./Controllers/)

src/Controllers/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(./ConsoleController/)

src/Controllers/ConsoleController/CMakeLists.txt

@@ -0,0 +1,3 @@
+#Make Model lib
+add_library(ConsoleController ./ConsoleController.cpp)
+target_link_libraries(ConsoleController Model)

src/Controllers/ConsoleController/ConsoleController.cpp

@@ -0,0 +1,97 @@
+#include "./ConsoleController.hpp"
+#include <SFML/Window/Keyboard.hpp>
+#include "../../Helpers/Keyboard.hpp"
+
+ConsoleController::ConsoleController()
+{
+}
+
+ConsoleController::~ConsoleController()
+{
+}
+
+void ConsoleController::run()
+{
+
+	//Init keyPress
+	kbdh::Direction keyPress;
+
+	//Intruction msg
+	std::cout << "Use arrows to play !" << std::endl;
+
+	//Pop a random number on the grid
+	m_game.popRandomNumber();
+
+	//First cout grid
+	m_game.coutGrid();
+
+
+	//Start game
+	while (!m_game.isOver())
+	{
+		//Get key press
+		keyPress=this->waitArrowKeyPress();
+
+		//Apply move
+		m_game.swipe(keyPress);
+
+		//Pop a random number on the grid
+		m_game.popRandomNumber();
+
+		//Cout grid
+		m_game.coutGrid();
+
+	}
+	m_game.coutGrid();
+}
+
+
+
+kbdh::Direction ConsoleController::waitArrowKeyPress()
+{
+	//Initialise keyPress
+	kbdh::Direction keyPress;
+
+	//Wait for keypress
+	while(1){
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
+		{
+			keyPress=kbdh::Left;
+			while(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
+			{
+				//Wait for release
+			}
+			break;
+		}
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
+		{
+			keyPress=kbdh::Right;
+			while(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
+			{
+				//Wait for release
+			}
+			break;
+		}
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
+		{
+			keyPress=kbdh::Up;
+			while(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
+			{
+				//Wait for release
+			}
+			break;
+		}
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
+		{
+			// la touche "flèche gauche" est enfoncée : on bouge le personnage
+			keyPress=kbdh::Down;
+			while(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
+			{
+				//Wait for release
+			}
+			break;
+		}
+	}
+
+	return keyPress;
+}

src/Controllers/ConsoleController/ConsoleController.hpp

@@ -0,0 +1,26 @@
+#ifndef DEF_CTCONSOLE
+#define DEF_CTCONSOLE
+
+/* CTConsole.hpp
+ * Defines the class CTConsole
+ * CTConsole is a controller which displays a game in a terminal
+ * Creators : krilius, manzerbredes
+ * Date : 29/04/2915 */
+
+#include <iostream>
+#include "../../Helpers/Keyboard.hpp"
+#include "../../Model/Game.hpp"
+
+class ConsoleController
+{
+	private:
+
+		Game m_game;
+		kbdh::Direction waitArrowKeyPress();
+	public:
+		ConsoleController();
+		~ConsoleController();
+		void run();
+};
+
+#endif

src/Helpers/Keyboard.hpp

@@ -0,0 +1,17 @@
+#ifndef DEF_MODELCONSTANTS
+#define DEF_MODELCONSTANTS
+
+/* ModelConstants.hpp
+ * Constains constants and enums used in the whole model
+ * Creators : krilius, manzerbredes
+ * Date : 29/04/2015 */
+
+namespace kbdh {
+
+	//Key arrow
+	enum Direction { Up, Down, Left, Right };
+	typedef enum Direction Direction;
+
+}
+
+#endif

src/Model/CMakeLists.txt

@@ -0,0 +1,2 @@
+#Make Model lib
+add_library(Model Grid.cpp Game.cpp) 

src/Model/Game.cpp

@@ -0,0 +1,49 @@
+#include "Game.hpp"
+
+
+
+Game::Game() : m_grid(){
+}
+
+Game::~Game(){
+}
+
+
+
+bool Game::swipe(kbdh::Direction direction){
+
+	switch(direction){
+
+		case kbdh::Left:
+			m_grid.swipeLeft();
+			break;
+		case kbdh::Right:
+			m_grid.swipeRight();
+			break;
+		case kbdh::Up:
+			m_grid.swipeUp();
+			break;
+		case kbdh::Down:
+			m_grid.swipeDown();
+			break;
+	}
+
+	return true;
+}
+
+
+void Game::coutGrid(){
+	std::cout << m_grid.description();
+}
+
+bool Game::isOver(){
+	return m_grid.isOver();
+}
+
+void Game::popRandomNumber(){
+	std::tuple<int, int> coord(m_grid.getRandomEmptyCellCoord());
+
+	int number=2;
+
+	m_grid.setCell(coord, number);
+}

src/Model/Game.hpp

@@ -0,0 +1,31 @@
+#ifndef DEF_GAME
+#define DEF_GAME
+
+/* Game.h
+ * Defines the class Game
+ * A game allows a player to play. It contains a grid and pops numbers
+ * Creators : krilius, manzerbredes
+ * Date : 29/04/2015 */
+
+#include <iostream>
+#include <string>
+#include "../Helpers/Keyboard.hpp"
+#include "Grid.hpp"
+#include <tuple>
+
+class Game
+{
+	private:
+		Grid m_grid;
+
+	public:
+		Game();
+		~Game();
+		
+		bool swipe(kbdh::Direction direction);
+		void coutGrid();
+		void popRandomNumber();
+		bool isOver();
+};
+
+#endif

src/Model/Grid.cpp

@@ -0,0 +1,258 @@
+#include "Grid.hpp"
+
+//Constructor
+Grid::Grid(): m_size(4), m_grid(4){
+
+	//Init all cells
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size;j++){
+			m_grid.at(i).push_back(0);
+		}
+	}
+
+}
+
+//Destructor
+Grid::~Grid(){
+}
+
+
+std::string Grid::description(){
+
+	//Init stringstream description
+	std::stringstream description;
+
+	//Get max str len of the grid
+	int maxStrLen=this->maxStrLenInGrid();
+
+	//Start to write description
+	std::stringstream gridBorder;
+	for(int i=0;i<(maxStrLen+2)*4+1;i++){
+		gridBorder<<"-";	
+	}
+	description << std::endl << gridBorder.str() << std::endl;
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size;j++){
+			std::stringstream spaceCol;
+			for(int k=0;k<maxStrLen-std::to_string(m_grid.at(i).at(j)).size();k++){
+				spaceCol << " ";
+			}
+			if(m_grid.at(i).at(j) == 0)
+				description << "| " << " " << spaceCol.str();
+			else
+				description << "| " << m_grid.at(i).at(j) << spaceCol.str();
+		}
+		description << "|";
+		description << std::endl;
+	}
+	description << gridBorder.str() << std::endl << std::endl;
+
+	//Return description
+	return description.str();
+}
+
+
+int Grid::maxStrLenInGrid(){
+	int max=0;
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size;j++){
+			std::string number=std::to_string(m_grid.at(i).at(j));
+			if(number.size() > max)
+				max=number.size();
+		}
+	}
+	return max;
+}
+
+bool Grid::isEmpty(int i, int j){
+	if(m_grid.at(i).at(j) == 0)
+		return true;
+	return false;
+}
+
+std::tuple<int, int> Grid::getRandomEmptyCellCoord(){
+
+	//Init list of candidate
+	std::vector<std::tuple<int, int> > candidates;
+
+	//Construct list of candidates
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size;j++){
+			if(this->isEmpty(i,j)){
+				std::tuple<int, int> currentCandidate(i,j);
+				candidates.push_back(currentCandidate);
+			}
+		}
+	}
+
+	//If no candidate available
+	if(candidates.size() == 0)
+		return std::tuple<int, int>(-1, -1);
+
+	//Select the candidates
+	int winnerIs(rand() % candidates.size());
+
+	//Return the candidate
+	return candidates.at(winnerIs);
+
+}
+
+
+
+//Change value of cell
+bool Grid::setCell(std::tuple<int, int> coord, int value){
+	int i=std::get<0>(coord);
+	int j=std::get<1>(coord);
+
+	if(i>=0 && i<m_size && j>=0 && j<m_size){
+		m_grid.at(i).at(j)=value;
+		return true;
+	}
+
+	return false;
+}
+
+//Another setCell method
+bool Grid::setCell(int i, int j, int value){
+	std::tuple<int, int> coord(i,j);
+	return this->setCell(coord, value);
+}
+
+
+std::vector<int> Grid::defragmentLine(std::vector<int> line){
+	for(int j=0; j<m_size-1;j++){
+		for(int i=0; i<m_size-1;i++){
+			int val1=line.at(i);
+			int val2=line.at(i+1);
+
+			if(val1 != 0 && val2 == 0){
+				line.at(i)=0;
+				line.at(i+1)=val1;
+			}
+		}
+	}
+	return line;
+}
+
+std::vector<int> Grid::mergeLine(std::vector<int> line){
+	for(int i=0; i< m_size-1;i++){
+		int val1=line.at(i);
+		int val2=line.at(i+1);
+
+		if(val1==val2){
+			line.at(i)=0;
+			line.at(i+1)=val1*2;
+			i++;
+		}
+	}
+	return line;
+}
+
+std::vector<int> Grid::swipeLine(std::vector<int> line){
+
+	//Swipe line is :
+		//- A defragmentation
+		//- A merging
+		//- Another defragmentation
+	line=this->defragmentLine(line);
+	line=this->mergeLine(line);
+	line=this->defragmentLine(line);
+
+	//Return swiped line
+	return line;
+}
+
+
+//Swipe to right
+void Grid::swipeRight(){
+	for(int i=0; i<m_size;i++){
+		m_grid.at(i)=this->swipeLine(m_grid.at(i));
+	}
+}
+
+//Swipe to right
+void Grid::swipeLeft(){
+	for(int i=0; i<m_size;i++){
+		m_grid.at(i)=this->reverseLine(this->swipeLine(this->reverseLine(m_grid.at(i))));
+	}
+}
+
+
+void Grid::swipeUp(){
+	for(int i=0; i<m_size;i++){
+		std::vector<int> colVect=this->getCol(i);
+		this->setCol(i,this->reverseLine(this->swipeLine(this->reverseLine(colVect))));
+	}
+}
+void Grid::swipeDown(){
+	for(int i=0; i<m_size;i++){
+		std::vector<int> colVect=this->getCol(i);
+		this->setCol(i,this->swipeLine(colVect));
+	}
+}
+
+void Grid::setCol(int col, std::vector<int> colVect){
+	for(int i=0;i<m_size;i++){
+		m_grid.at(i).at(col)=colVect.at(i);
+	}
+}
+
+std::vector<int> Grid::getCol(int col){
+
+	std::vector<int> colVect;
+
+	for(int i=0;i<m_size;i++){
+		colVect.push_back(m_grid.at(i).at(col));
+	}
+
+	return colVect;
+}
+
+std::vector<int> Grid::reverseLine(std::vector<int> line){
+	std::vector<int> reversedLine;
+
+	for(int j=m_size-1; j>=0;j--){
+		reversedLine.push_back(line.at(j));
+	}
+
+	return reversedLine;
+}
+
+
+bool Grid::isFull(){
+
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size;j++){
+			if(m_grid.at(i).at(j) == 0)
+				return false;
+		}
+	}
+	
+	return true;
+}
+
+bool Grid::isOver(){
+
+	if(!this->isFull())
+		return false;
+
+	for(int i=0;i<m_size;i++){
+		for(int j=0;j<m_size-1;j++){
+			if(m_grid.at(i).at(j) == m_grid.at(i).at(j+1))
+				return false;
+		}
+	}
+	
+	for(int i=0;i<m_size;i++){
+		std::vector<int> colVect(this->getCol(i));
+
+		for(int j=0;j<m_size-1;j++){
+			if(colVect.at(j) == colVect.at(j+1))
+				return false;
+		}
+	}
+
+	return true;
+
+
+}

src/Model/Grid.hpp

@@ -0,0 +1,53 @@
+#ifndef	DEF_GRID
+#define	DEF_GRID
+
+/* Grid.h
+ * Defines the class Grid
+ * A grid contains a table of cells the game will be set on
+ * Creators : krilius, manzerbredes
+ * Date : 29/04/2015 */
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <tuple>
+
+class Grid
+{
+	private:
+		int m_size;
+		std::vector<std::vector<int> > m_grid;
+
+		int maxStrLenInGrid();
+	public:
+		Grid();
+		~Grid();
+
+		std::string description();
+		bool isEmpty(int i, int j);
+		std::tuple<int, int> getRandomEmptyCellCoord();
+
+		bool setCell(std::tuple<int, int> coord, int value);
+		bool setCell(int i, int j, int value);
+		
+		std::vector<int> swipeLine(std::vector<int> line);
+		std::vector<int> defragmentLine(std::vector<int> line);
+		std::vector<int> mergeLine(std::vector<int> line);
+
+		std::vector<int> getCol(int col);
+
+		bool isFull();
+		bool isOver();
+
+		void setCol(int col, std::vector<int> colVect);
+		std::vector<int> reverseLine(std::vector<int> line);
+
+		//Moves
+		void swipeRight();
+		void swipeLeft();
+		void swipeUp();
+		void swipeDown();
+};
+
+
+#endif

src/main.cpp

@@ -1,25 +1,30 @@
-#include <SFML/Graphics.hpp>
+//----- STD include -----
+#include <iostream>
 #include <string>
+#include <time.h>
+#include <tuple>
+//----------------------
 
+//----- Personnal include -----
+#include "./Controllers/ConsoleController/ConsoleController.hpp"
+//-----------------------------
+
+
+
+
+
+//----- Start -----
 int main()
 {
-    sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");
-    sf::CircleShape shape(100.f);
-    shape.setFillColor(sf::Color::Green);
+    	//Init random
+	srand(time(NULL));
 
-    while (window.isOpen())
-    {
-        sf::Event event;
-        while (window.pollEvent(event))
-        {
-            if (event.type == sf::Event::Closed)
-                window.close();
-        }
+	//Init controller
+	ConsoleController controller;
+
+	//Run the game
+	controller.run();
 
-        window.clear();
-        window.draw(shape);
-        window.display();
-    }
 
 	return 0;
 }