diff --git a/Escape.pro b/Escape.pro
index 1aa0756..952df91 100644
--- a/Escape.pro
+++ b/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
diff --git a/Escape.pro.user b/Escape.pro.user
index 13af46b..4342fdd 100644
--- a/Escape.pro.user
+++ b/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>
diff --git a/classes/controller.h b/classes/controller.h
index 72b5d3c..114908e 100644
--- a/classes/controller.h
+++ b/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
diff --git a/classes/gun.h b/classes/gun.h
index 5311d80..957b2fa 100644
--- a/classes/gun.h
+++ b/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
diff --git a/classes/model.h b/classes/model.h
index 700196e..7ea413a 100644
--- a/classes/model.h
+++ b/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
diff --git a/classes/monster.h b/classes/monster.h
index cfde1ca..87d1c12 100644
--- a/classes/monster.h
+++ b/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
diff --git a/classes/player.h b/classes/player.h
index acbce92..63bdf31 100644
--- a/classes/player.h
+++ b/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&);
 
 
diff --git a/classes/view.h b/classes/view.h
index 4d21df2..b929a99 100644
--- a/classes/view.h
+++ b/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
diff --git a/images.qrc b/images.qrc
deleted file mode 100644
index 570fee3..0000000
--- a/images.qrc
+++ /dev/null
@@ -1,6 +0,0 @@
-<RCC>
-    <qresource prefix="/images">
-        <file>images/gameicon.png</file>
-        <file>images/gun.png</file>
-    </qresource>
-</RCC>
diff --git a/realizations/controller.cpp b/realizations/controller.cpp
index 840c3d7..e6d381f 100644
--- a/realizations/controller.cpp
+++ b/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();
 }
diff --git a/realizations/draw/drawMonsters.cpp b/realizations/draw/drawMonsters.cpp
index 37407e4..8e3cc6c 100644
--- a/realizations/draw/drawMonsters.cpp
+++ b/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));
+
     }
 }
diff --git a/realizations/draw/drawScore.cpp b/realizations/draw/drawScore.cpp
index 0c1ef6b..39af728 100644
--- a/realizations/draw/drawScore.cpp
+++ b/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()));
 }
diff --git a/realizations/draw/drawWalls.cpp b/realizations/draw/drawWalls.cpp
index 55bf449..d037f80 100644
--- a/realizations/draw/drawWalls.cpp
+++ b/realizations/draw/drawWalls.cpp
@@ -1,4 +1,5 @@
 #include <classes/view.h>
