my update (game works yay)

Author: marcwferreira

Debug/ROBOT3.exe

@@ -17,15 +17,16 @@
 #include "Player.h"
 #include "Robot.h"
 #include "Post.h"
+#include "Gate.h"
 #include "Move_pos.h"
 
 //constructor
 Game::Game(const std::string & filename){
 
-    gameWin = false; //onyl altered if player wins the game;
+    gameWin = false; //only altered if player wins the game
 
     std::ifstream mazefile;
-    mazefile.open(filename);
+    mazefile.open(filename);//open maze file
 
     std::string line;
 
@@ -42,11 +43,13 @@ Game::Game(const std::string & filename){
         mazefile.ignore ( std::numeric_limits<std::streamsize>::max(), 'x' );
         mazefile >> pos_y;
 
+        //set maze variables
         maze.setnumRows(pos_x);
         maze.setnumCols(pos_y);
 
         int line_counter = -1;//point to the line of the maze we are reading (-1 becaue of the first line in the file that is the size of map)
 
+        //read the lines of the fize to extract information
         while (getline(mazefile, line)) {
             for (int i = 0; i!=line.length(); i++) {
 
@@ -77,11 +80,11 @@ Game::Game(const std::string & filename){
 
                 //read doors in map
                 else if (line[i] == door){
-                    Post post_store(line_counter, i, door);
-                    posts.push_back(post_store);
+                    Gate gate_store(line_counter, i);
+                    gates.push_back(gate_store);
                 }
             }
-            line_counter++;
+            line_counter++;//jump to next line
         }
     }
     mazefile.close();
@@ -92,44 +95,83 @@ Maze Game::getMaze() const { return maze; }
 Player Game::getPlayer() const { return player; }
 std::vector<Robot> Game::getRobots() const { return robots; }
 std::vector<Post> Game::getPosts() const { return posts; }
+std::vector<Gate> Game::getGates() const { return gates; }
 bool Game::getGameWin() const { return gameWin; }
 
 //setter
 void Game::setGameWin(bool gameCond) {
     gameWin = gameCond;
 }
 
+//function to detect player win or lose
+bool Game::ask_game_ended() {
+    //see if player won game
+    if (gameWin) {
+        return game_ended;
+    }
+    //see if player lost game
+    else if (!player.isAlive()) {
+        return game_ended;
+    }
+    //if neither continue game
+    else {
+        return game_running;
+    }
+}
+
+
 //public function to play the game;
-bool Game::play(){
-    while (true) {
+bool Game::play() {
+
+    setGameWin(game_start_cond);//ensures the gameWin condiiton is set to false
+
+    bool game_running = true;//initiates varviable to loop the game
+
+    while (game_running) {
+
+        //print the game
         showGameDisplay();
+
+        //player_movement
         player_movement();
-        //detect player win
-        //detect player lost
-        robot_movement();
+        //detect if game ended (if player has won or lost)
+        game_running = ask_game_ended();
+        
+        //robots_movements
+        for (size_t i = 0; i < robots.size(); i++) {
+            robot_movement(i);
+            //detect if game ended (if player has won or lost)
+            game_running = ask_game_ended();
+            if (!game_running) {
+                break;
+            }
+        }
         //detect player_lost
     }
+
+    showGameDisplay(); //show display after the game ended
+
+    return gameWin;
 }
 
-//function to print the map
+//function to print the map (private)
 void Game::showGameDisplay() {
 
     Maze maze_s = getMaze();
     Player player_s = getPlayer();
     std::vector<Robot> robots_s = getRobots();
     std::vector<Post> posts_s = getPosts();
-
-    //std::cout << maze.getnumRows() << ' ' << maze.getnumCols() << std::endl;
+    std::vector<Gate> gates_s = getGates();
 
     bool printed = false; //see if the char has already been printed
     int size_line = maze_s.getnumRows(); //number of rows in map
     int size_col = maze_s.getnumCols(); //number of columns in map
     int player_row, player_col; //detect player place in map
     int robot_row, robot_col; //detect place of a robot in map
     int post_row, post_col; //detect place of post in map
+    int gate_row, gate_col; //detect place of door in map
 
-    std::cout << size_line << ' ' << size_col << std::endl;
-
+    //run the map coordinates, see what is in the position and prints it
     for (int row_number=0;row_number<size_line;row_number++){
         for (int column_number=0;column_number<size_col;column_number++){
 
@@ -157,7 +199,7 @@ void Game::showGameDisplay() {
                 }
             }
 
-            //print posts and doors in the map
+            //print posts in the map
             for (Post post_store : posts_s) {
                 post_row = post_store.getRow();
                 post_col = post_store.getCol();
@@ -169,6 +211,18 @@ void Game::showGameDisplay() {
                 }
             }
 
+            //print gates in the map
+            for (Gate gate_store : gates_s) {
+                gate_row = gate_store.getRow();
+                gate_col = gate_store.getCol();
+                if (gate_row == row_number && gate_col == column_number ) {
+                    if (!printed) {
+                        std::cout << gate_store.getSymbol();
+                    }
+                    printed = true;
+                }
+            }
+
             //if is none prints a space
             if(!printed){
                 std::cout << ' ';
@@ -181,6 +235,7 @@ void Game::showGameDisplay() {
     }
 }
 
+//function to do player movement (private)
 void Game::player_movement() {
 
     std::string player_move; //variable to detect player movement
@@ -255,6 +310,7 @@ void Game::player_movement() {
                     if (robots[i].isAlive()) {
                         player.move(player_movement);//puts player where he died
                         player.setAsDead();
+                        setGameWin(game_lost); //assures the player has lost
                         movement_completed = true;
                     }
                     else {
@@ -263,25 +319,29 @@ void Game::player_movement() {
                 }
             }
 
-            //player tris to move into a post
+            //player tries to move into a post
             for (unsigned int i = 0; i < posts.size(); i++) {
                 if ((posts[i].getRow() == player.getRow() + player_movement.dRow) && (posts[i].getCol() == player.getCol() + player_movement.dCol)) {
                     if (posts[i].isElectrified()) {
-                        //posts.erase(posts.begin() + i);
-                        player.move(player_movement);//puts player where he died
+                        //player doesnt move to electrified post
                         player.setAsDead();
+                        setGameWin(game_lost); //assures the player has lost
                         movement_completed = true;
                     }
-                    else if(posts[i].isDoor()){
-                        player.move(player_movement);//puts player in door frame
-                        setGameWin(game_won);//signifies play won
-                        
-                    }
                     else if (!posts[i].isElectrified()) {
                         valid_move = detect_invalid_move;
                     }
                 }
-            }       
+            }
+
+            //player tries to move into gate
+            for (unsigned int i = 0; i < gates.size(); i++) {
+                if ((gates[i].getRow() == player.getRow() + player_movement.dRow) && (gates[i].getCol() == player.getCol() + player_movement.dCol)) {
+                    player.move(player_movement);//puts player in door frame
+                    setGameWin(game_won);//signifies play won
+                    movement_completed = true;
+                }
+            }
 
             //player moves normally
             if (!movement_completed && valid_move) { //if movement has still not be completed move normally
@@ -297,80 +357,81 @@ void Game::player_movement() {
     }
 }
 
-void Game::robot_movement() {
+//function to do robot movement (private)
+void Game::robot_movement(int robot_index) {
 
-    for (int i = 0; i < robots.size(); i++) {
+    if (robots[robot_index].isAlive()) {
 
-        if (robots[i].isAlive()) {
+        //variables to determine where the robot will move
+        bool robot_has_moved = false;
+        Movement robot_movement;
 
-            //variables to determine where the robot will move
-            bool robot_has_moved = false;
-            Movement robot_movement;
+        //defaut robot movement (no movement)
+        robot_movement.dRow = no_movement;
+        robot_movement.dCol = no_movement;
 
-            //defaut robot movement (no movement)
-            robot_movement.dRow = no_movement;
-            robot_movement.dCol = no_movement;
+        //determines if the robot will move up or down (will chase the player)
+        if (robots[robot_index].getRow() - player.getRow() > robot_move_place) {
+            robot_movement.dRow = move_position_negative;
+        }
+        else if (robots[robot_index].getRow() - player.getRow() < robot_move_place) {
+            robot_movement.dRow = move_position_positive;
+        }
 
-            //determines if the robot will move up or down (will chase the player)
-            if (robots[i].getRow() - player.getRow() > robot_move_place) {
-                robot_movement.dRow = move_position_negative;
-            }
-            else if (robots[i].getRow() - player.getRow() > robot_move_place) {
-                robot_movement.dRow = move_position_positive;
-            }
+        //determines if the robot will move left or right (will chase the player)
+        if (robots[robot_index].getCol() - player.getCol() > robot_move_place) {
+            robot_movement.dCol = move_position_negative;
+        }
+        else if (robots[robot_index].getCol() - player.getCol() < robot_move_place) {
+            robot_movement.dCol = move_position_positive;
+        }
 
-            //determines if the robot will move left or right (will chase the player)
-            if (robots[i].getCol() - player.getCol() > robot_move_place) {
-                robot_movement.dCol = move_position_negative;
-            }
-            else if (robots[i].getCol() - player.getCol() > robot_move_place) {
-                robot_movement.dCol = move_position_positive;
-            }
+        //MAKE THE ROBOTS MOVE
 
-            //MAKE THE ROBOTS MOVE
-            //robot catches player and player dies
-            if ((robots[i].getRow() == player.getRow()) && (robots[i].getCol() == player.getCol())) {
-                robots[i].robotMove(robot_movement);
-                player.setAsDead();
-                robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
-            }
-            //robot goes into posts
-            for (unsigned int j = 0; j < posts.size(); j++) {
-                if ((posts[j].getRow() == robots[i].getRow() + robot_movement.dRow) && (posts[j].getCol() == robots[i].getCol() + robot_movement.dCol)) {
-                    if (posts[j].isElectrified()) {
-                        //posts.erase(posts.begin() + i);
-                        robots[i].robotMove(robot_movement);//puts player where he died
-                        robots[i].setAsDead();
-                        robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
-                    }
-                    else if (posts[j].isDoor()) {
-                        //do nothing
-                        robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
-                    }
-                    else if (!posts[j].isElectrified()) {
-                        //do nothing
-                        robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
-                    }
+        //robot catches player and player dies
+        if ((robots[robot_index].getRow() + robot_movement.dRow == player.getRow()) && (robots[robot_index].getCol() + robot_movement.dCol == player.getCol())) {
+            robots[robot_index].robotMove(robot_movement);
+            player.setAsDead();
+            setGameWin(game_lost); //assures the player has lost
+            robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
+        }
+        //robot goes into posts
+        for (unsigned int j = 0; j < posts.size(); j++) {
+            if ((posts[j].getRow() == robots[robot_index].getRow() + robot_movement.dRow) && (posts[j].getCol() == robots[robot_index].getCol() + robot_movement.dCol) && !robot_has_moved) {
+                if (posts[j].isElectrified()) {
+                    //robot doesnt move
+                    robots[robot_index].setAsDead(); //robot dies
+                    robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
                 }
-            }
-            //robot colides with another robot
-            for (unsigned int j = 0; j < robots.size(); j++) {
-                if ((robots[j].getRow() == robots[i].getRow() + robot_movement.dRow) && (robots[j].getCol() == robots[i].getCol() + robot_movement.dCol)) {
-                    if (robots[j].getID() != robots[i].getID()) {
-                        robots[i].robotMove(robot_movement);//puts player where he died
-                        robots[i].setAsDead();
-                        robots[j].setAsDead();
-                        robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
-                    }
-                    else {
-                        //do nothing
-                    }
+                else if (!posts[j].isElectrified() && !robot_has_moved) {
+                    robots[robot_index].robotMove(robot_movement);//puts robot where he died
+                    robots[robot_index].setAsDead();
+                    robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
                 }
             }
-            //robots move normally
-            if (!robot_has_moved) {
-                robots[i].robotMove(robot_movement);
+        }
+        //robot goes into door
+        for (unsigned int j = 0; j < gates.size(); j++) {
+            if ((gates[j].getRow() == robots[robot_index].getRow() + robot_movement.dRow) && (gates[j].getCol() == robots[robot_index].getCol() + robot_movement.dCol) && !robot_has_moved) {
+                //do nothing (robot cant move to door so it doesnt move)
+                robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
+            }
+        }
+        //robot colides with another robot
+        for (unsigned int j = 0; j < robots.size(); j++) {
+            if ((robots[j].getRow() == robots[robot_index].getRow() + robot_movement.dRow) && (robots[j].getCol() == robots[robot_index].getCol() + robot_movement.dCol) && !robot_has_moved) {
+                //only do it if it doesnt collide with itself
+                if (robots[j].getID() != robots[robot_index].getID() && !robot_has_moved) {
+                    robots[robot_index].robotMove(robot_movement);//puts player where he died
+                    robots[robot_index].setAsDead();
+                    robots[j].setAsDead();
+                    robot_has_moved = true; //sinaliaing the robot has already moved (so no defaut movement)
+                }
             }
         }
+        //robots move normally
+        if (!robot_has_moved) {
+            robots[robot_index].robotMove(robot_movement);
+        }
     }
 }