starfoxleader

Untitled

Sep 27th, 2020
746
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #ifndef RECT_H
  2. #define RECT_H
  3.  
  4.  
  5. struct Rect {
  6.  
  7.     int matrix[3][3];
  8.  
  9.     float x;
  10.     float y;
  11.  
  12.     float red;
  13.     float green;
  14.     float blue;
  15.  
  16.     float w;
  17.     float h;
  18.  
  19.     bool selected;
  20.  
  21.     Rect(); // This is a default constructor (takes no parameters)
  22.  
  23.     Rect(float x, float y, float w, float h);
  24.  
  25.     Rect(float x, float y, float w, float h, float red, float green, float blue);
  26.  
  27.     void draw();
  28.  
  29.     bool playerCircle;
  30.     bool contains(int x, int y);
  31.     bool singlePlayer;
  32.  
  33.     int result();
  34.  
  35.     void input(float x, float y);
  36.     void resetGame();
  37.  
  38.     void playerTurn(int x, int y, bool circle);
  39.     void placeShape();
  40.    
  41.     void select();
  42.     void dselect();
  43.  
  44. };
  45.  
  46.  
  47.  
  48.  
  49. #endif
  50.  
  51.  
  52.  
  53.  
  54. //////////////////////////////////////////////////////////////////////////////////////////////////////////////
  55.  
  56.  
  57.  
  58. #include "Rect.h"
  59.  
  60. #if defined WIN32
  61. #include <freeglut.h>
  62. #elif defined __APPLE__
  63. #include <GLUT/glut.h>
  64. #else
  65. #include <GL/freeglut.h>
  66. #endif
  67.  
  68. //boolean values are false by default
  69.  
  70. Rect::Rect(){
  71.  
  72.     for(int i = 0; i < 3; i++){
  73.         for(int j = 0; j < 3; j++){
  74.             matrix[i][j]=0;
  75.         }
  76.     }
  77. }
  78.  
  79. //X goes first
  80.  
  81. void Rect::resetGame(){
  82.     for(int i = 0; i < 3; i++){
  83.         for(int j = 0; j < 3; j++){
  84.             matrix[i][j]=0;
  85.         }
  86.     }
  87.  
  88.     playerCircle = false;
  89. }
  90.  
  91. void Rect::playerTurn(int x, int y, bool circle){
  92.     if(circle){
  93.         matrix[x][y] = 1; //spot has O
  94.         circle = false;
  95.     }
  96.  
  97.     else    {
  98.         matrix[x][y] = 2; //spot has X
  99.         circle = true;
  100.     }
  101.    
  102. }
  103.  
  104. bool Rect::contains(int x, int y) {
  105.     //check if a space is occupied by X or O
  106.     //O = 1
  107.     //X = 2
  108.     if (matrix[x][y] == 1 || matrix[x][y] == 2){
  109.         return true;
  110.     }
  111.     else{
  112.         return false;
  113.     }
  114. }
  115.  
  116. int Rect::result(){
  117.     //check 9 end cases here
  118.     //8 win cases
  119.     //3 vertical
  120.  
  121.     if(matrix[0][0] != 0 && matrix[0][0] == matrix[0][1] && matrix[0][1] == matrix[0][2]){
  122.         if (matrix[0][0] = 1){
  123.             return 1; //O win
  124.         }
  125.         else{
  126.             return 2; //X win
  127.         }
  128.     }
  129.  
  130.     if(matrix[1][0] != 0 && matrix[1][0] == matrix[1][1] && matrix[1][1] == matrix[1][2]){
  131.         if (matrix[1][0] = 1){
  132.             return 1; //O win
  133.         }
  134.         else{
  135.             return 2; //X win
  136.         }
  137.     }
  138.  
  139.     if(matrix[2][0] != 0 && matrix[2][0] == matrix[2][1] && matrix[2][1] == matrix[2][2]){
  140.         if (matrix[2][0] = 1){
  141.             return 1; //O win
  142.         }
  143.         else{
  144.             return 2; //X win
  145.         }
  146.     }
  147.  
  148.     //3 horizontal
  149.     if(matrix[0][0] != 0 && matrix[0][0] == matrix[1][0] && matrix[1][0] == matrix[2][0]){
  150.         if (matrix[0][0] = 1){
  151.             return 1; //O win
  152.         }
  153.         else{
  154.             return 2; //X win
  155.         }
  156.     }
  157.  
  158.     if(matrix[0][1] != 0 && matrix[0][1] == matrix[1][1] && matrix[1][1] == matrix[2][1]){
  159.         if (matrix[0][1] = 1){
  160.             return 1; //O win
  161.         }
  162.         else{
  163.             return 2; //X win
  164.         }
  165.     }
  166.  
  167.     if(matrix[0][2] != 0 && matrix[0][2] == matrix[1][2] && matrix[1][2] == matrix[2][2]){
  168.         if (matrix[0][2] = 1){
  169.             return 1; //O win
  170.         }
  171.         else{
  172.             return 2; //X win
  173.         }
  174.     }
  175.  
  176.     //2 diagonal
  177.  
  178.     if(matrix[0][0] != 0 && matrix[0][0] == matrix[1][1] && matrix[1][1] == matrix[2][2]){
  179.         if (matrix[0][0] = 1){
  180.             return 1; //O win
  181.         }
  182.         else{
  183.             return 2; //X win
  184.         }
  185.     }
  186.  
  187.     if(matrix[2][0] != 0 && matrix[2][0] == matrix[1][1] && matrix[1][1] == matrix[0][2]){
  188.         if (matrix[2][0] = 1){
  189.             return 1; //O win
  190.         }
  191.         else{
  192.             return 2; //X win
  193.         }
  194.     }
  195.  
  196.  
  197.     //1 way to draw
  198.     //check if board is filled for draw
  199.     bool full = true;
  200.     for(int i = 0; i < 3; i++){
  201.         for(int j = 0; j < 3; j++){
  202.             if(matrix[i][j]==0){
  203.                 full = false;
  204.             }
  205.         }
  206.     }
  207.     if(full = true){
  208.         //report tie
  209.         return 3;
  210.     }
  211.  
  212.     //else, continue game
  213.     return 0;
  214. }
  215.  
RAW Paste Data