API tools faq
paste
Guest User

Untitled

a guest
Oct 22nd, 2017
76
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.54 KB | None | 0 0
raw download clone embed print report
  1. #ifndef GAME_FIELD_CLASS
  2. #ifdef SPRITE_CLASS
  3. #define GAME_FIELD_CLASS
  4.  
  5. #ifndef BOX_TYPE_ENUM
  6. #include "enum_BoxType.h"
  7. #endif
  8.  
  9. #ifndef BOX_DIRECTION_STRUCT
  10. #include "st_BoxDirection.h"
  11. #endif
  12.  
  13. #ifndef BOX_STRUCT
  14. #include "st_Box.h"
  15. #endif
  16.  
  17. class GameField {
  18.     private:
  19.         SDL_Surface * screen;
  20.         st_Box box[FIELD_BOX_MAX];
  21.         Sprite * sprite[BOX_SPRITES];
  22.  
  23.         int rankBoxes[9];
  24.  
  25.         bool collisionUp(int x, int y);
  26.         bool collisionDown(int x, int y);
  27.         bool collisionLeft(int x, int y);
  28.         bool collisionRight(int x, int y);
  29.         bool collisionUpleft(int x, int y);
  30.         bool collisionUpright(int x, int y);
  31.         bool collisionDownleft(int x, int y);
  32.         bool collisionDownright(int x, int y);
  33.  
  34.         bool ai_turn;
  35.  
  36.         bool ai_win;
  37.         bool user_win;
  38.         bool game_tied;
  39.         bool game_end;
  40.     public:
  41.         GameField(SDL_Surface * screen);
  42.  
  43.         void handleEvents(SDL_Event & event);
  44.         bool userWin(void);
  45.         bool AIWin(void);
  46.         bool gameTied(void);
  47.         bool gameIsOver(void);
  48.         void showWinScreen(void);
  49.  
  50.         void AICheckMove(void);
  51.         void AIRankBoxes(void);
  52.         void AIMove(void);
  53.  
  54.         void checkWinner(void);
  55.  
  56.         void draw(void);
  57.  
  58.         ~GameField(void);
  59. };
  60.  
  61.     GameField::GameField(SDL_Surface * screen) {
  62.         st_SpriteGroup boxes = {"Assets/Spritesheets/boxes.png"};
  63.  
  64.         int x_pos = 0,
  65.             y_pos = 0;
  66.  
  67.         // 0, 0 = empty
  68.         // 210, 0 = circle
  69.         // 420, 0 = cross
  70.         for (int s = 0; s < BOX_SPRITES; s++) {
  71.             GameField::sprite[s] = new Sprite(x_pos, y_pos, BOX_SPRITE_WIDTH, BOX_SPRITE_HEIGHT, boxes);
  72.             x_pos += BOX_SPRITE_WIDTH;
  73.         }
  74.  
  75.         int cols = 0,
  76.             rows = 0;
  77.  
  78.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  79.             x_pos = (BOX_SPRITE_WIDTH * cols);
  80.             y_pos = (BOX_SPRITE_HEIGHT * rows);
  81.  
  82.             GameField::box[b].x = x_pos;
  83.             GameField::box[b].y = y_pos;
  84.             GameField::box[b].points = 8;
  85.             GameField::box[b].type = EMPTY;
  86.  
  87.             GameField::box[b].d.up = true;
  88.             GameField::box[b].d.down = true;
  89.             GameField::box[b].d.left = true;
  90.             GameField::box[b].d.right = true;
  91.             GameField::box[b].d.upleft = true;
  92.             GameField::box[b].d.upright = true;
  93.             GameField::box[b].d.downleft = true;
  94.             GameField::box[b].d.downright = true;
  95.  
  96.             if (cols == (FIELD_MAX_COLS - 1)) {
  97.                 if (rows == (FIELD_MAX_ROWS - 1))
  98.                     rows = 0;
  99.                 else
  100.                     rows++;
  101.  
  102.                 cols = 0;
  103.             } else {
  104.                 cols++;
  105.             }
  106.         }
  107.  
  108.         GameField::screen = screen;
  109.  
  110.         srand( SDL_GetTicks() );
  111.         int r = (rand() % 500);
  112.  
  113.         if (r < 100) {
  114.             GameField::ai_turn = false;
  115.         } else if ((r >= 100 && r < 200) || (r >= 300 && r < 400)) {
  116.             GameField::ai_turn = true;
  117.         } else if ((r >= 200 && r < 300) || (r >= 400 && r < 500)) {
  118.             GameField::ai_turn = false;
  119.         }
  120.  
  121.         GameField::ai_win = false;
  122.         GameField::user_win = false;
  123.         GameField::game_tied = false;
  124.         GameField::game_end = false;
  125.     }
  126.  
  127.     GameField::~GameField(void) {
  128.         delete [] GameField::sprite;
  129.     }
  130.  
  131.     void GameField::handleEvents(SDL_Event & event) {
  132.         int x = 0,
  133.             y = 0;
  134.  
  135.         int x_pos = 0,
  136.             y_pos = 0;
  137.  
  138.         int cols = 0,
  139.             rows = 0;
  140.  
  141.         if (event.type == SDL_MOUSEBUTTONDOWN) {
  142.             if (event.button.button == SDL_BUTTON_LEFT) {
  143.                 x = event.button.x;
  144.                 y = event.button.y;
  145.  
  146.                 for (int b = 0; b < FIELD_BOX_MAX; b++) {
  147.                     x_pos = ((BOX_SPRITE_WIDTH * cols) + BOX_SPRITE_WIDTH);
  148.                     y_pos = ((BOX_SPRITE_HEIGHT * rows) + BOX_SPRITE_HEIGHT);
  149.  
  150.                     if (x >= GameField::box[b].x && x <= x_pos) {
  151.                         if (y >= GameField::box[b].y && y <= y_pos) {
  152.                             if (GameField::box[b].type == EMPTY) {
  153.                                 GameField::box[b].type = CIRCLE;
  154.  
  155.                                 GameField::ai_turn = true;
  156.                             }
  157.  
  158.                             break;
  159.                         }
  160.                     }
  161.  
  162.                     if (cols == (FIELD_MAX_COLS - 1)) {
  163.                         if (rows == (FIELD_MAX_ROWS - 1))
  164.                             rows = 0;
  165.                         else
  166.                             rows++;
  167.  
  168.                         cols = 0;
  169.                     } else {
  170.                         cols++;
  171.                     }
  172.                 }
  173.             }
  174.         }
  175.     }
  176.  
  177.     bool GameField::userWin(void) {
  178.         return GameField::user_win;
  179.     }
  180.  
  181.     bool GameField::AIWin(void) {
  182.         return GameField::ai_win;
  183.     }
  184.  
  185.     bool GameField::gameTied(void) {
  186.         return GameField::game_tied;
  187.     }
  188.  
  189.     bool GameField::gameIsOver(void) {
  190.         return GameField::game_end;
  191.     }
  192.  
  193.     void GameField::showWinScreen(void) {
  194.         SDL_Surface * user = SDL_DisplayFormat( IMG_Load("Assets/user_win.png") );
  195.         SDL_Surface * ai = SDL_DisplayFormat( IMG_Load("Assets/ai_win.png") );
  196.         SDL_Surface * tied = SDL_DisplayFormat( IMG_Load("Assets/game_tied.png") );
  197.  
  198.         SDL_Rect text_spawn;
  199.         text_spawn.x = 200;
  200.         text_spawn.y = 190;
  201.  
  202.         if (GameField::user_win == true)
  203.             SDL_BlitSurface(user, NULL, GameField::screen, & text_spawn);
  204.         else if (GameField::ai_win == true)
  205.             SDL_BlitSurface(ai, NULL, GameField::screen, & text_spawn);
  206.         else if (GameField::game_tied == true)
  207.             SDL_BlitSurface(tied, NULL, GameField::screen, & text_spawn);
  208.  
  209.         SDL_FreeSurface(user);
  210.         SDL_FreeSurface(ai);
  211.         SDL_FreeSurface(tied);
  212.     }
  213.  
  214.     bool GameField::collisionUp(int x, int y) {
  215.         bool collision = false;
  216.  
  217.         if (y == 0)
  218.             return true;
  219.  
  220.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  221.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  222.                 st_Box ne = GameField::box[b];
  223.  
  224.                 if (x == ne.x && (y - BOX_SPRITE_HEIGHT) == ne.y) {
  225.                     collision = true;
  226.                     break;
  227.                 }
  228.             }
  229.         }
  230.  
  231.         return collision;
  232.     }
  233.  
  234.     bool GameField::collisionDown(int x, int y) {
  235.         bool collision = false;
  236.  
  237.         if ((y + BOX_SPRITE_HEIGHT) == SCREEN_HEIGHT)
  238.             return true;
  239.  
  240.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  241.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  242.                 st_Box ne = GameField::box[b];
  243.  
  244.                 if (x == ne.x && (y + BOX_SPRITE_HEIGHT) == ne.y) {
  245.                     collision = true;
  246.                     break;
  247.                 }
  248.             }
  249.         }
  250.  
  251.         return collision;
  252.     }
  253.  
  254.     bool GameField::collisionLeft(int x, int y) {
  255.         bool collision = false;
  256.  
  257.         if (x == 0)
  258.             return true;
  259.  
  260.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  261.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  262.                 st_Box ne = GameField::box[b];
  263.  
  264.                 if ((x - BOX_SPRITE_WIDTH) == ne.x && y == ne.y) {
  265.                     collision = true;
  266.                     break;
  267.                 }
  268.             }
  269.         }
  270.  
  271.         return collision;
  272.     }
  273.  
  274.     bool GameField::collisionRight(int x, int y) {
  275.         bool collision = false;
  276.  
  277.         if ((x + BOX_SPRITE_WIDTH) == SCREEN_WIDTH)
  278.             return true;
  279.  
  280.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  281.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  282.                 st_Box ne = GameField::box[b];
  283.  
  284.                 if ((x + BOX_SPRITE_WIDTH) == ne.x && y == ne.y) {
  285.                     collision = true;
  286.                     break;
  287.                 }
  288.             }
  289.         }
  290.  
  291.         return collision;
  292.     }
  293.  
  294.     bool GameField::collisionUpleft(int x, int y) {
  295.         bool collision = false;
  296.  
  297.         if (x == 0 || y == 0)
  298.             return true;
  299.  
  300.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  301.  
  302.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  303.                 st_Box ne = GameField::box[b];
  304.  
  305.                 if ((x - BOX_SPRITE_WIDTH) == ne.x && (y - BOX_SPRITE_HEIGHT) == ne.y) {
  306.                     collision = true;
  307.                     break;
  308.                 }
  309.             }
  310.         }
  311.  
  312.         return collision;
  313.     }
  314.  
  315.     bool GameField::collisionUpright(int x, int y) {
  316.         bool collision = false;
  317.  
  318.         if ((x + BOX_SPRITE_WIDTH) == SCREEN_WIDTH || y == 0)
  319.             return true;
  320.  
  321.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  322.  
  323.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  324.                 st_Box ne = GameField::box[b];
  325.  
  326.                 if ((x + BOX_SPRITE_WIDTH) == ne.x && (y - BOX_SPRITE_HEIGHT) == ne.y) {
  327.                     collision = true;
  328.                     break;
  329.                 }
  330.             }
  331.         }
  332.  
  333.         return collision;
  334.     }
  335.  
  336.     bool GameField::collisionDownleft(int x, int y) {
  337.         bool collision = false;
  338.  
  339.         if (x == 0 || (y + BOX_SPRITE_HEIGHT) == SCREEN_HEIGHT)
  340.             return true;
  341.  
  342.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  343.  
  344.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  345.                 st_Box ne = GameField::box[b];
  346.  
  347.                 if ((x - BOX_SPRITE_WIDTH) == ne.x && (y + BOX_SPRITE_HEIGHT) == ne.y) {
  348.                     collision = true;
  349.                     break;
  350.                 }
  351.             }
  352.         }
  353.  
  354.         return collision;
  355.     }
  356.  
  357.     bool GameField::collisionDownright(int x, int y) {
  358.         bool collision = false;
  359.  
  360.         if ((x + BOX_SPRITE_WIDTH) == SCREEN_WIDTH || (y + BOX_SPRITE_HEIGHT) == SCREEN_HEIGHT)
  361.             return true;
  362.  
  363.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  364.  
  365.             if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  366.                 st_Box ne = GameField::box[b];
  367.  
  368.                 if ((x + BOX_SPRITE_WIDTH) == ne.x && (y + BOX_SPRITE_HEIGHT) == ne.y) {
  369.                     collision = true;
  370.                     break;
  371.                 }
  372.             }
  373.         }
  374.  
  375.         return collision;
  376.     }
  377.  
  378.     void GameField::AICheckMove(void) {
  379.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  380.             if (GameField::box[b].type == EMPTY) {
  381.                 // Up
  382.                 if (GameField::collisionUp(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.up == true) {
  383.                     GameField::box[b].points--;
  384.  
  385.                     GameField::box[b].d.up = false;
  386.                 }
  387.  
  388.                 // Down
  389.                 if (GameField::collisionDown(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.down == true) {
  390.                     GameField::box[b].points--;
  391.  
  392.                     GameField::box[b].d.down = false;
  393.                 }
  394.  
  395.                 // Left
  396.                 if (GameField::collisionLeft(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.left == true) {
  397.                     GameField::box[b].points--;
  398.  
  399.                     GameField::box[b].d.left = false;
  400.                 }
  401.  
  402.                 // Right
  403.                 if (GameField::collisionRight(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.right == true) {
  404.                     GameField::box[b].points--;
  405.  
  406.                     GameField::box[b].d.right = false;
  407.                 }
  408.  
  409.                 // Up left
  410.                 if (GameField::collisionUpleft(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.upleft == true) {
  411.                     GameField::box[b].points--;
  412.  
  413.                     GameField::box[b].d.upleft = false;
  414.                 }
  415.  
  416.                 // Up right
  417.                 if (GameField::collisionUpright(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.upright == true) {
  418.                     GameField::box[b].points--;
  419.  
  420.                     GameField::box[b].d.upright = false;
  421.                 }
  422.  
  423.                 // Down left
  424.                 if (GameField::collisionDownleft(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.downleft == true) {
  425.                     GameField::box[b].points--;
  426.  
  427.                     GameField::box[b].d.downleft = false;
  428.                 }
  429.  
  430.                 // Down right
  431.                 if (GameField::collisionDownright(GameField::box[b].x, GameField::box[b].y) && GameField::box[b].d.downright == true) {
  432.                     GameField::box[b].points--;
  433.  
  434.                     GameField::box[b].d.downright = false;
  435.                 }
  436.             }
  437.         }
  438.     }
  439.  
  440.     void GameField::AIRankBoxes(void) {
  441. //        std::ofstream rankboxes("rankboxes.txt");
  442.  
  443.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  444.             if (GameField::box[b].type == EMPTY) {
  445.                 GameField::rankBoxes[b] = GameField::box[b].points;
  446.             } else if (GameField::box[b].type == CIRCLE || GameField::box[b].type == CROSS) {
  447.                 GameField::rankBoxes[b] = 0;
  448.             }
  449.         }
  450.  
  451.         // LOG
  452. //        int max_points = 0,
  453. //            box_n = 0;
  454. //
  455. //        for (int b = 0; b < FIELD_BOX_MAX; b++) {
  456. //            if (GameField::box[b].type == EMPTY) {
  457. //                if (GameField::box[b].points > max_points) {
  458. //                    max_points = GameField::box[b].points;
  459. //                    box_n = b;
  460. //                }
  461. //            }
  462. //        }
  463. //
  464. //        rankboxes << max_points << " " << box_n;
  465.         // END LOG
  466.  
  467. //        rankboxes.close();
  468.     }
  469.  
  470.     void GameField::AIMove(void) {
  471.         if (GameField::ai_turn == true) {
  472.             int max_points = 0,
  473.             best_box = 0;
  474.  
  475.             for (int b = 0; b < FIELD_BOX_MAX; b++) {
  476.                 if (GameField::box[b].type == EMPTY) {
  477.                     if (GameField::box[b].points >= max_points) {
  478.                         max_points = GameField::box[b].points;
  479.                         best_box = b;
  480.                     }
  481.                 }
  482.             }
  483.  
  484.             if (GameField::box[best_box].type == EMPTY) {
  485.                 GameField::box[best_box].type = CROSS;
  486.                 GameField::ai_turn = false;
  487.             }
  488.         }
  489.     }
  490.  
  491.     void GameField::checkWinner(void) {
  492. //        int winBoxes[8][3] = {
  493. //            {0, 3, 6},
  494. //            {1, 4, 7},
  495. //            {2, 5, 8},
  496. //            {0, 1, 2},
  497. //            {3, 4, 5},
  498. //            {6, 7, 8},
  499. //            {0, 4, 8},
  500. //            {2, 4, 6}
  501. //        };
  502.  
  503.         st_Box winBoxes[8][3] = {
  504.             {GameField::box[0], GameField::box[3], GameField::box[6]},
  505.             {GameField::box[1], GameField::box[4], GameField::box[7]},
  506.             {GameField::box[2], GameField::box[5], GameField::box[8]},
  507.             {GameField::box[0], GameField::box[1], GameField::box[2]},
  508.             {GameField::box[3], GameField::box[4], GameField::box[5]},
  509.             {GameField::box[6], GameField::box[7], GameField::box[8]},
  510.             {GameField::box[0], GameField::box[4], GameField::box[8]},
  511.             {GameField::box[2], GameField::box[4], GameField::box[6]}
  512.         };
  513.  
  514.         for (int w = 0; w < 8; w++) {
  515.             if (winBoxes[w][0].type == CIRCLE && winBoxes[w][1].type == CIRCLE && winBoxes[w][2].type == CIRCLE) {
  516.                 GameField::user_win = true;
  517.                 break;
  518.             } else if (winBoxes[w][0].type == CROSS && winBoxes[w][1].type == CROSS && winBoxes[w][2].type == CROSS) {
  519.                 GameField::ai_win = true;
  520.                 break;
  521.             }
  522.         }
  523.  
  524.         int circle = 0,
  525.             cross = 0,
  526.             empty = 0;
  527.  
  528.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  529.             if (GameField::box[b].type == CIRCLE)
  530.                 circle++;
  531.             else if (GameField::box[b].type == CROSS)
  532.                 cross++;
  533.             else if (GameField::box[b].type == EMPTY)
  534.                 empty++;
  535.         }
  536.  
  537.         if ((circle > cross || cross > circle) && empty == 0)
  538.             if (! GameField::user_win && ! GameField::ai_win)
  539.                 GameField::game_tied = true;
  540.  
  541.         if (GameField::user_win || GameField::ai_win || GameField::game_tied)
  542.             GameField::game_end = true;
  543.     }
  544.  
  545.     void GameField::draw(void) {
  546.         int x_pos = 0,
  547.             y_pos = 0;
  548.  
  549.         int cols = 0,
  550.             rows = 0;
  551.  
  552.         for (int b = 0; b < FIELD_BOX_MAX; b++) {
  553.             x_pos = (BOX_SPRITE_WIDTH * cols);
  554.             y_pos = (BOX_SPRITE_HEIGHT * rows);
  555.  
  556.             if (GameField::box[b].type == EMPTY) {
  557.                 GameField::sprite[0]->draw(x_pos, y_pos, GameField::screen);
  558.             } else if (GameField::box[b].type == CIRCLE) {
  559.                 GameField::sprite[1]->draw(x_pos, y_pos, GameField::screen);
  560.             } else if (GameField::box[b].type == CROSS) {
  561.                 GameField::sprite[2]->draw(x_pos, y_pos, GameField::screen);
  562.             }
  563.  
  564.             if (cols == (FIELD_MAX_COLS - 1)) {
  565.                 if (rows == (FIELD_MAX_ROWS - 1))
  566.                     rows = 0;
  567.                 else
  568.                     rows++;
  569.  
  570.                 cols = 0;
  571.             } else {
  572.                 cols++;
  573.             }
  574.         }
  575.     }
  576.  
  577. #endif
  578. #endif
Add Comment
Please, Sign In to add comment
Public Pastes
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!