Съдържание

  1. Декларация на класа.
  2. Използване на класа.
  3. Модел на играта.
  4. Описание на някои от методите.

 

Декларация на класа.

Основно ще работим с един клас Numbers. В него ще бъде логиката на играта и няма да наследява никакъв клас.
Да си създадем файловете gsrc/Numbers.cpp и gsrc/Numbers.h – да припомним, че gsrc е директорията съдържаща класовете на играта.

  1. #ifndef NUMBERS_H
  2. #define NUMBERS_H
  3. #include <algorithm>
  4. #include „../include/AnimatedSprite.h“
  5. class Numbers
  6. {
  7. public:
  8.        Numbers();
  9.        ~Numbers();
  10.        // определяме повърхността върху която ще показваме плочките
  11.       void setSurface(SDL_Surface* screen);
  12.       // показваме плочките
  13.       void render();
  14.       // започваме играта отначало
  15.       void restartGame();
  16.       // започваме нова игра
  17.       void newGame();
  18. private:
  19.       // посоки на движение на плочка
  20.       enum DIRECTIONS {
  21.              LEFT = 1, RIGHT, TOP, BOTTOM
  22.       } mDirections;
  23.       // x позиция на първата плочка
  24.       int tilePosX;
  25.       // y позиция на първата плочка
  26.       int tilePosY;
  27.       // широчина на плочката
  28.       int tileWidth;
  29.       // височина на плочката
  30.       int tileHeight;
  31.       // съхранява текущата позиция – само числата
  32.       int* currentPositionOfNumbers;
  33.       // Първоначална подредба
  34.       int initialPosition[16];
  35.       // Позицията към която се стремим
  36.       int targetPosition[16];
  37.       // повърхността върху която ще рисуваме
  38.       SDL_Surface* screen;
  39.       // използва се нулевата плочка
  40.       AnimatedSprite* emptyTile;
  41.       // обект, който използваме за попълване на vectorOfTiles
  42.       AnimatedSprite* tile;
  43.       // вектор съдържащ плочките
  44.       vector<AnimatedSprite*> vectorOfTiles;
  45.       // връща начална позиция
  46.       int* getNumberOrder();
  47.       // преценява може ли да се премести дадена плочка и накъде
  48.       int moveDecision(int);
  49.       // инициализиране
  50.       void clear();
  51.       // попълва vectorOfTiles с данните от getNumberOrder
  52.       void initVectorOfTiles(bool);
  53.       // връща true, ако играта е достигнала крайна позиция
  54.       bool isFinish(int*);
  55. };
  56. #endif // NUMBERS_H

В Numbers.cpp да напишем методите с празни тела, за да ги сложим първоначално на правилните места в играта.

  1. #include „Numbers.h“
  2. Numbers::Numbers(){}
  3. // тук ще извеждаме плочките използвайки тяхният метод render
  4. void Numbers::render() {}
  5. Numbers::~Numbers(){}
  6. void Numbers::setSurface(SDL_Surface* screen) {}
  7. // вземане на решение, на къде може да се премести плочката
  8. int Numbers::moveDecision(int pos) {}
  9. // връща валидна начална позиция на пъзела
  10. int* Numbers::getValidNumbersPosition() {}
  11. // започваме нова игра
  12. void Numbers::newGame() {}
  13. // започваме играта отначало
  14. void Numbers::restartGame(){}
  15. // изчистване на данните
  16. void Numbers::clear() {}
  17. // инициализиране на вектора съдържащ плочките
  18. void Numbers::initVectorOfTiles(bool restart) {}
  19. // достигнали ли сме целта
  20. bool Numbers::isFinish(int* target) {}

 

Използване на класа.

Да декларираме обект от тип Numbers в Game13.h – файлът, отговарящ за обработката на графиката, регистрирането на UI компонентите (бутони, background и т.н.) и т.н.

  1.     Numbers* mNumbers;

В метода init на Game15 в края добавяме:

  1.     mNumbers = new Numbers();
  2.     mNumbers->setSurface(screen);

В render след:

  1.     btnRestartGame->render(screen);

добавяме:

  1. if (mNumbers) {
  2.     mNumbers->render();
  3. }

Добавяме и обработка на бутоните за нова игра и рестартиране на игра.

  1. if (btnToMainMenu->isMouseButtonDown()) {
  2. …………………………………………….
  3. } else if (btnNewGame->isMouseButtonDown()) {
  4.      mNumbers->newGame();
  5. } else if (btnRestartGame->isMouseButtonDown()) {
  6.      mNumbers->restartGame();
  7. }

В деструктора Game15::~Game15() добавяме:

  1. delete mNumbers;
  2. mNumbers = 0;

Сега можем да компилираме и стартираме. Поведението на играта няма да се промени, но ще можем да пристъпим към кодирането на Numbers.cpp.

Модел на играта.



Предстоящо събитие на потребителска група .NET

Secure your ASP.NET API using OAuth 2.0

Дата: 28 Февруари


 


Като погледнем на играта една от идеите, които ни идва за описанието й, е представянето й като масив. Но в случая аз ще използвам линейна структура – вектор, който ще пази обектите – плочките с числа. Причината е, че много по-лесно е да се получи вектор със случайни стойности, отколкото матрица и въобще някои алгоритми за линейни структури от данни са вече готови и няма нужда да ги приспособяваме за масиви. Оттук и всички останали помощни масиви ще са едномерни.

