GameDev on Qt - Tutorial 3. Destroying opponents

GameDev, Enemy, Qt

In two previous articles, where we taught the hero to track the cursor and shoot towards the goal , it's time to add the targets to the gameand start  to destroy them. The destruction of the target will occur when the targets have completed life. In this case each of the target will be a random number of points of life and every bullet will cause a random amount of damage. Also, each of the target will be life bar, which will decrease on damage.

Destruction based on CallBack function

To implement this algorithm, create a Target target class, and add the ability to call CallBack function in Bullet class, which will be implemented in the class of the main application window and will cause damage to targets.

target.h

The header must declare a function that will do damage to the target. And also declare two variables that will be responsible for the health targets. The first variable - this will be the current health, and the second variable - this will be the maximum health. When health is over, there is the destruction of the target.

#ifndef TARGET_H
#define TARGET_H

#include <QObject>
#include <QGraphicsItem>
#include <QPainter>

class Target : public QObject, public QGraphicsItem
{
    Q_OBJECT
public:
    explicit Target(QObject *parent = 0);
    ~Target();
    /* Application function damage, damage to the value passed as argument to the function
     * */
    void hit(int damage);

signals:

public slots:

protected:
    QRectF boundingRect() const;
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);

private:
    int health;         // Current stock of the target health
    int maxHealth;      // The maximum stock pf the target health
};

#endif // TARGET_H

target.cpp

The class constructor installs the health parameters. The damage to the application function decreases health passed in the function value. And as soon as the health drops to zero or below, the target is destroyed.

#include "target.h"

static int randomBetween(int low, int high)
{
    return (qrand() % ((high + 1) - low) + low);
}

Target::Target(QObject *parent) :
    QObject(parent), QGraphicsItem()
{
    health = randomBetween(1,15);   // Set random value health
    maxHealth = health;             // Set a maximum health equals to the current health
}

Target::~Target()
{

}

QRectF Target::boundingRect() const
{
    return QRectF(-20,-20,40,40);  
}

void Target::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    /* Draw green square
     * */
    painter->setPen(Qt::black);
    painter->setBrush(Qt::green);
    painter->drawRect(-20,-10,40,30);

    /* We draw a strip of life commensurate with 
     * respect to the current health of your maximum health
     * */
    painter->setPen(Qt::NoPen);
    painter->setBrush(Qt::red);
    painter->drawRect(-20,-20, (int) 40*health/maxHealth,3);

    Q_UNUSED(option);
    Q_UNUSED(widget);
}

void Target::hit(int damage)
{
    health -= damage;   // Reduce the target's health
    this->update(QRectF(-20,-20,40,40));    // Redraw target
    // If health is over, it will initiate the death of the target
    if(health <= 0) this->deleteLater();
}

bullet.h

The bullet from the last class the lesson is necessary to add classifieds signature CallBack function, and the function of the installation CallBack function.

public:
    // Setting CallBack function
    void setCallbackFunc(void (*func) (QGraphicsItem * item));

private:
    // CallBack Function
    void (*callbackFunc)(QGraphicsItem * item);

bullet.cpp

It is also necessary to modify slotTimerBullet function, which will be to search for all objects that come across a bullet. If the bullet came across the object, then we destroy the bullet and call the CallBack function which will cause damage to the target when the bullet came across a target.

Also we realize setCallbackFunc function, which will install a function pointer in the CallBack function .

void Bullet::slotTimerBullet()
{
    setPos(mapToParent(0, -10));

    /* Checks for whether the bullet came across any element on the graphic scene. 
     * To do this, we define a small area in front of the bullet, which will search for items
     * */
    QList<QGraphicsItem *> foundItems = scene()->items(QPolygonF()
                                                           << mapToScene(0, 0)
                                                           << mapToScene(-1, -1)
                                                           << mapToScene(1, -1));
    /* Then we check all the elements. 
     * One of them will be the bullet itself and the hero - 
     * do not do anything with them. A call the CallBack feature
     * */
    foreach (QGraphicsItem *item, foundItems) {
        if (item == this || item == hero)
            continue;
        callbackFunc(item);     
        this->deleteLater();    
    }

    if(this->x() < 0){
        this->deleteLater();
    }
    if(this->x() > 500){
        this->deleteLater();
    }

    if(this->y() < 0){
        this->deleteLater();
    }
    if(this->y() > 500){
        this->deleteLater();
    }
}

void Bullet::setCallbackFunc(void (*func)(QGraphicsItem *))
{
    callbackFunc = func;
}

widget.h

In the header of the main window class you need to add a timer to create an ad targets, as well as slots for processing this timer, which will create and target. Also we declare a static list of targets, which we will check to hit a bullet. A hit test will produce in the CallBack slotHitTarget function. The argument will be transferred to a graphic object, which ran the bullet.

private:
    QTimer *timerTarget;        // Timer for creating targets
    static QList<QGraphicsItem *> targets; 

    static void slotHitTarget(QGraphicsItem *item); 

private slots:
    void slotCreateTarget();

widget.cpp

#include "widget.h"
#include "ui_widget.h"

static int randomBetween(int low, int high)
{
    return (qrand() % ((high + 1) - low) + low);
}

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    /* Source code from previous articles
     * */

    timerTarget = new QTimer();
    connect(timerTarget, &QTimer::timeout, this, &Widget::slotCreateTarget);
    timerTarget->start(1500);
}

Widget::~Widget()
{
    delete ui;
}

void Widget::slotBullet(QPointF start, QPointF end)
{
    /* Source code from previous articles
     * */
}

void Widget::slotCreateTarget()
{
    Target *target = new Target();  // Create target
    scene->addItem(target);         // Set target into the scene with random position
    target->setPos(qrand() % ((500 - 40 + 1) - 40) + 40,
                  qrand() % ((500 - 40 + 1) - 40) + 40);
    target->setZValue(-1);          
    targets.append(target);        
}

void Widget::slotHitTarget(QGraphicsItem *item)
{
    /* If we get signal from Bullet
     * Loop through the full list of objectives and causes occasional damage
     * */
    foreach (QGraphicsItem *targ, targets) {
        if(targ == item){
            // Cast object from the list in the Target class
            Target *t = qgraphicsitem_cast <Target *> (targ);
            t->hit(randomBetween(1,3)); // deal damage
        }
    }

}

QList<QGraphicsItem *> Widget::targets; 

Result

As a result, you on the playing field will be randomly placed target with a random size health and issued the protagonist bullets will gradually destroy them.

Video