Rodex_

connect_4

Apr 26th, 2017
255
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 7.56 KB | None | 0 0
  1. ============= Player.h ==============
  2. #include <string>
  3. #include <vector>
  4.  
  5.  
  6. #ifndef CONNECT_FOUR_PLAYERS_H
  7. #define CONNECT_FOUR_PLAYERS_H
  8.  
  9. class player{
  10. public:
  11.     virtual ~player() {}
  12.     virtual int playTurn(int max) {return -1;}
  13. };
  14.  
  15. class HumanPlayer : public player {
  16.  
  17. public:
  18.     HumanPlayer() {}
  19.     ~HumanPlayer() {}
  20.     int playTurn(int max);
  21.  
  22. };
  23.  
  24. class ComputerPlayer : public player{
  25.  
  26. public:
  27.     ComputerPlayer();
  28.     ~ComputerPlayer() {}
  29.     int playTurn(int max);
  30.  
  31. };
  32.  
  33.  
  34.  
  35. class field{
  36. private:
  37.     int m_height;
  38.     int m_width;
  39.     char ** gameboard;
  40.  
  41. public:
  42.     field(int height, int width);
  43.     ~field();
  44.  
  45.     void print();
  46.  
  47.     bool setTurn(char player, int column);
  48.  
  49.     bool check_win(char player, int last_turn);
  50.  
  51.     bool check_draw();
  52.  
  53. };
  54.  
  55.  
  56. #endif //CONNECT_FOUR_PLAYERS_H
  57.  
  58.  
  59.  
  60. ============== Player.cpp =============
  61. #include "players.h"
  62. #include <iostream>
  63. #include <time.h>
  64. #include <cstdlib>
  65.  
  66. using namespace std;
  67.  
  68. field::field(int height, int width){
  69.     m_height = height;
  70.     m_width = width;
  71.     gameboard = new char *[height];
  72.  
  73.     for (int i = 0; i < height; i++) {
  74.         gameboard[i] = new char[width];
  75.     }
  76.  
  77.     for (int j = 0; j < height ; ++j) {
  78.         for (int i = 0; i < width; ++i) {
  79.             gameboard[j][i] = '.';
  80.         }
  81.     }
  82. }
  83.  
  84. field::~field() {
  85.     for (int i = 0; i < m_height; i++) {
  86.         delete[] gameboard[i];
  87.     }
  88.     delete[] gameboard;
  89. }
  90.  
  91. bool field::setTurn(char player, int column) {
  92.     for (int i = m_height - 1; i >= 0; --i) {
  93.         if(gameboard[i][column - 1] == '.'){
  94.             gameboard[i][column - 1] = player;
  95.             return true;
  96.         }
  97.     }
  98.     return false;
  99. }
  100.  
  101. bool field::check_win(char player, int column){
  102.     column --;
  103.     int row = 0;
  104.     int check_win = 0;
  105.     for (int i = 0; i < m_height; ++i) {
  106.         if(gameboard[i][column] == player){
  107.             row = i;
  108.             break;
  109.         }
  110.     }
  111.  
  112.     ///senkrechte Überprüfung
  113.     for (int j = row; j < m_height; ++j) {
  114.         if(gameboard[j][column] == player){
  115.             check_win ++;
  116.         }else{
  117.             break;
  118.         }
  119.     }
  120.  
  121.     if (check_win == 4){
  122.         return true;
  123.     }
  124.  
  125.     ///Waagrechte Überprüfung
  126.     check_win = 0;
  127.     for (int j = column + 1; j < m_width ; ++j) {
  128.         if(gameboard[row][j] == player){
  129.             check_win ++;
  130.         }else{
  131.             break;
  132.         }
  133.     }
  134.     for (int j = column - 1; j >= 0; --j) {
  135.         if(gameboard[row][j] == player){
  136.             check_win ++;
  137.         }else{
  138.             break;
  139.         }
  140.     }
  141.     if (check_win == 3){
  142.         return true;
  143.     }
  144.  
  145.     ///Diagonale Überprüfung
  146.     int row_tmp = row;
  147.     check_win = 0;
  148.     ///links oben -> rechts unten
  149.     for (int j = column; j <  m_width; ++j) {
  150.         if(gameboard[row_tmp][j] == player){
  151.             if(row_tmp == m_height - 1){
  152.                 check_win ++;
  153.                 break;
  154.             }else{
  155.                 row_tmp ++;
  156.                 check_win ++;
  157.             }
  158.         }else{
  159.             break;
  160.         }
  161.     }
  162.  
  163.     if (row != 0) {
  164.         row_tmp = row - 1;
  165.         for (int j = column - 1; j > m_width; --j) {
  166.             if (gameboard[row_tmp][j] == player) {
  167.                 if (row_tmp == 0) {
  168.                     check_win++;
  169.                     break;
  170.                 } else {
  171.                     row_tmp--;
  172.                     check_win++;
  173.                 }
  174.             } else {
  175.                 break;
  176.             }
  177.         }
  178.     }
  179.     if (check_win == 4){
  180.         return true;
  181.     }
  182.     ///rechts oben -> links unten
  183.  
  184.     row_tmp = row;
  185.     check_win = 0;
  186.  
  187.     for (int j = column; j < m_width; ++j) {
  188.         if(gameboard[row_tmp][j] == player){
  189.             if(row_tmp == 0){
  190.                 check_win ++;
  191.                 break;
  192.             }else{
  193.                 row_tmp --;
  194.                 check_win ++;
  195.             }
  196.         }else{
  197.             break;
  198.         }
  199.     }
  200.  
  201.     if(row != m_height - 1){
  202.         row_tmp = row + 1;
  203.         for (int j = column - 1; j >= 0; --j) {
  204.             if(gameboard[row_tmp][j] == player){
  205.                 if(row_tmp == m_height - 1){
  206.                     check_win ++;
  207.                     break;
  208.                 }else{
  209.                     row_tmp ++;
  210.                     check_win ++;
  211.                 }
  212.             }else{
  213.                 break;
  214.             }
  215.         }
  216.     }
  217.  
  218.     if (check_win == 4){
  219.         return true;
  220.     }else{
  221.         return false;
  222.     }
  223. }
  224.  
  225. bool field::check_draw() {
  226.     for (int i = 0; i < m_width; ++i) {
  227.         if(gameboard[0][i] == '.'){
  228.             return false;
  229.         }
  230.     }
  231.     return true;
  232. }
  233.  
  234. void field::print() {
  235.     for (int j = 0; j < m_height; ++j) {
  236.         for (int i = 0; i < m_width; ++i) {
  237.             cout << gameboard[j][i];
  238.         }
  239.         cout << j + 1;
  240.         cout << endl;
  241.     }
  242.     for (int k = 0; k < m_width; ++k) {
  243.         cout << k + 1;
  244.     }
  245.     cout << endl;
  246. }
  247.  
  248. ComputerPlayer::ComputerPlayer() {
  249.     srand((unsigned)time(NULL));
  250. }
  251.  
  252. int HumanPlayer::playTurn(int max) {
  253.     int column;
  254.     cout << "Welche Spalte soll die Muenze eingeworfen werden: 1-" << max << endl;
  255.         cin >> column;
  256.     return column;
  257. }
  258.  
  259. int ComputerPlayer::playTurn(int max) {
  260.     return rand() % max + 1;
  261. }
  262.  
  263.  
  264. =============== connect4.cpp =============
  265. #include <iostream>
  266. #include "players.h"
  267.  
  268. using namespace std;
  269.  
  270. int main() {
  271.     int height, width, gamemode, turn;
  272.     bool check_win = false;
  273.     bool check_turn = false;
  274.  
  275.     cout << "Height: " << endl;
  276.         cin >> height;
  277.     cout << "Width: " << endl;
  278.         cin >> width;
  279.     cout << "Gamemode:" << endl << "1 = Player vs Player" << endl << "2 = Player vs Computer" << endl << "3 = Computer vs Computer" << endl;
  280.         cin >> gamemode;
  281.  
  282.     field *GameBoard = new field (height, width);
  283.  
  284.     player *Player1;
  285.     player *Player2;
  286.     switch  (gamemode){
  287.         case 1:
  288.             Player1 = new HumanPlayer();
  289.             Player2 = new HumanPlayer();
  290.             break;
  291.  
  292.         case 2:
  293.             Player1 = new HumanPlayer();
  294.             Player2 = new ComputerPlayer();
  295.             break;
  296.  
  297.  
  298.         default:
  299.             Player1 = new ComputerPlayer();
  300.             Player2 = new ComputerPlayer();
  301.             break;
  302.     }
  303.  
  304.     while (!check_win) {
  305.         check_turn = false;
  306.         GameBoard->print();
  307.         while(!check_turn) {
  308.             turn = Player1->playTurn(width);
  309.             check_turn = GameBoard->setTurn('X', turn);
  310.         }
  311.         if(GameBoard->check_win('X', turn)) {
  312.             check_win = true;
  313.             GameBoard->print();
  314.             cout << "Player 1 wins!" << endl;
  315.         }
  316.         if(GameBoard->check_draw()){
  317.             check_win = true;
  318.             GameBoard->print();
  319.             cout << "It's a draw" << endl;
  320.         }
  321.         if(!check_win){
  322.             GameBoard->print();
  323.             check_turn = false;
  324.             while(!check_turn){
  325.                 turn = Player2->playTurn(width);
  326.                 check_turn = GameBoard->setTurn('O', turn);
  327.             }
  328.             if(GameBoard->check_draw()){
  329.                 check_win = true;
  330.                 GameBoard->print();
  331.                 cout << "It's a draw" << endl;
  332.             }
  333.             if(GameBoard->check_win('O', turn)) {
  334.                 check_win = true;
  335.                 GameBoard->print();
  336.                 cout << "Player 2 wins!" << endl;
  337.             }
  338.         }
  339.     }
  340.  
  341.     delete Player1;
  342.     delete Player2;
  343.     delete GameBoard;
  344.     return 0;
  345. }
Advertisement
Add Comment
Please, Sign In to add comment