~mzanetti/machines-vs-machines/qmake-based

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifndef ENGINE_H
#define ENGINE_H

#include <QObject>
#include <QtQml>

class LevelPacks;
class LevelPack;
class Board;
class Enemies;
class EnemyFactory;
class TowerFactory;
class Wave;
class Tower;

class QTimer;

class Engine : public QObject
{
    Q_OBJECT
    Q_ENUMS(PlayStatus)

    Q_PROPERTY(LevelPacks* levelPacks READ levelPacks CONSTANT)
    Q_PROPERTY(LevelPack* levelPack READ levelPack NOTIFY levelPackChanged)
    Q_PROPERTY(int levelCount READ levelCount NOTIFY levelCountChanged)
    Q_PROPERTY(int points READ points NOTIFY pointsChanged)
    Q_PROPERTY(int lives READ lives NOTIFY livesChanged)
    Q_PROPERTY(int level READ level NOTIFY levelChanged)
    Q_PROPERTY(PlayStatus playStatus READ playStatus NOTIFY playStatusChanged)
    Q_PROPERTY(Board* board READ board CONSTANT)
    Q_PROPERTY(int waves READ waves NOTIFY wavesChanged)
    Q_PROPERTY(int currentWave READ currentWave NOTIFY currentWaveChanged)
    Q_PROPERTY(int money READ money NOTIFY moneyChanged)
    Q_PROPERTY(int gameSpeed READ gameSpeed WRITE setGameSpeed NOTIFY gameSpeedChanged)
    Q_PROPERTY(TowerFactory* availableTowers READ towerFactory NOTIFY availableTowersChanged)

public:
    enum PlayStatus {
        PlayStatusNotStarted,
        PlayStatusRunning,
        PlayStatusLost,
        PlayStatusWon,
        PlayStatusPaused
    };
    explicit Engine(QObject *parent = 0);
    ~Engine();

public:
    LevelPacks* levelPacks();

    LevelPack* levelPack() const;

    int levelCount() const;

    int points() const;

    int lives() const;
    int level() const;
    PlayStatus playStatus() const;

    int money() const;

    Board* board() const;

    int waves() const;
    int currentWave() const;

    int gameSpeed() const;
    void setGameSpeed(int gameSpeed);
    qreal stepSize() const;

    TowerFactory* towerFactory() const;
    EnemyFactory* enemyFactory() const;

public slots:
    void loadLevelPack(const QString &levelPackId);
    void unlockTower(int availableTowersIndex);
    void startNewGame(int level);
    void pauseGame();
    void resumeGame();
    void stopGame();
    void addTower(int fieldIndex, int towerTemplateId);
    void upgradeTower(Tower *tower);

signals:
    void levelPackChanged();
    void levelCountChanged();
    void pointsChanged();
    void livesChanged();
    void levelChanged();
    void playStatusChanged();
    void wavesChanged();
    void currentWaveChanged();

    void moneyChanged();
    void tick();
    void gameSpeedChanged();
    void availableTowersChanged();

private slots:
    void slotTick();

    void nextWave();
    void nextEnemy();
    void liveLost();

    void enemyCountChanged();
    void enemyDied();

private:
    QString levelFile(int level);
    bool loadLevelFile(int level);
    void loadEnemies();
    void loadTowers();

    void savePoints();
    void loadPoints();

private:
    LevelPacks *m_levelPacks;
    LevelPack *m_levelPack;
    int m_points;
    int m_lives;
    int m_levelCount;
    int m_level;
    PlayStatus m_playStatus;

    Board *m_board;
    EnemyFactory *m_enemyFactory;
    TowerFactory *m_towerFactory;
    QList<Wave*> m_waves;
    int m_currentWave;

    int m_money;
    int m_rewardPoints;

    int m_ticksPerSecond;
    QTimer *m_timer;
    int m_gameSpeed;
    int m_ticksToNextWave;
    int m_ticksToNextEnemy;
};

#endif // ENGINE_H