daily pastebin goal
34%
SHARE
TWEET

Untitled

a guest Feb 20th, 2019 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /**************** Course : TCP1101 Programming Fundamentals Session: Trimester 2, 2018/19
  2. Name: Hasaan Khurshid Naqash
  3. ID : 1181301410
  4. Lecture Section : TC02
  5. Tutorial Section: TT03
  6. Assignment: 02
  7. Email: naqashhasaan2@gmail.com
  8. Phone: +60 1169614180.**************/
  9.  
  10.  
  11.  
  12.  
  13. #include <iostream>
  14. #include <iomanip>
  15. #include <cstdlib>
  16. #include <string>
  17. #include <ctime>
  18. #include <vector>
  19. #include <windows.h>
  20. using namespace std;
  21.  
  22. const char HILL = '$', TRAP = '#', GOLD = '*', HIDDEN = '?', TRAPPED = '@';
  23.  
  24. enum Direction
  25. {
  26.     north = 0,
  27.     east = 1,
  28.     west = 2,
  29.     south = 3
  30. };
  31.  
  32. class Map
  33. {
  34. private:
  35.     vector < vector<char> > map;
  36.     int dimX, dimY, roverX, roverY;
  37.     char objectUnderRover;
  38.     Direction heading;
  39. public:
  40.     Map()//constructor
  41.     {
  42.         dimX = 0;
  43.         dimY = 0;
  44.         roverX = 0;
  45.         roverY = 0;
  46.     }
  47.     Map(int dimx, int dimy)//overloaded constructor
  48.     {
  49.         dimX = dimx;
  50.         dimY = dimy;
  51.         roverX = dimx/2;
  52.         roverY = dimy/2;
  53.         init();
  54.     }
  55.     void init()
  56.     {
  57.         const int noOfObjects = 10;  //number of objects in the objects array
  58.         char objects[noOfObjects] = {' ', ' ', ' ', ' ', ' ', ' ',
  59.             HILL, HILL, TRAP, TRAP };
  60.        
  61.         //create dynamic 2D array using vector
  62.         map.resize(dimY);        //create rows
  63.         for (int i=0; i<dimY; ++i)
  64.         {
  65.             map[i].resize(dimX);  //resize each rows
  66.         }
  67.        
  68.         //put random chars into the vector array
  69.        
  70.         unsigned int seed = static_cast<unsigned int>(time(NULL));
  71.         srand(seed);        // seed needs to be set only once in the entire program
  72.        
  73.         for (int i=0; i<dimY; ++i)
  74.         {
  75.             for (int j=0; j<dimX; ++j)
  76.             {
  77.                 int objNo = rand() % noOfObjects;
  78.                 map[i][j] =  objects[objNo];
  79.             }
  80.         }
  81.     }
  82.    
  83.     void populateGold(int quantity)
  84.     {
  85.         roverX = dimY/2;
  86.         roverY = dimX/2;
  87.         int goldDeployed = 0;
  88.         map[roverX][roverY] = ' ';  // sets center of map to be empty
  89.         do {
  90.             const int SIZE = 4;
  91.             Direction directions[SIZE] = {north, east, west, south};
  92.            
  93.             int dir = rand() % SIZE;
  94.             heading = directions[dir];
  95.             int randNum = rand() % 10;
  96.             if (randNum == 0 || randNum == 1)
  97.             {
  98.                 turnRight();
  99.             }
  100.             else if (randNum == 8 || randNum == 9)
  101.             {
  102.                 turnLeft();
  103.             }
  104.             else
  105.             {
  106.                 move();
  107.                 int randNumGold = rand() % 10;
  108.                 if (randNumGold == 0)
  109.                 {
  110.                     if (objectUnderRover != GOLD)
  111.                     {
  112.                         map[roverX][roverY] = GOLD;
  113.                         goldDeployed++;
  114.                     }
  115.                 }
  116.             }
  117.         } while(goldDeployed<quantity);
  118.     }
  119.    
  120.     void turnLeft()
  121.     {
  122.         switch (heading) {
  123.             case north:
  124.                 heading = west;
  125.                 break;
  126.             case east:
  127.                 heading = north;
  128.                 break;
  129.             case west:
  130.                 heading = south;
  131.                 break;
  132.             case south:
  133.                 heading = east;
  134.                 break;
  135.         }
  136.     }
  137.     void turnRight()
  138.     {
  139.         switch (heading) {
  140.             case north:
  141.                 heading = east;
  142.                 break;
  143.             case east:
  144.                 heading = south;
  145.                 break;
  146.             case west:
  147.                 heading = north;
  148.                 break;
  149.             case south:
  150.                 heading = west;
  151.                 break;
  152.         }
  153.     }
  154.    
  155.     void move()
  156.     {
  157.         switch (heading) {
  158.             case north:
  159.                 if (isInsideMap(roverX-1, roverY))
  160.                 {
  161.                     roverX-=1;
  162.                     objectUnderRover = map[roverX][roverY];
  163.                     if (objectUnderRover != GOLD)
  164.                     {
  165.                         map[roverX][roverY] = ' ';
  166.                     }
  167.                 }
  168.                 else
  169.                 {
  170.                     heading = south;
  171.                 }
  172.                 break;
  173.             case east:
  174.                 if (isInsideMap(roverX, roverY+1))
  175.                 {
  176.                     roverY+=1;
  177.                     objectUnderRover = map[roverX][roverY];
  178.                     if (objectUnderRover != GOLD)
  179.                     {
  180.                         map[roverX][roverY] = ' ';
  181.                     }
  182.                 }
  183.                 else
  184.                 {
  185.                     heading = west;
  186.                 }
  187.                 break;
  188.             case west:
  189.                 if (isInsideMap(roverX, roverY-1))
  190.                 {
  191.                     roverY-=1;
  192.                     objectUnderRover = map[roverX][roverY];
  193.                     if (objectUnderRover != GOLD)
  194.                     {
  195.                         map[roverX][roverY] = ' ';
  196.                     }
  197.                 }
  198.                 else
  199.                 {
  200.                     heading = east;
  201.                 }
  202.                 break;
  203.             case south:
  204.                 if (isInsideMap(roverX+1, roverY))
  205.                 {
  206.                     roverX+=1;
  207.                     objectUnderRover = map[roverX][roverY];
  208.                     if (objectUnderRover != GOLD)
  209.                     {
  210.                         map[roverX][roverY] = ' ';
  211.                     }
  212.                 }
  213.                 else
  214.                 {
  215.                     heading = north;
  216.                 }
  217.                 break;
  218.         }
  219.     }
  220.    
  221.     void resize(int dimx, int dimy, char ch)
  222.     {
  223.         dimX = dimx;
  224.         dimY = dimy;
  225.         map.resize(dimy);        //create rows
  226.         for (int i=0; i<dimy; ++i)
  227.         {
  228.             map[i].resize(dimx);  //resize each rows
  229.         }
  230.         for (int i=0; i<dimy; ++i)
  231.         {
  232.             for (int j=0; j<dimx; ++j)
  233.             {
  234.                 map[i][j] = ch;
  235.             }
  236.         }
  237.     }
  238.    
  239.    
  240.     void display()
  241.     {
  242.         cout << "\n  --__--__--Welcome to Mars!--__--__--" << endl;
  243.        
  244.         for (int i=0; i<dimY; ++i)
  245.         {
  246.             cout << "  ";
  247.             for (int j=0; j<dimX; ++j)
  248.             {
  249.                 cout << "+-";
  250.             }
  251.             cout << "+" << endl;
  252.             cout << setw(2) << (dimY-i);
  253.             for (int j=0; j<dimX; ++j)
  254.             {
  255.                 cout << "|" << map[i][j];
  256.             }
  257.             cout << "|" << endl;
  258.         }
  259.        
  260.         cout << "  ";
  261.         for (int j=0; j<dimX; ++j)
  262.         {
  263.             cout << "+-";
  264.         }
  265.         cout << "+" << endl;
  266.        
  267.         cout << "  ";
  268.         for (int j=0; j<dimX; ++j)
  269.         {
  270.             int digit = (j+1)/10;
  271.             cout << " ";
  272.             if (digit==0)
  273.                 cout << " ";
  274.             else
  275.                 cout << digit;
  276.         }
  277.         cout << endl;
  278.         cout << "  ";
  279.         for (int j=0; j<dimX; ++j)
  280.         {
  281.             cout << " " << (j+1)%10;
  282.         }
  283.         cout << endl << endl;
  284.     }
  285.     void setObject(int x, int y, char ch)
  286.     {
  287.         map[x][y] = ch;
  288.     }
  289.     char getObject(int x, int y)
  290.     {
  291.         char object = map[x][y];
  292.         return object;
  293.     }
  294.     bool isEmpty(int x, int y)
  295.     {
  296.         if(getObject(x, y) == ' ')
  297.         {
  298.             return true;
  299.         }
  300.         else
  301.             return false;
  302.     }
  303.     bool isHill(int x, int y)
  304.     {
  305.         if(getObject(x, y) == HILL)
  306.         {
  307.             return true;
  308.         }
  309.         else
  310.             return false;
  311.     }
  312.     bool isTrap(int x, int y)
  313.     {
  314.         if(getObject(x, y) == TRAP)
  315.         {
  316.             return true;
  317.         }
  318.         else
  319.             return false;
  320.     }
  321.     bool isGold(int x, int y)
  322.     {
  323.         if (getObject(x, y) == GOLD) {
  324.             return true;
  325.         }
  326.         else
  327.             return false;
  328.     }
  329.     bool isInsideMap(int x, int y)
  330.     {
  331.         if ((x>=0 && x<dimY) && (y>=0 && y<dimX))
  332.         {
  333.             return true;
  334.         }
  335.         else
  336.             return false;
  337.     }
  338.     int getDimX()
  339.     {
  340.         return dimX;
  341.     }
  342.     int getDimY()
  343.     {
  344.         return dimY;
  345.     }
  346. }; //Map
  347.  
  348. class Rover
  349. {
  350. private:
  351.     int x, y, goldCollected = 0;
  352.     bool quit = false;
  353.     Direction heading;
  354.     char objectUnderRover;
  355.     Map* ptrToMars; //a pointer to the map for Mars
  356.     Map mapper; //a map that keeps track of observed cells so far
  357. public:
  358.     Rover()
  359.     {
  360.     }
  361.    
  362.     void land(Map& mars) //links a map of Mars to a Rover
  363.     {
  364.         int dimX = mars.getDimX(), dimY = mars.getDimY();
  365.         ptrToMars = &mars;
  366.         mapper.resize(dimX, dimY, HIDDEN);
  367.         x = dimX/2;
  368.         y = dimY/2;
  369.        
  370.         const int SIZE = 4;
  371.         Direction directions[SIZE] = {north, east, west, south};
  372.        
  373.         int dir = rand() % SIZE;
  374.         heading = directions[dir];
  375.        
  376.         switch (heading) {
  377.             case north:
  378.                 mapper.setObject(y, x, '^');
  379.                 unhideNearbyObj();
  380.                 break;
  381.             case east:
  382.                 mapper.setObject(y, x, '>');
  383.                 unhideNearbyObj();
  384.                 break;
  385.             case west:
  386.                 mapper.setObject(y, x, '<');
  387.                 unhideNearbyObj();
  388.                 break;
  389.             case south:
  390.                 mapper.setObject(y, x, 'v');
  391.                 unhideNearbyObj();
  392.                 break;
  393.         }
  394.     }
  395.    
  396.     Map* getPtrToMars()
  397.     {
  398.         return ptrToMars;
  399.     }
  400.    
  401.     int getGoldCollected()
  402.     {
  403.         return goldCollected;
  404.     }
  405.    
  406.     void setGoldCollected(int no)
  407.     {
  408.         goldCollected = no;
  409.     }
  410.    
  411.     char getObjUnderRover()
  412.     {
  413.         return objectUnderRover;
  414.     }
  415.    
  416.     void setObjUnderRover(char obj)
  417.     {
  418.         objectUnderRover = obj;
  419.     }
  420.    
  421.     bool getQuitVal()
  422.     {
  423.         return quit;
  424.     }
  425.    
  426.     void unhideNearbyObj() {
  427.         switch (heading) {
  428.             case north:
  429.                 if(mapper.isInsideMap(y-1, x))
  430.                 {
  431.                     mapper.setObject(y-1, x, ptrToMars->getObject(y-1, x));
  432.                 }
  433.                 if(mapper.isInsideMap(y-1, x-1))
  434.                 {
  435.                     mapper.setObject(y-1, x-1, ptrToMars->getObject(y-1, x-1));
  436.                 }
  437.                 if(mapper.isInsideMap(y-1, x+1))
  438.                 {
  439.                     mapper.setObject(y-1, x+1, ptrToMars->getObject(y-1, x+1));
  440.                 }
  441.                 break;
  442.             case east:
  443.                 if(mapper.isInsideMap(y, x+1))
  444.                 {
  445.                     mapper.setObject(y, x+1, ptrToMars->getObject(y, x+1));
  446.                 }
  447.                 if(mapper.isInsideMap(y-1, x+1))
  448.                 {
  449.                     mapper.setObject(y-1, x+1, ptrToMars->getObject(y-1, x+1));
  450.                 }
  451.                 if(mapper.isInsideMap(y+1, x+1))
  452.                 {
  453.                     mapper.setObject(y+1, x+1, ptrToMars->getObject(y+1, x+1));
  454.                 }
  455.                 break;
  456.             case west:
  457.                 if(mapper.isInsideMap(y, x-1))
  458.                 {
  459.                     mapper.setObject(y, x-1, ptrToMars->getObject(y, x-1));
  460.                 }
  461.                 if(mapper.isInsideMap(y-1, x-1))
  462.                 {
  463.                     mapper.setObject(y-1, x-1, ptrToMars->getObject(y-1, x-1));
  464.                 }
  465.                 if(mapper.isInsideMap(y+1, x-1))
  466.                 {
  467.                     mapper.setObject(y+1, x-1, ptrToMars->getObject(y+1, x-1));
  468.                 }
  469.                 break;
  470.             case south:
  471.                 if(mapper.isInsideMap(y+1, x))
  472.                 {
  473.                     mapper.setObject(y+1, x, ptrToMars->getObject(y+1, x));
  474.                 }
  475.                 if(mapper.isInsideMap(y+1, x-1))
  476.                 {
  477.                     mapper.setObject(y+1, x-1, ptrToMars->getObject(y+1, x-1));
  478.                 }
  479.                 if(mapper.isInsideMap(y+1, x+1))
  480.                 {
  481.                     mapper.setObject(y+1, x+1, ptrToMars->getObject(y+1, x+1));
  482.                 }
  483.                 break;
  484.         }
  485.     }
  486.    
  487.     bool turnLeft()
  488.     {
  489.         switch (heading) {
  490.             case north:
  491.                 mapper.setObject(y, x, '<');
  492.                 heading = west;
  493.                 unhideNearbyObj();
  494.                 break;
  495.             case east:
  496.                 mapper.setObject(y, x, '^');
  497.                 heading = north;
  498.                 unhideNearbyObj();
  499.                 break;
  500.             case west:
  501.                 mapper.setObject(y, x, 'v');
  502.                 heading = south;
  503.                 unhideNearbyObj();
  504.                 break;
  505.             case south:
  506.                 mapper.setObject(y, x, '>');
  507.                 heading = east;
  508.                 unhideNearbyObj();
  509.                 break;
  510.         }
  511.         return true;
  512.     }
  513.     bool turnRight()
  514.     {
  515.         switch (heading) {
  516.             case north:
  517.                 mapper.setObject(y, x, '>');
  518.                 heading = east;
  519.                 unhideNearbyObj();
  520.                 break;
  521.             case east:
  522.                 mapper.setObject(y, x, 'v');
  523.                 heading = south;
  524.                 unhideNearbyObj();
  525.                 break;
  526.             case west:
  527.                 mapper.setObject(y, x, '^');
  528.                 heading = north;
  529.                 unhideNearbyObj();
  530.                 break;
  531.             case south:
  532.                 mapper.setObject(y, x, '<');
  533.                 heading = west;
  534.                 unhideNearbyObj();
  535.                 break;
  536.         }
  537.         return true;
  538.     }
  539.     bool move()
  540.     {
  541.         switch (heading) {
  542.             case north:
  543.                 if ((mapper.isInsideMap(y-1, x)) && (mapper.isEmpty(y-1, x)==true))
  544.                 {
  545.                     mapper.setObject(y, x, ' ');
  546.                     y-=1;
  547.                     objectUnderRover = mapper.getObject(y, x);
  548.                     mapper.setObject(y, x, '^');
  549.                     unhideNearbyObj();
  550.                     return true;
  551.                 }
  552.                 else if ((mapper.isInsideMap(y-1, x)) && (mapper.isTrap(y-1, x)==true))
  553.                 {
  554.                     mapper.setObject(y, x, ' ');
  555.                     y-=1;
  556.                     objectUnderRover = mapper.getObject(y, x);
  557.                     mapper.setObject(y, x, TRAPPED);
  558.                     unhideNearbyObj();
  559.                     return true;
  560.                 }
  561.                 else if ((mapper.isInsideMap(y-1, x)) && (mapper.isGold(y-1, x)==true))
  562.                 {
  563.                     mapper.setObject(y, x, ' ');
  564.                     y-=1;
  565.                     objectUnderRover = mapper.getObject(y, x);
  566.                     goldCollected++;
  567.                     mapper.setObject(y, x, '^');
  568.                     ptrToMars->setObject(y, x, ' ');
  569.                     unhideNearbyObj();
  570.                     return true;
  571.                 }
  572.                 else
  573.                     return false;
  574.                 break;
  575.             case east:
  576.                 if ((mapper.isInsideMap(y, x+1)) && (mapper.isEmpty(y, x+1)==true))
  577.                 {
  578.                     mapper.setObject(y, x, ' ');
  579.                     x+=1;
  580.                     objectUnderRover = mapper.getObject(y, x);
  581.                     mapper.setObject(y, x, '>');
  582.                     unhideNearbyObj();
  583.                     return true;
  584.                 }
  585.                 else if ((mapper.isInsideMap(y, x+1)) && (mapper.isTrap(y, x+1)==true))
  586.                 {
  587.                     mapper.setObject(y, x, ' ');
  588.                     x+=1;
  589.                     objectUnderRover = mapper.getObject(y, x);
  590.                     mapper.setObject(y, x, TRAPPED);
  591.                     unhideNearbyObj();
  592.                     return true;
  593.                 }
  594.                 else if ((mapper.isInsideMap(y, x+1)) && (mapper.isGold(y, x+1)==true))
  595.                 {
  596.                     mapper.setObject(y, x, ' ');
  597.                     x+=1;
  598.                     objectUnderRover = mapper.getObject(y, x);
  599.                     goldCollected++;
  600.                     mapper.setObject(y, x, '>');
  601.                     ptrToMars->setObject(y, x, ' ');
  602.                     unhideNearbyObj();
  603.                     return true;
  604.                 }
  605.                 else
  606.                     return false;
  607.                 break;
  608.             case west:
  609.                 if ((mapper.isInsideMap(y, x-1)) && (mapper.isEmpty(y, x-1)==true))
  610.                 {
  611.                     mapper.setObject(y, x, ' ');
  612.                     x-=1;
  613.                     objectUnderRover = mapper.getObject(y, x);
  614.                     mapper.setObject(y, x, '<');
  615.                     unhideNearbyObj();
  616.                     return true;
  617.                 }
  618.                 else if ((mapper.isInsideMap(y, x-1)) && (mapper.isTrap(y, x-1)==true))
  619.                 {
  620.                     mapper.setObject(y, x, ' ');
  621.                     x-=1;
  622.                     objectUnderRover = mapper.getObject(y, x);
  623.                     mapper.setObject(y, x, TRAPPED);
  624.                     unhideNearbyObj();
  625.                     return true;
  626.                 }
  627.                 else if ((mapper.isInsideMap(y, x-1)) && (mapper.isGold(y, x-1)==true))
  628.                 {
  629.                     mapper.setObject(y, x, ' ');
  630.                     x-=1;
  631.                     objectUnderRover = mapper.getObject(y, x);
  632.                     goldCollected++;
  633.                     mapper.setObject(y, x, '<');
  634.                     ptrToMars->setObject(y, x, ' ');
  635.                     unhideNearbyObj();
  636.                     return true;
  637.                 }
  638.                 else
  639.                     return false;
  640.                 break;
  641.             case south:
  642.                 if ((mapper.isInsideMap(y+1, x)) && (mapper.isEmpty(y+1, x)==true))
  643.                 {
  644.                     mapper.setObject(y, x, ' ');
  645.                     y+=1;
  646.                     objectUnderRover = mapper.getObject(y, x);
  647.                     mapper.setObject(y, x, 'v');
  648.                     unhideNearbyObj();
  649.                     return true;
  650.                 }
  651.                 else if ((mapper.isInsideMap(y+1, x)) && (mapper.isTrap(y+1, x)==true))
  652.                 {
  653.                     mapper.setObject(y, x, ' ');
  654.                     y+=1;
  655.                     objectUnderRover = mapper.getObject(y, x);
  656.                     mapper.setObject(y, x, TRAPPED);
  657.                     unhideNearbyObj();
  658.                     return true;
  659.                 }
  660.                 else if ((mapper.isInsideMap(y+1, x)) && (mapper.isGold(y+1, x)==true))
  661.                 {
  662.                     mapper.setObject(y, x, ' ');
  663.                     y+=1;
  664.                     objectUnderRover = mapper.getObject(y, x);
  665.                     goldCollected++;
  666.                     mapper.setObject(y, x, 'v');
  667.                     ptrToMars->setObject(y, x, ' ');
  668.                     unhideNearbyObj();
  669.                     return true;
  670.                 }
  671.                 else
  672.                     return false;
  673.                 break;
  674.         }
  675.     }
  676.     void displayMapper()
  677.     {
  678.         int dimX = mapper.getDimX(), dimY = mapper.getDimY();
  679.         cout << "\n  --__--__--Mars Rover Mapper--__--__--" << endl;
  680.        
  681.         for (int i=0; i<dimY; ++i)
  682.         {
  683.             cout << "  ";
  684.             for (int j=0; j<dimX; ++j)
  685.             {
  686.                 cout << "+-";
  687.             }
  688.             cout << "+" << endl;
  689.             cout << setw(2) << (dimY-i);
  690.             for (int j=0; j<dimX; ++j)
  691.             {
  692.                 cout << "|" << mapper.getObject(i, j);
  693.             }
  694.             cout << "|" << endl;
  695.         }
  696.        
  697.         cout << "  ";
  698.         for (int j=0; j<dimX; ++j)
  699.         {
  700.             cout << "+-";
  701.         }
  702.         cout << "+" << endl;
  703.        
  704.         cout << "  ";
  705.         for (int j=0; j<dimX; ++j)
  706.         {
  707.             int digit = (j+1)/10;
  708.             cout << " ";
  709.             if (digit==0)
  710.                 cout << " ";
  711.             else
  712.                 cout << digit;
  713.         }
  714.         cout << endl;
  715.         cout << "  ";
  716.         for (int j=0; j<dimX; ++j)
  717.         {
  718.             cout << " " << (j+1)%10;
  719.         }
  720.         cout << endl << endl;
  721.     }
  722.     bool executeCommand(char command) {
  723.         bool success;
  724.         if (command == 'M')
  725.         {
  726.             success = move();
  727.            
  728.             return success;
  729.         }
  730.         else if (command == 'R')
  731.         {
  732.             success = turnRight();
  733.             return success;
  734.            
  735.         }
  736.         else if (command == 'L')
  737.         {
  738.             success = turnLeft();
  739.             return success;
  740.         }
  741.         else if (command == 'Q')
  742.         {
  743.             quit = true;
  744.             return true;
  745.         }
  746.         else
  747.             return false;
  748.     }
  749. }; //Rover
  750.  
  751. void menu();
  752. void score(int, int, int, int);
  753. void enterCSeq(Rover&, int*, int*, int*, char*);
  754.  
  755.  
  756. int main()
  757. {
  758.     system("CLS");
  759.     char again = 'Y';
  760.     char *ptrToAgain = &again;
  761.     do
  762.     {
  763.         int dimx, dimy, noOfGold, commandSScore = 0, totalCommands = 0;
  764.         int *ptrToNoOfGold = &noOfGold, *ptrToCSScore = &commandSScore, *ptrToTotalCommands = &totalCommands;
  765.         cout << "Let's explore Mars..." << endl;
  766.         cout << "Mars Dimension X => ";
  767.         cin >> dimx;
  768.         while (dimx<1 || dimx>30) {
  769.             cout << "Please enter an integer between 1-30" << endl;
  770.             cout << "Mars Dimension X => ";
  771.             cin >> dimx;
  772.         }
  773.         cout << "Mars Dimension Y => ";
  774.         cin >> dimy;
  775.         while (dimy<1 || dimy>30) {
  776.             cout << "Please enter an integer between 1-30" << endl;
  777.             cout << "Mars Dimension Y => ";
  778.             cin >> dimy;
  779.         }
  780.         cout << "No of Golds => ";
  781.         cin >> noOfGold;
  782.         int factorX = dimx*dimy;
  783.         while (noOfGold>factorX-1) {
  784.             cout << "Please Enter the gold less than " << factorX << endl;
  785.             cout << "No of Golds => ";
  786.             cin >> noOfGold;
  787.         }
  788.         Map mars(dimx, dimy);
  789.         mars.populateGold(noOfGold);
  790.         Rover curiosity;
  791.         curiosity.land(mars);
  792.         do
  793.         {
  794.             curiosity.displayMapper();
  795.             menu();
  796.             score(commandSScore, totalCommands, curiosity.getGoldCollected(), noOfGold);
  797.             enterCSeq(curiosity, ptrToNoOfGold, ptrToCSScore, ptrToTotalCommands, ptrToAgain);
  798.         } while (again == 'Y' || again == 'y');
  799.         cout << "Do you want to explore Mars again? => ";
  800.         cin >> again;
  801.     } while (again == 'Y' || again == 'y');
  802.     cout << "\nGood Bye from Mars!" << endl;
  803.     cout << endl;
  804.     cout << endl;
  805.     cout << endl;
  806.    
  807.     cout << "+++++++++++++++++++++++++++++++++++++++++++++" << endl;
  808.     cout << "+                                           +" << endl;
  809.     cout << "+    Developed by Hasaan Khurshid Naqash    +" << endl;
  810.     cout << "+                                           +" << endl;
  811.     cout << "+++++++++++++++++++++++++++++++++++++++++++++" << endl;
  812.     return 0;
  813.    
  814. }
  815.  
  816. void menu()
  817. {
  818.     cout << "\nMission: Get all the golds!!, Do not get trapped!!" << endl;
  819.     cout << "L=Turn Left, R=Turn Right, M=Move, Q=Quit" << endl;
  820.     cout << HILL << "=Hill " << TRAP << "=Trap " << GOLD << "=Gold" << endl;
  821. }
  822.  
  823. void score(int cScore, int commands, int gCollected, int totalGold)
  824. {
  825.     int totalScore = gCollected*50-cScore*5-commands*1;
  826.     cout << "\nTotal Command Sequences = " << cScore << " [S]" << endl;
  827.     cout << "Total Commands = " << commands << " [C]" << endl;
  828.     cout << "Total Golds = " << gCollected << " [G] out of " << totalGold << endl;
  829.     cout << "Total Score = [G] x 50 - [S] x 5 - [C] x 1 = " << totalScore << endl;
  830. }
  831.  
  832. void enterCSeq(Rover& curiosity, int* noOfGold, int* commandSScore, int* totalCommands, char* again)
  833. {
  834.     if (curiosity.getObjUnderRover() != TRAP && curiosity.getGoldCollected() < *noOfGold && curiosity.getQuitVal() == false)
  835.     {
  836.         cout << "\nExample Sequence: MMLMMMRMMRMRMLLL" << endl;
  837.         cout << "Enter command sequence => ";
  838.         string commandSequence;
  839.         getline(cin >> ws, commandSequence);
  840.         *commandSScore = *commandSScore+1;
  841.        
  842.         int len = static_cast<int>(commandSequence.length());
  843.         *totalCommands += commandSequence.length();
  844.        
  845.         for (int i=0; i<len; ++i)
  846.         {
  847.             char command = commandSequence[i];
  848.             command = toupper(command);   //convert to upper case
  849.            
  850.             curiosity.displayMapper();
  851.             cout << "Command = " << command << " ..." << endl;
  852.            Sleep(2000);
  853.            system("CLS");
  854.             bool success = curiosity.executeCommand(command);
  855.            
  856.             curiosity.displayMapper();
  857.            
  858.             cout << "Command = " << command;
  859.            
  860.             if (success)
  861.                 cout << " [executed]" << endl;
  862.             else
  863.                 cout << " [failed to execute]" << endl;
  864.         }
  865.     }
  866.     else if (curiosity.getGoldCollected() == *noOfGold)
  867.     {
  868.         cout << "\nCongratz, Mission ACCOMPLISHED!!" << endl;
  869.         cout << "\nDo you want to see the Map of Mars? => ";
  870.         char seeMapMars;
  871.         cin >> seeMapMars;
  872.         if (seeMapMars == 'Y' || seeMapMars == 'y') {
  873.             curiosity.getPtrToMars()->display();
  874.         }
  875.         *again = 'N';
  876.         curiosity.setObjUnderRover(' ');
  877.         curiosity.setGoldCollected(0);
  878.     }
  879.     else if (curiosity.getObjUnderRover() == TRAP)
  880.     {
  881.         cout << "\nTRAPPED, Mission FAILED!!" << endl;
  882.         cout << "\nDo you want to see the Map of Mars? => ";
  883.         char seeMapMars;
  884.         cin >> seeMapMars;
  885.         if (seeMapMars == 'Y' || seeMapMars == 'y') {
  886.             curiosity.getPtrToMars()->display();
  887.         }
  888.         *again = 'N';
  889.         curiosity.setObjUnderRover(' ');
  890.         curiosity.setGoldCollected(0);
  891.     }
  892.     else if (curiosity.getQuitVal() == true)
  893.     {
  894.         cout << "\nQUITTED, Mission FAILED!!" << endl;
  895.         cout << "\nDo you want to see the Map of Mars? => ";
  896.         char seeMapMars;
  897.         cin >> seeMapMars;
  898.         if (seeMapMars == 'Y' || seeMapMars == 'y') {
  899.             curiosity.getPtrToMars()->display();
  900.         }
  901.         *again = 'N';
  902.         curiosity.setObjUnderRover(' ');
  903.         curiosity.setGoldCollected(0);
  904.     }
  905. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top