Balls version

Escape.pro

@@ -1,4 +1,4 @@
-QT       += core gui
+QT       += core gui multimedia
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -43,4 +43,4 @@ else: unix:!android: target.path = /opt/$${TARGET}/bin
 !isEmpty(target.path): INSTALLS += target
 
 RESOURCES += \
-    images.qrc
+    res.qrc

Escape.pro.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 9.0.1, 2023-05-26T00:33:40. -->
+<!-- Written by QtCreator 9.0.1, 2023-06-01T10:28:18. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>

classes/controller.h

@@ -37,6 +37,11 @@ public slots:
     void keyDAction();
     void keySAction();
 
+    void updateScore();
+
+    void shiftClicked();
+    void shiftReleased();
+
 private:
     Model* model;
     View* view;
@@ -47,6 +52,8 @@ public slots:
     QTimer* keyW;
     QTimer* keyD;
     QTimer* keyS;
+
+    QTimer* scoreUpdate;
 };
 
 #endif // CONTROLLER_H

classes/gun.h

@@ -2,12 +2,16 @@
 #define GUN_H
 
 #include <QImage>
+#include <QObject>
+#include <QTimer>
+#include <QMediaPlayer>
 
-class Gun {
+class Gun : public QObject {
+    Q_OBJECT
 public:
-    Gun();
+    Gun(QObject* parent = nullptr);
     Gun(const Gun& other);
-    Gun(QImage, int, int);
+    Gun(QImage, int, int, QObject* parent = nullptr);
     void operator=(const Gun&);
 
     const QImage& getImage() const;
@@ -16,12 +20,15 @@ class Gun {
 
     bool isReadyToShoot();
 
+private slots:
+    void stopDelay();
+
 private:
     QImage image;
     int damage;
     int frequency;
-    int delay;
-
+    QTimer *timer;
+    QMediaPlayer* player;
 };
 
 #endif // GUN_H

classes/model.h

@@ -4,11 +4,15 @@
 #include <classes/monsters.h>
 #include <classes/map.h>
 #include <classes/player.h>
+#include <QMediaPlayer>
+#include <QMediaPlayList>
+#include <QObject>
 
-class Model {
+class Model : public QObject {
+    Q_OBJECT
 public:
-    Model();
-    Model(Player, Monsters, Map, int, double);
+    Model(QObject* parent = nullptr);
+    Model(Player, Monsters, Map, int, double, QObject* parent = nullptr);
 
     Player& getPlayer();
     Monsters& getMonsters();
@@ -24,13 +28,19 @@ class Model {
     void jumpPlayerUpdate(double interval);
     bool isPlayerDied();
 
+    void killMonster();
+    void injureMonster();
+
 private:
     Player player;
     Monsters monsters;
     Map map;
     int score;
     double gravity;
+    QMediaPlayer* soundPlayer;
 
+    QMediaPlayer* injured;
+    QMediaPlayer* killed;
 };
 
 #endif // MODEL_H

classes/monster.h

@@ -3,9 +3,12 @@
 
 #include <classes/player.h>
 #include <QImage>
+#include <QObject>
+#include <QMediaPlayer>
 #include <QPointF>
 
 class Monster {
+
 public:
     Monster();
     Monster(QImage, double, QPointF, int, double, double);
@@ -15,6 +18,7 @@ class Monster {
     const QImage& getImage() const;
     double getHeight() const;
     const QPointF& getPosition() const;
+    void setHeight(double);
     void setPosition(const QPointF&);
     double getHitboxRadius() const;
 
@@ -29,7 +33,6 @@ class Monster {
     int health;
     double hitboxRadius;
     double speed;
-
 };
 
 #endif // MONSTER_H

classes/player.h

@@ -26,7 +26,7 @@ class Player {
     double getJumpHeight() const;
     void setJumpHeight(double);
 
-    const Gun& getGun() const;
+    Gun& getGun();
     void setGun(const Gun&);
 
 

classes/view.h

@@ -6,6 +6,7 @@
 #include <QPaintEvent>
 #include <QMouseEvent>
 #include <QKeyEvent>
+#include <QLabel>
 #include <classes/model.h>
 
 class View : public QMainWindow
@@ -29,6 +30,9 @@ class View : public QMainWindow
     void keyDReleased();
     void keySReleased();
 
+    void shiftClicked();
+    void shiftReleased();
+
 protected:
     void paintEvent(QPaintEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
@@ -44,5 +48,7 @@ class View : public QMainWindow
     void drawGun(QPainter *);
     void drawScore(QPainter *);
 
+    QLabel* score;
+
 };
 #endif // VIEW_H

realizations/controller.cpp

@@ -18,7 +18,7 @@ Controller::Controller(Model *newModel, View *newView, QObject *parent) :
 
     generateMonsterTimer = new QTimer(this);
     connect(generateMonsterTimer, &QTimer::timeout, this, &Controller::generateMonster);
-    generateMonsterTimer->start(10'000);
+    generateMonsterTimer->start(3'000);
 
     keyA = new QTimer(this);
     keyD = new QTimer(this);
@@ -47,10 +47,19 @@ Controller::Controller(Model *newModel, View *newView, QObject *parent) :
     connect(view, &View::keyDReleased, this, &Controller::keyDReleased);
     connect(view, &View::keySReleased, this, &Controller::keySReleased);
     connect(view, &View::keyWReleased, this, &Controller::keyWReleased);
+
+    connect(view, &View::shiftClicked, this, &Controller::shiftClicked);
+    connect(view, &View::shiftReleased, this, &Controller::shiftReleased);
+
+
+    scoreUpdate = new QTimer(this);
+    scoreUpdate->setTimerType(Qt::PreciseTimer);
+    connect(scoreUpdate, &QTimer::timeout, this, &Controller::updateScore);
+    scoreUpdate->start(1000);
 }
 
 void Controller::mouseMove(QMouseEvent *event) {
-    int centerX = view->width() / 2;
+    int centerX = view->width() / 2 - 1;
     int delta = centerX - event->x();
     model->getPlayer().rotate(delta * 1.0 / centerX * model->getPlayer().getViewAngle());
 
@@ -66,6 +75,14 @@ void Controller::spaceClicked(QKeyEvent *event) {
     }
 }
 
+void Controller::shiftClicked() {
+    model->getPlayer().setSpeed(model->getPlayer().getSpeed() * 2);
+}
+
+void Controller::shiftReleased() {
+    model->getPlayer().setSpeed(model->getPlayer().getSpeed() / 2.0);
+}
+
 void Controller::keyAPressed() {
     keyA->start(15);
 }
@@ -161,6 +178,7 @@ void Controller::updateView() {
     model->jumpPlayerUpdate(interval);
     model->moveMonsters(interval);
     if (model->isPlayerDied()) {
+        qDebug() << "killed";
         QCoreApplication::quit();
     }
     view->repaint();
@@ -170,8 +188,26 @@ void Controller::generateMonster() {
     QImage imageMonster = QImage(":/images/images/gameicon.png");
     qsrand(QTime::currentTime().msec());
 
-    float randomHeight = qrand() % 9 + static_cast<float>(qrand())
-            / static_cast<float>(RAND_MAX);
-    Monster monster(imageMonster, randomHeight, QPointF(20, 0), 10, 2, 2);
-    model->getMonsters().addMonster(monster);
+    bool isFound = 0;
+    while(!isFound) {
+        float randomHeight = 1;
+        float randomX = qrand() % 110 - 56 + static_cast<float>(qrand())
+                / static_cast<float>(RAND_MAX);
+        float randomY = qrand() % 110 - 56 + static_cast<float>(qrand())
+                / static_cast<float>(RAND_MAX);
+
+        double dx = randomX - model->getPlayer().getPosition().x();
+        double dy = randomY - model->getPlayer().getPosition().y();
+        double dz = randomHeight - model->getPlayer().getHeight() - model->getPlayer().getJumpHeight();
+        float length = sqrt(dx * dx + dy * dy + dz * dz);
+        if (length > 10) {
+            Monster monster(imageMonster, randomHeight, QPointF(randomX, randomY), 20, 2, 8);
+            model->getMonsters().addMonster(monster);
+            break;
+        }
+    }
+}
+
+void Controller::updateScore() {
+    model->increaseScore();
 }

realizations/draw/drawMonsters.cpp

@@ -2,24 +2,33 @@
 #include <QDebug>
 #include <cmath>
 
-struct MonsterRelative {
-    Monster monster;
-    double angleHorizontal;
-    double angleVertical;
-    double length;
-    double deviation;
-};
-
-bool comparison(const MonsterRelative& first, const MonsterRelative& second) {
-    return first.length > second.length;
-}
-
 void View::drawMonsters(QPainter *painter) {
-    const std::vector<Monster>& monsters = model->getMonsters().getMonsters();
+    std::vector<Monster>& monsters = model->getMonsters().getMonsters();
     const Player& player = model->getPlayer();
     const QPointF& position = player.getPosition();
 
-    std::vector<MonsterRelative> monstersRelative;
+    // sorting monsters by their length to the player
+    std::sort(monsters.begin(), monsters.end(), [player, position](Monster& first, Monster& second) {
+        // absolute value
+        // use the coordinate transformation formula
+        // x' = (x - a1)
+        // y' = (y - a2)
+        double dxFirst = first.getPosition().x() - position.x();
+        double dyFirst = -first.getPosition().y() + position.y();
+        double dzFirst = first.getHeight() - player.getHeight() - player.getJumpHeight();
+
+        double lengthFirst = sqrt(dxFirst * dxFirst + dyFirst * dyFirst + dzFirst * dzFirst);
+
+        double dxSecond = second.getPosition().x() - position.x();
+        double dySecond = -second.getPosition().y() + position.y();
+        double dzSecond = second.getHeight() - player.getHeight() - player.getJumpHeight();
+
+        double lengthSecond =
+                sqrt(dxSecond * dxSecond + dySecond * dySecond + dzSecond * dzSecond);
+
+        return lengthFirst > lengthSecond;
+    });
+
     // count monsters' angles relatively to angleLeft
     for (std::size_t i = 0; i < monsters.size(); ++i) {
         // absolute value
@@ -63,26 +72,18 @@ void View::drawMonsters(QPainter *painter) {
                 angleVertical = -M_PI - angleVertical;
             }
         }
-        // it can't be less than -pi, because viewAngle < pi / 2
-        monstersRelative.push_back(MonsterRelative({monsters[i], angleHorizontal, angleVertical, length, deviation}));
-    }
-    // sorting monsters by their length to the player
-    std::sort(monstersRelative.begin(), monstersRelative.end(), comparison);
 
-    // drawing monsters
-    for (std::size_t i = 0; i < monstersRelative.size(); ++i) {
-        const MonsterRelative& monsterRelative = monstersRelative[i];
-        QImage image = monsterRelative.monster.getImage();
+        // drawing monsters
+        QImage image = monsters[i].getImage();
         // half of the width
-        int imageWidthHalf = monsterRelative.deviation / player.getViewAngle() * (width() / 2.0);
-        int imageX = (width() / 2.0) * (1 + monsterRelative.angleHorizontal / player.getViewAngle());
-        int imageY = height() / 2.0 - width() / 2.0 * monsterRelative.angleVertical / player.getViewAngle();
-        if (monsterRelative.length < 0.0001) {
+        int imageWidthHalf = deviation / player.getViewAngle() * (width() / 2.0);
+        int imageX = (width() / 2.0) * (1 + angleHorizontal / player.getViewAngle());
+        int imageY = height() / 2.0 - width() / 2.0 * angleVertical / player.getViewAngle();
+        if (length < 0.0001) {
             continue;
         }
 
-        double length = monsterRelative.length;
-        double radius = monsterRelative.monster.getHitboxRadius();
+        double radius = monsters[i].getHitboxRadius();
         int newWidth = sqrt(length * length - radius * radius) / length * image.width();
         QImage newImage(image.width(), image.height(), QImage::Format_ARGB32);
         newImage.fill(Qt::transparent);
@@ -99,5 +100,6 @@ void View::drawMonsters(QPainter *painter) {
         painter->
                 drawImage(imageX - imageWidthHalf, imageY - imageWidthHalf,
                           finalImage.scaled(2 * imageWidthHalf, 2 * imageWidthHalf, Qt::KeepAspectRatio));
+
     }
 }

realizations/draw/drawScore.cpp

@@ -1,5 +1,6 @@
 #include <classes/view.h>
 
 void View::drawScore(QPainter *painter) {
-
+    Q_UNUSED(painter);
+    score->setText(QString::number(model->getScore()));
 }