Essays.club - Получите бесплатные рефераты, курсовые работы и научные статьи
Поиск

Игры "ghost's city"

Автор:   •  Февраль 10, 2018  •  Курсовая работа  •  52,057 Слов (209 Страниц)  •  586 Просмотры

Страница 1 из 209
  1. МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
  1. федеральное государственное автономное образовательное учреждение
    высшего профессионального образования
  1. «Санкт-Петербургский государственный университет
    аэрокосмического приборостроения»
  1. КАФЕДРА ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМ И СЕТЕЙ
  2. КУРСОВАЯ РАБОТА
  3. ЗАЩИЩЕНА С ОЦЕНКОЙ
  4. РУКОВОДИТЕЛЬ
  1. доцент, канд. техн. наук
  1. Л.Н. Бариков
  1. должность, уч. степень, звание
  1. подпись, дата
  1. инициалы, фамилия
  1. ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
    К КУРСОВОЙ РАБОТЕ
  1. Игра «Ghost’s city»
  1. по дисциплине: Основы программирования
  1. РАБОТУ ВЫПОЛНИЛ
  1. СТУДЕНТ ГР.
  1. 4642
  1. Ю.Л.Ляпина
  1. подпись, дата
  1. инициалы, фамилия
  6. Санкт-Петербург
  7. 2017
  8. СОДЕРЖАНИЕ
  9. Введение……………………………………………………………………………………………3
  10. 1.Постановка задачи……………………………………………………………………………….4
  11. 2.Спецификация……………………………………………………………………………………5
  12.           2.1 Спецификация…………………………………………………………………………...6
  13. 3.Текст программы…………………………………………………………………………………7
  14.            Аннотация…………………………………………………………………………………...8
  15.            Содержание………………………………………………………………………………….9
  16.            3.1 Текст программы……………………………………………………………………….10
  17.            3.2 Результаты тестирования………………………………………………………………53
  18. 4.Описание программы……………………………………………………………………………54
  19.            Аннотация……………………………………………………………………………...…...55
  20.            Содержание……………………………………………………………………………...….56
  21.             4.1 Общие сведения…………………………………………………………………...…...57
  22.             4.2 Функциональное назначение……………………………………………………...…..57
  23.             4.3 Описание логической структуры………………………………………………....…...57
  24.             4.4 Спецификация подпрограмм……………………………………………………...…..57
  25.             4.5 Используемые технические средства…………………………………………….…...61
  26.             4.6 Вызов и загрузка……………………………………………………………………..…61
  27. 5. Описание применения……………………………………………………………………….….62
  28.             Аннотация……………………………………………………………………………….….63
  29.             Содержание…………………………………………………………………………………64
  30.             5.1 Назначение программы………………………………………………………………...65
  31.             5.2 Условия применения……………………………………………………………...……65
  32.             5.3 Описание задачи………………………………………………………………………...65
  33.             5.4 Основные характеристики занимаемой памяти……………………………………....65
  34. Заключение……………………………………………………………………………………….....66
  35. Список используемых источников………………………………………………………………..67
  1. Введение
  2. Данная курсовая работа способствует закреплению учебного материала, изученного по курсу «Основы программирования».
  3. Программа представляет собой приложение «Ghost’s city», используется в качестве игры для одного человека.
  4. Цель курсового проекта — выработать навыки общеизвестных алгоритмов для решения конкретных задач, закрепить знания по программированию на языке С++.
  5. Курсовая работа поможет приобрести навыки по оформлению документации на программные средства.
  1. 1.Постановка задачи
  2. Используя технологию объектно-ориентированного программирования и кроссплатформенную мультимедийную библиотеку SFML,  написать программу «Ghost’s city».
  3. Используя клавиатуру программу может использовать только 1 человек.
  4. Программу «Ghost’s city» создать на языке С++, в среде программирования MS Visual Studio 2013.
  1. МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
  1. федеральное государственное автономное образовательное учреждение
    высшего профессионального образования
  1. «Санкт-Петербургский государственный университет
    аэрокосмического приборостроения»
  2. КАФЕДРА ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМ И СЕТЕЙ
  1. ПРОГРАММА
  1. Игра «Ghost’s city»
  1. Спецификация
  1. 44.4642.17-01
  1. РАБОТУ ВЫПОЛНИЛ
  1. СТУДЕНТ ГР.
  1. 4642
  1. Ю.Л.Ляпина
  1. подпись, дата
  1. инициалы, фамилия
  8. Санкт-Петербург
  9. 2017
  11. 2.1 Спецификация
  1. Обозначение
  1. Наименование
  1. Применение
  1. 44.4642.17-01
  1. Документация
  2. Программа «Ghost’s city»
  3. Спецификация
  1. 44.4642.17-12
  1. Документация
  2. Программа «Ghost’s city»
  3. Текст программы
  1. 44.4642.17-13
  1. Документация
  2. Программа «Ghost’s city»
  3. Описание программы
  1. 44.4642.17-31
  1. Документация
  2. Программа «Ghost’s city»
  3. Описание применения
  1. МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
  1. федеральное государственное автономное образовательное учреждение
    высшего профессионального образования
  1. «Санкт-Петербургский государственный университет
    аэрокосмического приборостроения»
  2. КАФЕДРА ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМ И СЕТЕЙ
  1. ПРОГРАММА
  1. Игра «Ghost’s city»
  1. Текст программы
  1. 44.4642.17-12
  1. РАБОТУ ВЫПОЛНИЛ
  1. СТУДЕНТ ГР.
  1. 4642
  1. Ю.Л.Ляпина
  1. подпись, дата
  1. инициалы, фамилия
  8. Санкт-Петербург
  9. 2017
  11. Аннотация
  12. В документе приводится текст программы игры  «Ghost’s  city»,  написанной на языке С++,  так же результаты тестирования.
  1. Содержание
  2. 3.1 Текст программы
  3. 3.2 Результаты тестирования
  37. 3.1 Текст программы
  38. bullet.cpp
  39. #include "bullet.h"
  40. #include "wall.h"
  42. Bullet::Bullet()
  43. {
  44.         m_type = GameObjectType_Bullet;
  45.         m_ownerType = GameObjectType_None;
  47.         setTextureRect(kBulletImage);
  48. }
  50. void Bullet::render(sf::RenderWindow* rw)
  51. {
  52.         GameObject::render(rw);
  53. }
  55. void Bullet::intersect(GameObject* object)
  56. {
  57.         // удаляет себя
  58.         setHealth(0);
  60.         // наносит урон
  61.         object->doDamage(1);
  62. }
  1. bullet.h
  2. #pragma once
  3. #include "gameObject.h"
  4. #include "level.h"
  6. class Bullet
  7.         : public GameObject
  8. {
  9. public:
  10.         Bullet();
  12.         virtual void render(sf::RenderWindow* rw);
  13.         virtual void intersect(GameObject* object);
  14.         void setOwnerType(GameObjectType ownerType) { m_ownerType = ownerType; }
  15.         GameObjectType getOwnerType() { return m_ownerType; }
  17. private:
  18.         GameObjectType m_ownerType;
  19. };
  1. direction.h
  2. #pragma once
  3. enum Direction
  4. {
  5.         Direction_Left,
  6.         Direction_Up,
  7.         Direction_Right,
  8.         Direction_Down,
  10.         Direction_MAX
  11. };
  1. enemy.cpp
  2. #include "enemy.h"
  3. #include "ghostEnemy.h"
  4. #include "utils.h"
  7. /////////////////////////////////////
  8. // Class Enemy
  9. Enemy::Enemy()
  10. {
  11.         m_type = GameObjectType_Enemy;
  14.         m_spawnTime = kEnemyEmergenceTime; //spawn - место появления spawner - моб, враг
  15.         m_spawnTimer = GetRandomFloat(0.0, m_spawnTime);
  17.         m_physical = false;
  18. }
  21. void Enemy::update(float dt)
  22. {
  23.         GameObject::update(dt);
  24.         m_spawnTimer += dt;
  26.         if (m_spawnTimer > m_spawnTime)
  27.         {
  28.                 m_spawnTimer = 0.0f;
  29.                 int enemiesOnLevel = m_game->getObjectsCount(GameObjectType_GhostEnemy);
  30.                 int enemiesStorageLeft = kEnemiesLevel - enemiesOnLevel - m_game->getDiedEnemiesCount();
  31.                 if (enemiesStorageLeft > 0 && enemiesOnLevel < kEnemiesLevelInOneMoment)
  32.                         m_game->createObject(GameObjectType_GhostEnemy, getX(), getY());
  33.         }
  34. }
  1. enemy.h
  2. #pragma once
  3. #include "gameObject.h"
  4. #include "level.h"
  6. class Enemy
  7.         : public GameObject
  8. {
  9. public:
  10.         Enemy();
  11.         virtual void update(float dt);
  13. private:
  14.         float m_spawnTimer;
  15.         float m_spawnTime;
  16. };
  1. game.cpp
  2. #include "game.h"
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include "level.h"
  8. #include "wall.h"
  9. #include
  11. #include "bullet.h"
  12. #include "ghostPlayer.h"
  13. #include "ghostEnemy.h"
  14. #include "enemy.h"
  16. sf::Texture* g_atlas00 = 0;
  18. Game::Game()
  19. {
  20.         m_isGameActive = true;
  21.         m_clockLastFrame = 0;
  23.         for (int i = 0; i < kObjectsCountMax; i++)
  24.                 m_objects[i] = 0;
  26.         m_player = 0;
  27.         m_diedEnemiesCount = 0;
  28.         m_renderWindow = 0;
  29. }
  31. Game::~Game()
  32. {
  33.         if (g_atlas00)
  34.                 delete g_atlas00;
  36.         if (m_renderWindow)
  37.                 delete m_renderWindow;
  38. }
  40. void Game::setupSystem()
  41. {
  42.         srand(time(0));
  44.         m_renderWindow = new sf::RenderWindow(
  45.                 sf::VideoMode(kPixels * kScreenColumns, kPixels * kScreenRows, 32),
  46.                 "Ghost's City",
  47.                 sf::Style::Titlebar | sf::Style::Close);
  49.         g_atlas00 = new sf::Texture();
  50.         g_atlas00->loadFromFile("atlas00.png");
  51. }
  53. void Game::initialize()
  54. {
  55.         shutdown();
  57.         m_diedEnemiesCount = 0;
  59.         // загрузка уровня
  60.         for (int r = 0; r < kLevelRows; r++)
  61.         {
  62.                 for (int c = 0; c < kLevelColumns; c++)
  63.                 {
  64.                         unsigned char cellSymbol = kLevelData0[r][c];
  66.                         switch (cellSymbol)
  67.                         {
  68.                         case CellSymbol_BrickWall:
  69.                         {
  70.                                 Wall* wall = (Wall*)createObject(GameObjectType_Wall, c, r);
  71.                                 wall->setTextureRect(kBrickWallImage);
  72.                                 break;
  73.                         }
  75.                         case CellSymbol_SteelWall:
  76.                         {
  77.                                 Wall* wall = (Wall*)createObject(GameObjectType_Wall, c, r);
  78.                                 wall->setTextureRect(kSteelWallImage);
  79.                                 wall->setInvulnerable(true);
  80.                                 break;
  81.                         }
  83.                         
  84.                         case CellSymbol_Player:
  85.                         {
  86.                                 GhostPlayer* player = (GhostPlayer*)createObject(GameObjectType_GhostPlayer, c + 0.5, r + 0.5);
  87.                                 player->setSpriteColor(sf::Color(255, 255, 255));
  88.                                 player->setKeys('A', 'D', 'W', 'S', VK_SPACE);
  89.                                 m_player = player;
  91.                                 break;
  92.                         }
  94.                         case CellSymbol_Enemy:
  95.                         {
  96.                                 createObject(GameObjectType_Enemy, c, r);
  97.                                 break;
  98.                         }
  99.                         }
  100.                 }
  101.         }
  102. }
  104. bool Game::loop()
  105. {
  106.         if (!m_renderWindow->isOpen())
  107.                 return false;
  109.         // время обновления
  110.         clock_t clockNow = clock();
  111.         clock_t deltaClock = clockNow - m_clockLastFrame;
  112.         float deltaTime = float(deltaClock) / CLOCKS_PER_SEC;
  113.         m_clockLastFrame = clockNow;
  115.     sf::Event event;
  116.         while (m_renderWindow->pollEvent(event))
  117.         {
  118.                 if (event.type == sf::Event::Closed)
  119.                         m_renderWindow->close();
  120.         }
  122.     render();
  123.         update(deltaTime);
  125.         return m_isGameActive;
  126. }
  128. void Game::shutdown()
  129. {
  130.         for (int i = 0; i < kObjectsCountMax; i++)
  131.                 if (m_objects[i] != 0)
  132.                 {
  133.                         delete m_objects[i];
  134.                         m_objects[i] = 0;
  135.                 }
  136. }
  138. void Game::render()
  139. {
  140.         // начало кадра
  141.         m_renderWindow->clear(sf::Color(20, 20, 20));
  143.         // прорисовка всех обектов
  144.         int objectsCount = 0;
  145.         for (int i = 0; i < kObjectsCountMax; i++)
  146.                 if (m_objects[i] != 0)
  147.                 {
  148.                         m_objects[i]->render(m_renderWindow);
  149.                         objectsCount++;
  150.                 }
  151.                 m_renderWindow->display();
  152. }
  154. void Game::update(float dt)
  155. {
  156.         for (int i = 0; i < kObjectsCountMax; i++)
  157.                 if (m_objects[i] != 0)
  158.                 {
  159.                         m_objects[i]->update(dt);
  161.                         if (m_objects[i]->getHealth() <= 0 && m_objects[i]->getDestroyAfterDeath())
  162.                                 destroyObject(m_objects[i]);
  163.                 }
  165.         // удаление игрока
  166.         if (m_player && m_player->getHealth() <= 0)
  167.         {
  168.                 destroyObject(m_player);
  169.                 m_player = NULL;
  170.                 initialize();
  171.         }
  172.     // удаление всех врагов
  173.         if (m_diedEnemiesCount == kEnemiesLevel) {
  174.                 m_renderWindow->clear(sf::Color(176, 196, 222));
  175.         
  176.             m_renderWindow->display();
  177.                         
  178.         }
  179. }
  181. GameObject* Game::checkIntersects(float x, float y, float width, float height, GameObject* exceptObject)
  182. {
  183.         int r00 = int(y);
  184.         int c00 = int(x);
  185.         int r01 = r00 + height - 1;
  186.         int c01 = c00 + width - 1;
  188.         for (int i = 0; i < kObjectsCountMax; i++)
  189.                 if (m_objects[i] != 0 && m_objects[i]->getPhysical() && m_objects[i] != exceptObject)
  190.                 {
  191.                         int r10 = int(m_objects[i]->getY());
  192.                         int c10 = int(m_objects[i]->getX());
  193.                         int r11 = r10 + m_objects[i]->getHeight() - 1;
  194.                         int c11 = c10 + m_objects[i]->getWidth() - 1;
  196.                         if (r00 <= r11 && r01 >= r10 && c00 <= c11 && c01 >= c10)
  197.                                 return m_objects[i];
  198.                 }
  200.         return 0;
  201. }
  203. bool Game::moveObjectTo(GameObject* object, float x, float y)
  204. {
  205.         int r0 = int(y);
  206.         int c0 = int(x);
  207.         int r1 = r0 + object->getHeight() - 1;
  208.         int c1 = c0 + object->getWidth() - 1;
  210.         if (r0 < 0 || c0 < 0 || r1 >= kLevelRows || c1 >= kLevelColumns)
  211.                 return false;
  214.         bool canMoveToCell = false;
  216.         GameObject* otherObject = checkIntersects(x, y, object->getWidth(), object->getHeight(), object);
  218.         if (otherObject)
  219.                 object->intersect(otherObject);
  220.         else
  221.                 canMoveToCell = true;
  224.         if (canMoveToCell)
  225.         {
  226.                 object->setX(x);
  227.                 object->setY(y);
  228.         }
  230.         return canMoveToCell;
  231. }
  233. int Game::getObjectsCount(GameObjectType type)
  234. {
  235.         int totalCount = 0;
  237.         for (int i = 0; i < kObjectsCountMax; i++)
  238.         {
  239.                 if (m_objects[i] == 0)
  240.                         continue;
  242.                 if (m_objects[i]->getType() == type)
  243.                         totalCount++;
  244.         }
  246.         return totalCount;
  247. }
  249. GameObject* Game::createObject(GameObjectType type, float x, float y)
  250. {
  251.         // нахождение свободного указател и осоздание объекта
  252.         for (int i = 0; i < kObjectsCountMax; i++)
  253.         {
  254.                 if (m_objects[i] == 0)
  255.                 {
  256.                         GameObject* object = 0;
  258.                         switch (type)
  259.                         {
  260.                         case GameObjectType_Wall:                        object = new Wall();                        break;
  261.                         case GameObjectType_Bullet:                        object = new Bullet();                        break;
  262.                         case GameObjectType_GhostPlayer:        object = new GhostPlayer();                break;
  263.                         case GameObjectType_GhostEnemy:                object = new GhostEnemy();                break;
  264.                         case GameObjectType_Enemy:                object = new Enemy();        break;
  265.                         }
  266.                         if (object == 0)
  267.                                 return 0;
  268.                         object->setGame(this);
  269.                         if (moveObjectTo(object, x, y) == false)
  270.                         {
  271.                                 delete object;
  272.                                 return 0;
  273.                         }
  274.                         m_objects[i] = object;
  275.                         return object;
  276.                 }
  277.         }
  279.         return 0;
  280. }
  282. void Game::destroyObject(GameObject* object)
  283. {
  284.         for (int i = 0; i < kObjectsCountMax; i++)
  285.         {
  286.                 if (m_objects[i] == object)
  287.                 {
  288.                         delete m_objects[i];
  289.                         m_objects[i] = 0;
  290.                         return;
  291.                 }
  292.         }
  293. }
  295. void Game::increaseDiedEnemiesCount()
  296. {
  297.         m_diedEnemiesCount++;
  298. }
  1. game.h
  2. #pragma once
  3. #include
  4. #include
  5. #include "gameObject.h"
  6. #include "gameObjectType.h"
  8. const int kObjectsCountMax = 1024;
  10. // предварительное объявление класса
  11. class GameObject;
  13. class Game
  14. {
  15. public:
  16.         Game();
  17.         ~Game();
  19.         void setupSystem();
  20.         void initialize();
  21.         bool loop();
  22.         void shutdown();
  24.         GameObject* createObject(GameObjectType type, float x, float y);
  25.         void destroyObject(GameObject* object);
  26.         GameObject* checkIntersects(float x, float y, float width, float height, GameObject* exceptObject);
  27.         bool moveObjectTo(GameObject* object, float x, float y);
  28.         int getObjectsCount(GameObjectType type);
  30.         int getDiedEnemiesCount() { return m_diedEnemiesCount; }
  31.         void increaseDiedEnemiesCount();
  33. private:
  34.         void render();
  35.         void update(float dt);
  37. private:
  38.         bool m_isGameActive;
  39.         clock_t m_clockLastFrame;
  41.         sf::RenderWindow* m_renderWindow;
  43.         GameObject* m_objects[kObjectsCountMax];
  44.         GameObject* m_player;
  46.         int m_diedEnemiesCount;
  47. };
  1. gameObject.cpp
  2. #include "gameObject.h"
  3. #include "level.h"
  5. GameObject::GameObject()
  6. {
  7.         m_game = 0;
  8.         m_type = GameObjectType_None;
  10.         m_x = 0.0;
  11.         m_y = 0.0;
  12.         m_xSpeed = 0.0;
  13.         m_ySpeed = 0.0;
  15.         m_width = 1;
  16.         m_height = 1;
  18.         m_health = 1;
  19.         m_destroyAfterDeath = true;
  20.         m_invulnerable = false;
  22.         m_physical = true;
  24.         m_direction = Direction_Up;
  26.         m_sprite = new sf::Sprite();
  27.         m_sprite->setTexture(*g_atlas00);
  28.         setTextureRect(sf::IntRect());
  29. }
  31. GameObject::~GameObject()
  32. {
  33.         if (m_sprite)
  34.                 delete m_sprite;
  35. }
  37. void GameObject::render(sf::RenderWindow* rw)
  38. {
  39.         if (m_sprite)
  40.         {
  41.                 int row = int(m_y);
  42.                 int column = int(m_x);
  44.                 m_sprite->setPosition(column * kPixels, row * kPixels);
  46.                 rw->draw(*m_sprite);
  47.         }
  48. }
  50. void GameObject::update(float dt)
  51. {
  52.         int oldRow = int(m_y);
  53.         int oldColumn = int(m_x);
  55.         float newY = m_y + m_ySpeed * dt;
  56.         float newX = m_x + m_xSpeed * dt;
  58.         int newRow = int(newY);
  59.         int newColumn = int(newX);
  62.         if (oldColumn != newColumn)
  63.                 m_game->moveObjectTo(this, newX, m_y);
  64.         else
  65.                 m_x = newX;
  67.         if (oldRow != newRow)
  68.                 m_game->moveObjectTo(this, m_x, newY);
  69.         else
  70.                 m_y = newY;
  71. }
  73. void GameObject::intersect(GameObject* object)
  74. {
  76. }
  78. void GameObject::doDamage(int damage)
  79. {
  80.         if (getInvulnerable())
  81.                 return;
  83.         if (m_health > damage)
  84.                 m_health -= damage;
  85.         else
  86.                 m_health = 0;
  87. }
  1. gameObject.h
  2. #pragma once
  3. #include "direction.h"
  4. #include "game.h"
  5. #include "gameObjectType.h"
  7. // педварительное объявление класса
  8. class Game;
  10. class GameObject
  11. {
  12. public:
  13.         GameObject();
  14.         virtual ~GameObject();
  16.         virtual void render(sf::RenderWindow* rw);
  17.         virtual void update(float dt);
  19.         virtual void intersect(GameObject* object);
  21.         GameObjectType getType() { return m_type; }
  23.         void setGame(Game* game) { m_game = game; }
  25.         void setX(float x) { m_x = x; }
  26.         float getX() { return m_x; }
  28.         void setY(float y) { m_y = y; }
  29.         float getY() { return m_y; }
  31.         void setXSpeed(float xSpeed) { m_xSpeed = xSpeed; }
  32.         float getXSpeed() { return m_xSpeed; }
  34.         void setYSpeed(float ySpeed) { m_ySpeed = ySpeed; }
  35.         float getYSpeed() { return m_ySpeed; }
  37.         void setWidth(int width) { m_width = width; }
  38.         int getWidth() { return m_width; }
  40.         void setHeight(int height) { m_height = height; }
  41.         int getHeight() { return m_height; }
  43.         void setHealth(int health) { m_health = health; }
  44.         int getHealth() { return m_health; }
  46.         void setDestroyAfterDeath(bool destroyAfterDeath) { m_destroyAfterDeath = destroyAfterDeath; }
  47.         bool getDestroyAfterDeath() { return m_destroyAfterDeath; }
  49.         void setInvulnerable(bool invulnerable) { m_invulnerable = invulnerable; }
  50.         bool getInvulnerable() { return m_invulnerable; }
  52.         void setPhysical(bool physical) { m_physical = physical; }
  53.         bool getPhysical() { return m_physical; }
  55.         void setDirection(Direction direction) { m_direction = direction; }
  56.         Direction getDirection() { return m_direction; }
  58.         void doDamage(int damage);
  60.         void setSpriteColor(sf::Color color) { m_sprite->setColor(color); }
  61.         void setTextureRect(sf::IntRect rect) { m_sprite->setTextureRect(rect); }
  63. protected:
  64.         Game* m_game;
  65.         GameObjectType m_type;
  67.         float m_x;
  68.         float m_y;
  69.         float m_xSpeed;
  70.         float m_ySpeed;
  72.         int m_width;
  73.         int m_height;
  75.         int m_health;
  76.         bool m_destroyAfterDeath;
  77.         bool m_invulnerable;
  79.         bool m_physical;
  81.         Direction m_direction;
  83.         sf::Sprite* m_sprite;
  84. };
  1. gameObjectType.h
  2. #pragma once
  3. enum GameObjectType
  4. {
  5.         GameObjectType_None,
  6.         GameObjectType_Ghost,
  7.         GameObjectType_GhostPlayer,
  8.         GameObjectType_GhostEnemy,
  9.         GameObjectType_Wall,
  10.         GameObjectType_Bullet,
  11.         GameObjectType_Enemy,
  12. };
  1. ghost.cpp
  2. #include "ghost.h"
  3. #include "bullet.h"
  5. Ghost::Ghost()
  6. {
  7.         m_type = GameObjectType_Ghost;
  9.         m_width = kGhostSize;
  10.         m_height = kGhostSize;
  12.         m_speed = 0;
  13.         m_recoveryTime = 0.0;
  14. }
  16. void Ghost::update(float dt)
  17. {
  18.         GameObject::update(dt);
  20.         if (m_recoveryTime > 0)
  21.                 m_recoveryTime -= dt;
  22. }
  24. void Ghost::render(sf::RenderWindow* rw)
  25. {
  26.         sf::IntRect texRect = kGhostImage;
  27.         texRect.left += m_width * kPixels * m_direction;
  28.         setTextureRect(texRect);
  30.         GameObject::render(rw);
  31. }
  33. void Ghost::move(Direction direction)
  34. {
  35.         setDirection(direction);
  37.         setXSpeed(0);
  38.         setYSpeed(0);
  40.         switch (m_direction)
  41.         {
  42.         case Direction_Left: setXSpeed(-m_speed); break;
  43.         case Direction_Right: setXSpeed(m_speed); break;
  44.         case Direction_Up: setYSpeed(-m_speed); break;
  45.         case Direction_Down: setYSpeed(m_speed); break;
  46.         }
  47. }
  49. void Ghost::fire()
  50. {
  51.         if (m_recoveryTime > 0)
  52.                 return;
  54.         m_recoveryTime = kGhostRecoveryTime;
  56.         float x = 0.0;
  57.         float y = 0.0;
  58.         float xSpeed = 0.0;
  59.         float ySpeed = 0.0;
  61.         calculateFrontCellPosition(&x, &y);
  63.         switch (m_direction)
  64.         {
  65.         case Direction_Left: xSpeed = -kBulletSpeed; break;
  66.         case Direction_Right: xSpeed = kBulletSpeed; break;
  67.         case Direction_Up: ySpeed = -kBulletSpeed; break;
  68.         case Direction_Down: ySpeed = kBulletSpeed; break;
  69.         }
  71.         Bullet* bullet = (Bullet*)m_game->createObject(GameObjectType_Bullet, x, y);
  72.         if (bullet)
  73.         {
  74.                 bullet->setOwnerType(m_type);
  75.                 bullet->setXSpeed(xSpeed);
  76.                 bullet->setYSpeed(ySpeed);
  77.         }
  78. }
  80. void Ghost::calculateFrontCellPosition(float* x, float* y)
  81. {
  82.         switch (m_direction)
  83.         {
  84.         case Direction_Left:
  85.                 (*x) = int(getX()) - 0.01;
  86.                 (*y) = int(getY()) + (getHeight() / 2.0);
  88.                 break;
  89.         case Direction_Right:
  90.                 (*x) = int(getX()) + getWidth() + 0.01;
  91.                 (*y) = int(getY()) + (getHeight() / 2.0);
  92.                 break;
  93.         case Direction_Up:
  94.                 (*y) = int(getY()) - 0.01;
  95.                 (*x) = int(getX()) + (getWidth() / 2.0);
  96.                 break;
  97.         case Direction_Down:
  98.                 (*y) = int(getY()) + getHeight() + 0.01;
  99.                 (*x) = int(getX()) + (getWidth() / 2.0);
  100.                 break;
  101.         }
  102. }
  1. ghost.h
  2. #pragma once
  3. #include "gameObject.h"
  4. #include "level.h"
  6. class Ghost
  7.         : public GameObject
  8. {
  9. public:
  10.         Ghost();
  12.         virtual void update(float dt);
  13.         virtual void render(sf::RenderWindow* rw);
  15.         void move(Direction direction);
  16.         void fire();
  18. protected:
  19.         void calculateFrontCellPosition(float* x, float* y);
  21. protected:
  22.         float m_recoveryTime;
  23.         float m_speed;
  24. };
  1. ghostEnemy.cpp
  2. #include "ghostEnemy.h"
  3. #include "utils.h"
  4. #include "wall.h"
  5. #include "bullet.h"
  7. GhostEnemy::GhostEnemy()
  8. {
  9.         m_type = GameObjectType_GhostEnemy;
  10.         m_analizeTime = kEnemyAIAnalizeTime;
  11.         m_analizeTimer = GetRandomFloat(0.0, m_analizeTime);
  12.         m_lastAnalizeX = 0.0;
  13.         m_lastAnalizeY = 0.0;
  15.         m_health = kEnemyHealth;
  16.         m_speed = kEnemySpeed;
  18.         setSpriteColor(sf::Color(0, 165, 226));
  19. }
  21. GhostEnemy::~GhostEnemy()
  22. {
  23.         m_game->increaseDiedEnemiesCount();
  24. }
  26. void GhostEnemy::update(float dt)
  27. {
  28.         Ghost::update(dt);
  30.         m_analizeTimer += dt;
  31.         if (m_analizeTimer >= m_analizeTime)
  32.         {
  33.                 m_analizeTimer = 0;
  34.                 analize();
  35.         }
  36. }
  38. void GhostEnemy::analize()
  39. {
  40.         float x = 0.0;
  41.         float y = 0.0;
  42.         calculateFrontCellPosition(&x, &y);
  44.         float xDelta = 0.0;
  45.         float yDelta = 0.0;
  47.         switch (m_direction)
  48.         {
  49.         case Direction_Left: xDelta = -1.0; break;
  50.         case Direction_Right: xDelta = 1.0; break;
  51.         case Direction_Up: yDelta = -1.0; break;
  52.         case Direction_Down: yDelta = 1.0; break;
  53.         }
  54.         // находит ближайшего врага и расстояние к нему
  55.         GameObject* object = 0;
  56.         int distance = 0;
  57.         do
  58.         {
  59.                 object = m_game->checkIntersects(x, y, 1, 1, 0);
  61.                 x += xDelta;
  62.                 y += yDelta;
  63.                 ++distance;
  64.         } while (object == 0);
  67.         // защита от пуль
  68.         if (object->getType() == GameObjectType_Bullet)
  69.         {
  70.                 if (((Bullet*)object)->getOwnerType() == GameObjectType_GhostPlayer)
  71.                         fire();
  73.                 return;
  74.         }
  76.         // атака
  77.         if (object->getType() == GameObjectType_GhostPlayer)
  78.         {
  79.                 fire();
  80.                 return;
  81.         }
  83.         // 20% смена направления
  84.         if (0 == rand() % 5)
  85.         {
  86.                 // движение в случайном направлении
  87.                 moveRandomDirection();
  88.                 return;
  89.         }
  92.         switch (object->getType())
  93.         {
  94.         case GameObjectType_Wall:
  95.                 if (((Wall*)object)->getInvulnerable() == false)
  96.                 {
  97.                         fire();
  98.                         return;
  99.                 }
  100.                 break;
  101.         }
  104.         // смена направления
  105.         if (distance == 1
  106.                 || ((int)m_lastAnalizeX == (int)getX() && (int)m_lastAnalizeY == (int)getY()))
  107.         {
  108.                 // движение в случайном направлении
  109.                 moveRandomDirection();
  110.                 return;
  111.         }
  113.         m_lastAnalizeX = getX();
  114.         m_lastAnalizeY = getY();
  115. }
  117. void GhostEnemy::moveRandomDirection()
  118. {
  119.         Direction prevDirection = getDirection();
  120.         Direction newDirection;
  121.         do
  122.         {
  123.                 newDirection = (Direction)(rand() % ((int)Direction_MAX));
  124.         } while (prevDirection == newDirection);
  126.         move(newDirection);
  127. }
  1. ghostEnemy.h
  2. #pragma once
  3. #include "ghost.h"
  5. class GhostEnemy
  6.         : public Ghost
  7. {
  8. public:
  9.         GhostEnemy();
  10.         ~GhostEnemy();
  11.         void update(float dt);
  13. protected:
  15.         void analize();
  16.         void moveRandomDirection();
  18. protected:
  19.         float m_analizeTimer;
  20.         float m_analizeTime;
  22.         float m_lastAnalizeX;
  23.         float m_lastAnalizeY;
  24. };
  1. ghostPlayer.cpp
  2. #include "ghostPlayer.h"
  3. #include "utils.h"
  5. GhostPlayer::GhostPlayer()
  6. {
  7.         m_type = GameObjectType_GhostPlayer;
  9.         m_keyLeft = 0;
  10.         m_keyRight = 0;
  11.         m_keyUp = 0;
  12.         m_keyDown = 0;
  13.         m_keyFire = 0;
  15.         m_health = kPlayerHealth;
  16.         m_speed = kPlayerSpeed;
  18.         m_destroyAfterDeath = false;
  19. }
  21. void GhostPlayer::update(float dt)
  22. {
  23.         Ghost::update(dt);
  25.         if (IsKeyDown(m_keyLeft))
  26.                 move(Direction_Left);
  27.         else
  28.                 if (IsKeyDown(m_keyRight))
  29.                         move(Direction_Right);
  30.                 else
  31.                         if (IsKeyDown(m_keyUp))
  32.                                 move(Direction_Up);
  33.                         else
  34.                                 if (IsKeyDown(m_keyDown))
  35.                                         move(Direction_Down);
  36.                                 else
  37.                                 {
  38.                                         setXSpeed(0);
  39.                                         setYSpeed(0);
  40.                                 }
  42.         if (IsKeyDown(m_keyFire))
  43.                 fire();
  44. }
  46. void GhostPlayer::setKeys(int keyLeft, int keyRight, int keyUp, int keyDown, int keyFire)
  47. {
  48.         m_keyLeft = keyLeft;
  49.         m_keyRight = keyRight;
  50.         m_keyUp = keyUp;
  51.         m_keyDown = keyDown;
  52.         m_keyFire = keyFire;
  53. }
  1. ghostPlayer.h
  2. #pragma once
  3. #include "ghost.h"
  4. class GhostPlayer
  5.         : public Ghost
  6. {
  7. public:
  8.         GhostPlayer();
  10.         void update(float dt);
  12.         void setKeys(int keyLeft, int keyRight, int keyUp, int keyDown, int keyFire);
  14. protected:
  15.         int m_keyLeft;
  16.         int m_keyRight;
  17.         int m_keyUp;
  18.         int m_keyDown;
  19.         int m_keyFire;
  20. };
  1. level.h
  2. #include
  3. #include "direction.h"
  4. // внешнее
  5. extern sf::Texture* g_atlas00;
  6. // данные уровеня
  7. const int kScreenRows = 40;
  8. const int kScreenColumns = 80;
  9. const int kLevelRows = kScreenRows;
  10. const int kLevelColumns = 70;
  11. const int kPixels = 15;  
  13. const unsigned char        CellSymbol_Player = '1';
  14. const unsigned char        CellSymbol_Ghost = 'T';
  15. const unsigned char        CellSymbol_BrickWall = '#';
  16. const unsigned char        CellSymbol_SteelWall = '@';
  17. const unsigned char        CellSymbol_Enemy = 'S';
  19. const unsigned char kLevelData0[kLevelRows][kLevelColumns + 1] =
  20. {
  21.         "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@",
  22.         "@S                                                                     @@                                                        S       @",
  23.         "@                                                                       @@                                                                 @",
  24.         "@                                                                       @@                                                                 @",
  25.         "@                                                                                           S           @@@@                         @",
  26.         "@                                                                                                        @                                    @",
  27.         "@                                                                                                        @                                    @",
  28.         "@@@@@@@@@@@@@@@@                                                 @                                    @",
  29.         "@                                                @                                                     @                                    @",
  30.         "@                                                @                                                     @                                    @",
  31.         "@                                                @                                                        @@@@@@               @",
  32.         "@                                                @                                                                                             @",
  33.         "@                                                 @@@@@                                                                             @",
  34.         "@                                        @                                                                                                     @",
  35.         "@                                        @                                                                                                     @",
  36.         "@                                        @                           @@@@@@@@@@@@@@@@@@@@@",
  37.         "@   S                                       @                                                          @                                  @",
  38.         "@                                            @                                                            @                                @",
  39.         "@                                            @                                          @                  @                            @",
  40.         "@@@@@@@@@@@@@@@@                       @        @                  @                            @",
  41.         "@                                                                              @                              @                            @",
  42.         "@                                                                              @                               @                           @",
  43.         "@                                                           @@@@@@                                 @@@@              @",
  44.         "@                                                           @                                                           @@              @",
  45.         "@                                                           @                                                                                @",
  46.         "@                                                           @                                                                  S            @",
  47.         "@@@@@@@@@@@@@@@@@@                         @@                                                @",
  48.         "@             @                                                                     @@                                                  @",
  49.         "@         1   @                                                                   @@                                                   @",
  50.         "@             @                                                                  @@               @@@                           @",
  51.         "@                                                                                 @@                @@@                            @",
  52.         "@                                                                               @@                @                                     @",
  53.         "@                                                                             @@                 @                                      @",
  54.         "@                                                                            @@                 @                                       @",
  55.         "@             @                                                         @@                   @                                       @",
  56.         "@             @                                                        @@                    @                                       @",
  57.         "@             @                                                     @@                   @                                           @",
  58.         "@             @                                                     @                      @                                            @",
  59.         "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@",
  60. };
  63. const sf::IntRect kBrickWallImage = sf::IntRect(0, 3 * kPixels, kPixels, kPixels);
  64. const sf::IntRect kSteelWallImage = sf::IntRect(kPixels, 3 * kPixels, kPixels, kPixels);
  66. // данные призрака
  67. const float kGhostRecoveryTime = 0.5; //FireCooldown воссстановление
  68. const int kGhostSize = 3; //размер призрака
  69. const sf::IntRect kGhostImage = sf::IntRect(0, 0, kGhostSize*kPixels, kGhostSize*kPixels);
  71. // данные игрока
  72. const int kPlayerHealth = 16; //здоровье
  73. const int kPlayerSpeed = 10; //скорость
  75. // данные врага
  76. const int kEnemiesLevel = 10;  //количество врагов    
  77. const int kEnemiesLevelInOneMoment = 6; //масимальное кооличество врагов в один момент  
  78. const int kEnemyHealth = 5; //здоровье врага
  79. const int kEnemySpeed = 5;  //скорость врагов
  80. const float kEnemyEmergenceTime = 10.0; // востанновление
  81. const float kEnemyAIAnalizeTime = 0.5;
  83. // данные пули
  84. const float kBulletSpeed = 30.0;
  85. const sf::IntRect kBulletImage = sf::IntRect(0, 4 * kPixels, kPixels, kPixels);
  1. main.cpp
  2. #define _CRT_SECURE_NO_WARNINGS
  4. #include "game.h"
  5. #include
  6. // Чтобы убрать коносль в релизе
  7. #ifndef _DEBUG
  8. #        pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
  9. #endif
  11. int main()
  12. {
  13.         Game game;
  15.         game.setupSystem();
  16.         game.initialize();
  17.         
  18.         while (game.loop());
  20.         game.shutdown();
  22.         return 0;
  23. }
  1. utils.cpp
  2. #include "utils.h"
  3. #include
  5. bool IsKeyDown(int virtualKeyCode)
  6. {
  7.         short keyState = GetAsyncKeyState(virtualKeyCode);
  8.         return ((keyState & 0x8000) > 0);
  9. }
  11. int GetRandomInt(int min, int max)
  12. {
  13.         return min + rand() % (max - min + 1);
  14. }
  16. float GetRandomFloat(float min, float max)
  17. {
  18.         return (min + (max - min) * (rand() % 101 / 100.0));
  19. }
  1. utils.h
  2. #pragma once
  4. bool IsKeyDown(int virtualKeyCode);
  5. int GetRandomInt(int min, int max);
  6. float GetRandomFloat(float min, float max);
  1. wall.cpp
  2. #include "wall.h"
  4. Wall::Wall()
  5. {
  6.         m_type = GameObjectType_Wall;
  7. }
  9. void Wall::render(sf::RenderWindow* rw)
  10. {
  11.         GameObject::render(rw);
  12. }
  1. wall.h
  2. #pragma once
  3. #include "gameObject.h"
  4. #include "level.h"
  6. class Wall
  7.         : public GameObject
  8. {
  9. public:
  10.         Wall();
  11.         virtual void render(sf::RenderWindow* rw);
  13. private:
  14. };
  39. 3.2 Результаты тестирования
  40. Рисунок 1 — Запуск игры «Ghost’s city», призрак не стреляет[pic 1]
  42. Рисунок 2 — Запуск игры «Ghost’s city», призрак стреляет[pic 2]
  1. МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
  1. федеральное государственное автономное образовательное учреждение
    высшего профессионального образования
  1. «Санкт-Петербургский государственный университет
    аэрокосмического приборостроения»
  2. КАФЕДРА ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМ И СЕТЕЙ
  1. ПРОГРАММА
  1. Игра «Ghost’s city»
  1. Описание программы
  1. 44.4642.17-13
  1. РАБОТУ ВЫПОЛНИЛ
  1. СТУДЕНТ ГР.
  1. 4642
  1. Ю.Л.Ляпина
  1. подпись, дата
  1. инициалы, фамилия
  9. Санкт-Петербург
  10. 2017
  13. Аннотация
  14.  В документе приведены общие сведения  о  программе. Приведено общее описание функционирования программы , общие сведения о языке программирования. Описаны входные  и выходные данные, логика работы программы, даны сведения об используемых технических средствах.  
  1. Содержание
  2. 4.1 Общие сведения
  3. 4.2 Функциональное назначение
  4. 4.3 Описание логической структуры
  5. 4.4 Спецификация подпрограммы
  6. 4.5 Используемые технические средствах
  7. 4.6  Вызов и загрузка
  1. 4.1 Общие сведения
  2. Программа написана на языке С++  совместно с SFML, состоит из игрового окна и окна завершения. Программа «Ghost’s city» - предназначенная для одного пользователя. Суть программы убить всех своих врагов-призраков и выжить самому. От пользователя требуется наличие клавиатуры.
  3. 4.2 Функциональное назначение
  4. С помощью данной программы пользователь может хорошо провести время. Может повысить свои навыки ловкости.
  5. 4.3 Описание логической структуры
  6. Программа написана на языке С++  совместно с SFML. При открытии программы появляется окно с игровым полем, значит игра уже началась. После проигрыша ( смерть игрока-призрака ) игра автоматически перезапускается, после выигрыша — остается один игрок-призрак и экран начинает мигать синим цветом.
  7. Управление для пользователя:
  8. - W - движение вверх
  9. - A  - движение влево
  10. - S  - движение вниз
  11. - D  - движение вправо
  12. - SPACE ( клавиша «пробел») - выстрел
  13. 4.4 Спецификация подпрограммы
  14. 4.4.1 Функция initialize
  15. Назначение: задание начальных значений для логики игры (используется с классом Game)
  16. Имя: initialize
  17. Заголовок: void initialize(); void Game::initialize();
  18. 4.4.2 Функция loop
  19. Назначение: вычисление значения fps ( FramesTimeCounter)
  20. Имя: loop
  21. Заголовок: bool loop();bool Game::loop();
  22. 4.4.3 Функция main
  23. Назначение:  главная функция
  24. Имя: main
  25. Заголовок:  int main()
  26. 4.4.4 Функция render
  27. Назначение: осуществление гафического вывода основного цикла игры на экран (используется с классами: Game, Enemy,  Ghost, Bullet:, Wall,  GameObject)
  28. Имя: render
  29. Заголовок: void Wall::render(sf::RenderWindow* rw)
  30. 4.4.5 Функция update
  31. Назначение: алгоритм управления (используется с классами: Game, Enemy,  GameObject, Ghost,  GhostEnemy, GhostPlayer)
  32. Имя:  update
  33. Заголовок: void  update ( float dt);
  34. 4.4.6 Функция  IsKeyDown
  35. Назначение: проверка нажатия клавиши
  36. Имя: IsKeyDown
  37. Заголовок: bool IsKeyDown(int virtualKeyCode)
  38. 4.4.7 Функция setupSystem
  39. Назначение: действия насчет единоразовых настроек системы.Задание зерна генератору псевдослучайных чисел.
  40. Имя: setupSystem
  41. Заголовок: void setupSystem(); void Game::setupSystem();
  42. 4.4.8 Функция increaseDiedEnemiesCount
  43. Назначение:
  44. Имя:  increaseDiedEnemiesCount
  45. Заголовок: void Game::increaseDiedEnemiesCount();
  46. 4.4.9 Функция  destroyGameObject
  47. Назначение: удаление игрового объекта
  48. Имя: destroyGameObject
  49. Заголовок:  void Game::destroyObject(GameObject* object)
  50. 4.4.10 Функция getObjectsCount
  51. Назначение: подсчитывает количество объектов
  52. Имя: getObjectsCount
  53. Заголовок: int Game::getObjectsCount(GameObjectType type)
  54. 4.4.11 Функция moveObjectTo
  55. Назначение:  движение объектом
  56. Имя: moveObjectTo
  57. Заголовок: bool Game::moveObjectTo(GameObject* object, float x, float y)
  58. 4.4.12 Функция  intersect
  59. Назначение:  информаирование объекта, что он столкнулся с другим объектом. Также при столкновении наносит 1 единицу урона
  60. Имя: intersect
  61. Заголовок:  void Bullet::intersect(GameObject* object)
  62. 4.4.13 Функция  doDamage
  63. Назначение: нанесение урона
  64. Имя:  doDamage
  65. Заголовок: void GameObject::doDamage(int damage)
  66. 4.4.14 Функция move
  67. Назначение: движение
  68. Имя: move
  69. Заголовок: void Ghost::move(Direction direction)
  70. 4.4.15 Функция fire
  71. Назначение:  атака
  72. Имя: fire
  73. Заголовок:  void Ghost::fire()
  74. 4.4.16 Функция  calculateFrontCellPosition
  75. Назначение: возвращает координаты ячейки перед пистолетом призрака
  76. Имя:  calculateFrontCellPosition
  77. Заголовок:  void Ghost::calculateFrontCellPosition(float* x, float* y)
  78. 4.4.17 Функция  moveRandomDirection
  79. Назначение: движение в случайном направлении
  80. Имя:  moveRandomDirection
  81. Заголовок:  void GhostEnemy::moveRandomDirection()
  82. 4.4.18 Функция  analize
  83. Назначение: совершает анализ и выбирает какое действие ему совершить
  84. Имя:  analize
  85. Заголовок:  void GhostEnemy::analize()
  86. 4.4.19 Функция  setKeys
  87. Назначение: принимает значение нажатой клавиши
  88. Имя:  setKeys
  89. Заголовок:  void GhostPlayer::setKeys(int keyLeft, int keyRight, int keyUp, int keyDown, int keyFire)
  90. 4.4.20 Функция shutdown
  91. Назначение: задержка выполнения программы, по окончанию игры
  92. Имя: shutdown
  93. Заголовок: void Game::shutdown()
  94. 4.4.21 Функция  GetRandomFloat
  95. Назначение: дает случайное значение вещественного типа
  96. Имя:  GetRandomFloat
  97. Заголовок:  float GetRandomFloat(float min, float max)
  98. 4.4.22 Функция GetRandomInt
  99. Назначение: дает случайное значение целого типа
  100. Имя: GetRandomInt
  101. Заголовок:  int GetRandomInt(int min, int max)
  102. 4.5 Используемые технические средствах
  103. Для адекватного функционировании программы необходимо наличие ПК с ОС windows 7 и выше, необходимо наличие клавиатуры.
  104. 4.6  Вызов и загрузка
  105. Вызов  и загрузка программы осуществляется в следующей последовательности: нахождение файла программы «Ghost’s city.exe», запуск исполняемого файла, ожидание открытия программы.
  1. МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
  1. федеральное государственное автономное образовательное учреждение
    высшего профессионального образования
  1. «Санкт-Петербургский государственный университет
    аэрокосмического приборостроения»
  2. КАФЕДРА ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМ И СЕТЕЙ
  1. ПРОГРАММА
  1. Игра «Ghost’s city»
  1. Описание применения
  1. 44.4642.17-31
  1. РАБОТУ ВЫПОЛНИЛ
  1. СТУДЕНТ ГР.
  1. 4642
  1. Ю.Л.Ляпина
  1. подпись, дата
  1. инициалы, фамилия
  9. Санкт-Петербург
  10. 2017
  11. Аннотация
  12. В документе приводятся назначение программы , ее основные характеристики  и область применения. Приводятся общие  характеристики входной и выходной информации.
  1. Содержание
  2. 5.1 Назначение программы
  3. 5.2 Условия применения
  4. 5.3 Описание задачи
  5. 5.4 Характеристики
  1. 5.1 Назначение программы
  2. Программа «Ghost’s city»  предназначена для развлекательных целей.
  3. 5.2 Условия применения
  4. Программа написана на языке С++ , совмещенная с библиотекой SFML. Для адекватного функционировании программы необходимо наличие ПК с ОС windows 7 и выше, необходимо наличие клавиатуры. Для запуска программы также необходимо: нахождение файла программы «Ghost’s city.exe», запуск исполняемого файла, ожидание открытия программы.
  5. 5.3 Описание задачи
  6. Разработать программу, дающую возможность расслабиться и отдохнуть после тяжелого дня в игре «Ghost’s city».
  7. 5.4 Характеристики
  8. Файл «Ghost’s city.exe» - 552 КБ
  9. Файлы классов и библиотек — 105 МБ (из этого обычные С++ библиотеки, без библиотеки SFML, весят 35,8 КБ)
  10. Изображение (спрайты) — 23 КБ
  1. ЗАКЛЮЧЕНИЕ
  2. В данной курсовой работе реализована программа «Ghost’s city».
  3. В процессе работы над курсовым проектом были закреплены навыки программирования на языке С++ с подключением библиотеки SFML в среде Visual Studio.
  4. Получены умения по документированию программного обеспечения, согласно принятым государственным стандартам.
  1. СПИСОК ИСПОЛЬЗУЕМЫХ ИСТОЧНИКОВ
  3. 1. ГОСТ 19.701-90 Схемы алгоритмов, программ, данных и систем. Условные обозначения и правила выполнения.
  4. 2. Курсы создания компьютерных игр на C/C++ [Электронный ресурс]. - Режим доступа: https://pikabu.ru/story/kursyi_sozdaniya_kompyuternyikh_igr_na_cc__chast_10__3848892, свободный.
  5. 3.Курсы создания компьютерных игр на SFML [Электронный ресурс]. - Режим доступа: http://kychka-pc.ru/category/sfml, свободный
  6. 4. Практический курс программирования на Си, автор К. Поляков [Электронный ресурс] -  Режим доступа:  http://kpolyakov.spb.ru/school/c.htm, свободный

...

Скачать:   txt (96.2 Kb)   pdf (364 Kb)   docx (132.7 Kb)  
Продолжить читать еще 208 страниц(ы) »
Читать полный текст Сохранить
Доступно только на Essays.club