В конструктора инициализираме началната позиция на плочката – по нея ще се подредят и останалите. Също така инициализираме масива с началната позиция (initialPosition) и масива с позицията към която ще се стремим targetPosition.

Описание на някои от методите.

  1. Numbers::Numbers(){
  2.           tilePosX = 30;
  3.           tilePosY = 30;
  4.           tileWidth = 80;
  5.           tileHeight = 80;
  6.           for (int i = 0; i < 16; i++) {
  7.           initialPosition[i] = 0;
  8.          targetPosition[i] = i+1;
  9.          }
  10.          targetPosition[15] = 0;
  11.          initVectorOfTiles(false);
  12. }

От горния код се вижда, че позицията, към която ще се стремим, е най-разпространената:

Уроци по програмиране

Накрая в конструктора извикваме метода initVectorOfTiles(false), с който вземаме валидна начална позиция на пъзела и попълваме currentPositionOfNumbers, vectorOfTiles и SpriteManager. Параметърът, който се подава, е false, защото нямаме рестарт на играта. Да припомня, че обектът за този клас ще се създава и унищожава в Game15.cpp.
Тук инициализираме и emptyTile обекта, който няма число, освен за представяне на празната плочка, emptyTile се използва и да зареди спрайта за числата:

Уроци по програмиране

и останалите обекти да не зареждат всеки свой екземпляр, а да го вземат от emptyTile.

  1. void Numbers::initVectorOfTiles(bool restart) {
  2.       emptyTile = new AnimatedSprite();
  3.       emptyTile->setImage(Constants::RESOURCE_DIR + Constants::pathSeparator + „numbers.png“);
  4.      emptyTile->setName(„EMPTY“);
  5.      int x = 0;
  6.      int y = 0;
  7.      if (restart) {
  8.         for (int i = 0; i < 16;i++) {
  9.              currentPositionOfNumbers[i] = initialPosition[i];
  10.         }
  11.      } else {
  12.           currentPositionOfNumbers = getValidNumbersPosition();
  13.           for (int i = 0; i < 16;i++) {
  14.                initialPosition[i] = currentPositionOfNumbers[i];
  15.           }
  16.      }
  17.      for (int m = 0; m < 16; m++) {
  18.            if (currentPositionOfNumbers[m] != 0) {
  19.               tile = new AnimatedSprite();
  20.               tile->setTilesXY(15, 1);
  21.               tile->setImage(emptyTile->getImage());
  22.               tile->setGroup(„numbers“);
  23.               tile->setName(„number_“+ConvertFunctions::intToString(currentPositionOfNumbers[m]-1));
  24.               tile->setFrameBeginEnd(currentPositionOfNumbers[m]-1, currentPositionOfNumbers[m]-1);
  25.               tile->calculate(10);
  26.               tile->setX(tilePosX + tileWidth * x);
  27.               tile->setY(tilePosY + tileHeight * y);
  28.               SpriteManager::addSprite(tile);
  29.               vectorOfTiles.push_back(tile);
  30.      } else {
  31.           vectorOfTiles.push_back(emptyTile);
  32.      }
  33.      x++;
  34.      if (x % 4 == 0) {
  35.          x = 0;
  36.          y++;
  37.      }
  38.   }
  39. }

Ако сега компилираме и стартираме външното поведение на играта няма да се промени, защото още нищо не сме правили по метода render.
В setSurface определяме this->screen:

  1. void Numbers::setSurface(SDL_Surface* screen) {
  2.       this->screen = screen;
  3. }

В render ще показваме плочките, които са в vectorOfTiles и ще обработваме mouse click. Ето фрагмент от кода:

  1.     // ако сме попълни вектора
  2.    if (vectorOfTiles.size() > 0) {
  3.        // да покажем всички плочки
  4.        for (int m = 0; m < 16; m++) {
  5.             // ако сме кликнали върху плочката vectorOfTiles[m]
  6.             if (vectorOfTiles[m]->isMouseButtonDown()) {
  7.                 // ако плочката може да се премести
  8.                 switch (moveDecision(m)) {
  9.                 // на ляво
  10.                 case LEFT:
  11.                       vectorOfTiles[m]->setX(vectorOfTiles[m]->getX() tileWidth);
  12.                       vectorOfTiles[m]->setMouseButtonDown(false);
  13.                       swap(vectorOfTiles[m], vectorOfTiles[m1]);
  14.                       break;
  15.                 case TOP:
  16. ……………………………………………………..
  17.                 default: // ако не може стои на място
  18.                        break;
  19.                 }
  20.                 // ако след преместването сме достигнали желаната позиция
  21.                 // извеждаме съобщение
  22.                 if (isFinish(targetPosition)) {
  23.                 cout << „Game over!“ << endl;
  24.                 }
  25.             }
  26.             // показваме плочките
  27.             vectorOfTiles[m]->render(this->screen);
  28.        }

Кодъг може да свалите оттук: Github Repo

Приятно кодиране 🙂

Автор: Янко Попов