+#include <QPolygon>
 #include <cmath>
 
 struct Ray {
@@ -84,10 +85,6 @@ void View::drawWalls(QPainter *painter) {
     // add angleLeft and angleRight intersection points
     rays.insert(rays.begin(), Ray({intersectionLeft, 0}));
     rays.push_back(Ray({intersectionRight, angleRightRelative}));
-    // draw horizontal lines
-    QPen pen(QColor(0, 0, 255), 4, Qt::SolidLine, Qt::RoundCap);
-    painter->setRenderHint(QPainter::Antialiasing);
-    painter->setPen(pen);
 
     std::vector<QPointF> bottomPoints(rays.size());
     std::vector<QPointF> topPoints(rays.size());
@@ -119,11 +116,36 @@ void View::drawWalls(QPainter *painter) {
         topPoints[i] = QPointF(rays[i].angle / (2 * player.getViewAngle()) * this->width(),
                                this->height() / 2.0 * (1 + verticalAngle / verticalViewAngle));
     }
+    QPolygon floor;
+    QPolygon ceiling;
+    floor << QPoint(-1, bottomPoints[0].y());
+    ceiling << QPoint(-1, topPoints[0].y());
     for (std::size_t i = 0; i < rays.size(); ++i) {
+        floor << bottomPoints[i].toPoint();
+        ceiling << topPoints[i].toPoint();
         painter->drawLine(bottomPoints[i], topPoints[i]);
     }
+    floor << QPoint(this->width() + 1, bottomPoints.back().y());
+    floor << QPoint(this->width() + 1, this->height() + 1);
+    floor << QPoint(-1, this->height() + 1);
+    ceiling << QPoint(this->width() + 1, topPoints.back().y());
+    ceiling << QPoint(this->width() + 1, -1);
+    ceiling << QPoint(-1, -1);
+
+    painter->setPen(Qt::NoPen);
+    painter->setBrush(QBrush(QColor(97, 16, 97)));
+    painter->drawPolygon(floor);
+    painter->setBrush(QBrush(QColor(0, 191, 255)));
+    painter->drawPolygon(ceiling);
+
+    QPen pen(QColor(0, 0, 0), 2, Qt::SolidLine, Qt::RoundCap);
+    painter->setRenderHint(QPainter::Antialiasing);
+    painter->setPen(pen);
+    painter->setBrush(QBrush(QColor(138, 120, 131)));
     for (std::size_t i = 1; i < rays.size(); ++i) {
-        painter->drawLine(bottomPoints[i - 1], bottomPoints[i]);
-        painter->drawLine(topPoints[i - 1], topPoints[i]);
+        QPolygon wall;
+        wall << bottomPoints[i - 1].toPoint() << bottomPoints[i].toPoint();
+        wall << topPoints[i].toPoint() << topPoints[i - 1].toPoint();
+        painter->drawPolygon(wall);
     }
 }
diff --git a/realizations/gun.cpp b/realizations/gun.cpp
index 7696562..4796888 100644
--- a/realizations/gun.cpp
+++ b/realizations/gun.cpp
@@ -1,31 +1,45 @@
 #include <classes/gun.h>
+#include <QFileInfo>
+#include <QDebug>
+
+Gun::Gun(QObject* parent) : QObject(parent) {
+    player = new QMediaPlayer(this);
+    player->setMedia(QUrl("qrc:/sounds/sounds/simpleGun.mp3"));
 
-Gun::Gun() {
     image = QImage();
     damage = 1;
     frequency = 0;
-    delay = 0;
+    timer = new QTimer(this);
+    connect(timer, &QTimer::timeout, this, &Gun::stopDelay);
 }
 
-Gun::Gun(const Gun& other) {
+Gun::Gun(const Gun& other) : QObject(other.parent()){
+    player = other.player;
+
     image = other.image;
     frequency = other.frequency;
-    delay = 0;
     damage = other.damage;
+    timer = new QTimer(this);
+    connect(timer, &QTimer::timeout, this, &Gun::stopDelay);
 }
 
-Gun::Gun(QImage newImage, int newFrequency, int newDamage) {
+Gun::Gun(QImage newImage, int newFrequency, int newDamage, QObject* parent) :
+    QObject(parent)
+{
+    player = new QMediaPlayer(this);
+    player->setMedia(QUrl("qrc:/sounds/sounds/simpleGun.mp3"));
+
     image = newImage;
     frequency = newFrequency;
     damage = newDamage;
-    delay = 0;
+    timer = new QTimer(this);
+    connect(timer, &QTimer::timeout, this, &Gun::stopDelay);
 }
 
 void Gun::operator=(const Gun& other) {
     image = other.image;
     damage = other.damage;
     frequency = other.frequency;
-    delay = 0;
 }
 
 const QImage& Gun::getImage() const {
@@ -41,10 +55,14 @@ void Gun::setFrequency(int value) {
 }
 
 bool Gun::isReadyToShoot() {
-    if (delay == 0) {
-        delay = frequency;
-        return 1;
+    if (timer->isActive()) {
+        return 0;
     }
-    --delay;
-    return 0;
+    player->play();
+    timer->start(frequency);
+    return 1;
+}
+
+void Gun::stopDelay() {
+    timer->stop();
 }
diff --git a/realizations/main.cpp b/realizations/main.cpp
index 1f34053..2dae8a6 100644
--- a/realizations/main.cpp
+++ b/realizations/main.cpp
@@ -3,16 +3,17 @@
 #include <QApplication>
 #include <QColor>
 #include <cmath>
+#include <QDebug>
 #include <classes/controller.h>
 
 int main(int argc, char *argv[])
 {
     QApplication application(argc, argv);
     std::vector<QPointF> vertices =
-    {QPointF(-40, -40), QPointF(-40, 40), QPointF(80, 40), QPointF(80, -40)};
+    {QPointF(-60, -60), QPointF(-60, 60), QPointF(60, 60), QPointF(60, -60)};
     Map map(vertices, 3);
 
-    Gun gun(QImage(":/images/images/gun.png"), 1, 1);
+    Gun gun(QImage(":/images/images/gun.png"), 1000, 10);
     Player player(QPointF(0, 0), 0, M_PI_4, 2, 0.5, 10, 0, gun);
     Model model(player, Monsters(), map, 0, 10);
     View view(&model);
diff --git a/realizations/model.cpp b/realizations/model.cpp
index 8de944b..ea5ae93 100644
--- a/realizations/model.cpp
+++ b/realizations/model.cpp
@@ -1,21 +1,47 @@
 #include <classes/model.h>
 #include <cmath>
 
-Model::Model() {
+Model::Model(QObject* parent) : QObject(parent) {
+    soundPlayer = new QMediaPlayer(this);
+    QMediaPlaylist* playList = new QMediaPlaylist(this);
+    playList->addMedia(QUrl("qrc:/sounds/sounds/back.mp3"));
+    playList->setPlaybackMode(QMediaPlaylist::Loop);
+    soundPlayer->setPlaylist(playList);
+    soundPlayer->play();
+
     player = Player();
     monsters = Monsters();
     map = Map();
     score = 0;
     gravity = 10;
+
+    injured = new QMediaPlayer(this);
+    injured->setMedia(QUrl("qrc:/sounds/sounds/injured.mp3"));
+    killed = new QMediaPlayer(this);
+    killed->setMedia(QUrl("qrc:/sounds/sounds/killed.mp3"));
 }
 
 Model::Model
-(Player newPlayer, Monsters newMonsters, Map newMap, int newScore, double newGravity) {
+(Player newPlayer, Monsters newMonsters, Map newMap, int newScore, double newGravity, QObject* parent) :
+    QObject(parent)
+{
+    soundPlayer = new QMediaPlayer(this);
+    QMediaPlaylist* playList = new QMediaPlaylist(this);
+    playList->addMedia(QUrl("qrc:/sounds/sounds/back.mp3"));
+    playList->setPlaybackMode(QMediaPlaylist::Loop);
+    soundPlayer->setPlaylist(playList);
+    soundPlayer->play();
+
     player = newPlayer;
     monsters = newMonsters;
     map = newMap;
     score = newScore;
     gravity = newGravity;
+
+    injured = new QMediaPlayer(this);
+    injured->setMedia(QUrl("qrc:/sounds/sounds/injured.mp3"));
+    killed = new QMediaPlayer(this);
+    killed->setMedia(QUrl("qrc:/sounds/sounds/killed.mp3"));
 }
 
 Player& Model::getPlayer() {
@@ -69,13 +95,21 @@ bool Model::isPlayerDied() {
     const QPointF& point = player.getPosition();
     for (std::size_t i = 0; i < arrayMonsters.size(); ++i) {
         const QPointF& monsterPos = arrayMonsters[i].getPosition();
-        double length =
-                sqrt((point.x() - monsterPos.x())*(point.x() - monsterPos.x())
-                     + (point.y() - monsterPos.y())*(point.y() - monsterPos.y()));
-        if (length < player.getHitboxRadius() + arrayMonsters[i].getHitboxRadius()
-                && arrayMonsters[i].getHeight() >= player.getJumpHeight()) {
+        double dx = monsterPos.x() - point.x();
+        double dy = monsterPos.y() - point.y();
+        double dz = arrayMonsters[i].getHeight() - player.getHeight() - player.getJumpHeight();
+        double length = sqrt(dx * dx + dy * dy + dz * dz);
+        if (length < player.getHitboxRadius() + arrayMonsters[i].getHitboxRadius()) {
             return 1;
         }
     }
     return 0;
 }
+
+void Model::killMonster() {
+    killed->play();
+}
+
+void Model::injureMonster() {
+    injured->play();
+}
diff --git a/realizations/monster.cpp b/realizations/monster.cpp
index 14a3be1..3b55bde 100644
--- a/realizations/monster.cpp
+++ b/realizations/monster.cpp
@@ -46,18 +46,27 @@ void Monster::setPosition(const QPointF& value) {
     position = value;
 }
 
+void Monster::setHeight(double newHeight) {
+    height = newHeight;
+}
+
 double Monster::getHitboxRadius() const {
     return hitboxRadius;
 }
 
 void Monster::moveToPlayer(const Player& player, double interval) {
     const QPointF& point = player.getPosition();
-    double length = sqrt((point.x() - position.x())*(point.x() - position.x())
-                         + (point.y() - position.y())*(point.y() - position.y()));
+    double dx = position.x() - point.x();
+    double dy = position.y() - point.y();
+    double dz = this->height - player.getHeight() - player.getJumpHeight();
+    double length = sqrt(dx * dx + dy * dy + dz * dz);
+
     double moveLength = speed * interval;
-    double newX = position.x() + (moveLength / length) * (point.x() - position.x());
-    double newY = position.y() + (moveLength / length) * (point.y() - position.y());
+    double newX = position.x() - (moveLength / length) * dx;
+    double newY = position.y() - (moveLength / length) * dy;
+    double newZ = this->height - (moveLength / length) * dz;
     position = QPointF(newX, newY);
+    this->height = newZ;
 }
 
 bool Monster::isDead() const {
@@ -74,6 +83,7 @@ void Monster::hit(int damage) {
     }
     QImage newImage = image;
     QPainter painter(&newImage);
-    painter.fillRect(newImage.rect(), QColor(255, 0, 0, 35));
+    double intensity = damage * 1.0 / health / 0.1;
+    painter.fillRect(newImage.rect(), QColor(255, 0, 0, 20 * intensity));
     image = newImage;
 }
diff --git a/realizations/player.cpp b/realizations/player.cpp
index b8ca8f3..fef5e9a 100644
--- a/realizations/player.cpp
+++ b/realizations/player.cpp
@@ -90,7 +90,7 @@ void Player::setJumpHeight(double value) {
     jumpHeight = value;
 }
 
-const Gun& Player::getGun() const {
+Gun& Player::getGun() {
     return gun;
 }
 
diff --git a/realizations/shoot.cpp b/realizations/shoot.cpp
index 5b0f99d..a321a96 100644
--- a/realizations/shoot.cpp
+++ b/realizations/shoot.cpp
@@ -7,9 +7,12 @@ void Controller::leftClicked(QMouseEvent *event) {
     Q_UNUSED(event);
     std::vector<Monster>& monsters = model->getMonsters().getMonsters();
 
-    const Player& player = model->getPlayer();
+    Player& player = model->getPlayer();
     const QPointF& position = player.getPosition();
 
+    if (!player.getGun().isReadyToShoot()) {
+        return;
+    }
     std::sort(monsters.begin(), monsters.end(), [position](const Monster& first, const Monster& second) {
         // absolute value
         // use the coordinate transformation formula
@@ -49,6 +52,9 @@ void Controller::leftClicked(QMouseEvent *event) {
             monsters[i].hit(player.getGun().getDamage());
             if (monsters[i].isDead()) {
                 model->getMonsters().removeMonster(i);
+                model->killMonster();
+            } else {
+                model->injureMonster();
             }
             return;
         }
diff --git a/realizations/view.cpp b/realizations/view.cpp
index e6cabef..633b41f 100644
--- a/realizations/view.cpp
+++ b/realizations/view.cpp
@@ -11,10 +11,16 @@ View::View(Model *newModel, QWidget *parent)
 //    QPoint center = this->rect().center();
 //    QPoint globalCenter = this->mapToGlobal(center);
 //    QCursor::setPos(globalCenter);
-
     this->resize(1200, 800);
     setMouseTracking(true);
     this->setCursor(Qt::BlankCursor);
+
+    score = new QLabel(this);
+    score->resize(this->width() / 4, this->height() / 8);
+    score->setAlignment(Qt::AlignRight);
+    score->setStyleSheet
+            ("QLabel { font-size: 30pt; background-color : transparent; color : white;}");
+    score->move(QPoint(this->width() * 3 / 4 - 5, 0));
 }
 
 View::~View() {
@@ -41,6 +47,9 @@ void View::mousePressEvent(QMouseEvent *event) {
 }
 
 void View::keyReleaseEvent(QKeyEvent *event) {
+    if (event->key() == Qt::Key_Shift) {
+        emit shiftReleased();
+    }
     if (event->key() == Qt::Key_A) {
         emit keyAReleased();
     }
@@ -56,6 +65,9 @@ void View::keyReleaseEvent(QKeyEvent *event) {
 }
 
 void View::keyPressEvent(QKeyEvent *event) {
+    if (event->key() == Qt::Key_Shift) {
+        emit shiftClicked();
+    }
     if (event->key() == Qt::Key_Space) {
         emit spaceClicked(event);
     }
diff --git a/res.qrc b/res.qrc
new file mode 100644
index 0000000..b23a62a
--- /dev/null
+++ b/res.qrc
@@ -0,0 +1,12 @@
+<RCC>
+    <qresource prefix="/images">
+        <file>images/gameicon.png</file>
+        <file>images/gun.png</file>
+    </qresource>
+    <qresource prefix="/sounds">
+        <file>sounds/simpleGun.mp3</file>
+        <file>sounds/back.mp3</file>
+        <file>sounds/killed.mp3</file>
+        <file>sounds/injured.mp3</file>
+    </qresource>
+</RCC>
diff --git a/smile b/smile
deleted file mode 100644
index 53c6e0d..0000000
Binary files a/smile and /dev/null differ
diff --git a/sounds/back.mp3 b/sounds/back.mp3
new file mode 100644
index 0000000..7324f54
Binary files /dev/null and b/sounds/back.mp3 differ
diff --git a/sounds/injured.mp3 b/sounds/injured.mp3
new file mode 100644
index 0000000..276e28a
Binary files /dev/null and b/sounds/injured.mp3 differ
diff --git a/sounds/killed.mp3 b/sounds/killed.mp3
new file mode 100644
index 0000000..dff3a02
Binary files /dev/null and b/sounds/killed.mp3 differ
diff --git a/sounds/simpleGun.mp3 b/sounds/simpleGun.mp3
new file mode 100644
index 0000000..769db2b
Binary files /dev/null and b/sounds/simpleGun.mp3 differ