kapman/game.h

   1 /*
   2  * Copyright 2007-2008 Thomas Gallinari <tg8187@yahoo.fr>
   3  * Copyright 2007-2008 Alexandre Galinier <alex.galinier@hotmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifndef GAME_H
  20 #define GAME_H
  21
  22 #include "maze.h"
  23 #include "kapman.h"
  24 #include "ghost.h"
  25 #include "bonus.h"
  26
  27 #include <QPointF>
  28 #include <QTimer>
  29 #include <QKeyEvent>
  30 #include <KGameDifficulty>
  31 #include <Phonon/MediaObject>
  32
  33 /**
  34  * @brief This class manages the game main loop : it regularly checks the key press events, computes the character moves and updates their coordinates.
  35  */
  36 class Game : public QObject {
  37
  38         Q_OBJECT
  39
  40         public :
  41                 /** Ratio which modify the timers function of the difficulty */
  42                 static qreal s_durationRatio;
  43
  44                 /** Timer duration for prey state in medium difficulty */
  45                 static int s_preyStateDuration;
  46
  47                 /** Timer duration for bonus apparition in medium difficulty */
  48                 static int s_bonusDuration;
  49
  50         private :
  51
  52                 /** Number of FPS */
  53                 static const int FPS;
  54
  55                 /** The game different states : RUNNING, PAUSED_LOCKED, PAUSED_UNLOCKED */
  56                 enum State {
  57                         RUNNING,                        // Game running
  58                         PAUSED_LOCKED,          // Game paused and user is not allowed to unpause
  59                         PAUSED_UNLOCKED         // Game paused and user is allowed to unpause
  60                 };
  61                 /** A flag for the State enum */
  62                 Q_DECLARE_FLAGS(GameStates, State)
  63
  64                 /** The game state */
  65                 State m_state;
  66
  67                 /** The Game main timer */
  68                 QTimer* m_timer;
  69
  70                 /** The Bonus timer to make it disappear if it is not eaten after a given time */
  71                 QTimer* m_bonusTimer;
  72
  73                 /** Timer to manage the prey state of the ghosts */
  74                 QTimer* m_preyTimer;
  75
  76                 /** The Maze */
  77                 Maze* m_maze;
  78
  79                 /** The main Character */
  80                 Kapman* m_kapman;
  81
  82                 /** The Ghosts */
  83                 QList<Ghost*> m_ghosts;
  84
  85                 /** The Bonus instance */
  86                 Bonus *m_bonus;
  87
  88                 /** A flag to know if the player has cheated during the game */
  89                 bool m_isCheater;
  90
  91                 /** The remaining number of lives */
  92                 int m_lives;
  93
  94                 /** The won points */
  95                 long m_points;
  96
  97                 /** The current game level */
  98                 int m_level;
  99
 100                 /** The number of eaten ghosts since the beginning of the current level */
 101                 int m_nbEatenGhosts;
 102
 103                 /** A first MediaObject to play sounds */
 104                 Phonon::MediaObject* m_media1;
 105
 106                 /** A second MediaObject to play sounds */
 107                 Phonon::MediaObject* m_media2;
 108
 109         public:
 110
 111                 /** The different types of information about the game */
 112                 enum Information { NoInfo = 0,
 113                                    ScoreInfo = 1,       // Score
 114                                    LivesInfo = 2,       // Number of remaining lives
 115                                    LevelInfo = 4,       // Current level
 116                                    AllInfo = ScoreInfo | LivesInfo | LevelInfo };
 117                 /** A flag for the Information enum */
 118                 Q_DECLARE_FLAGS(InformationTypes, Information)
 119
 120                 /**
 121                  * Creates a new Game instance.
 122                  * @param p_difficulty the KGameDifficulty level of the Game
 123                  */
 124                 Game(KGameDifficulty::standardLevel p_difficulty = KGameDifficulty::Medium);
 125
 126                 /**
 127                  * Deletes the Game instance.
 128                  */
 129                 ~Game();
 130
 131                 /**
 132                  * Starts the Game.
 133                  */
 134                 void start();
 135
 136                 /**
 137                  * Pauses the Game.
 138                  * @param p_locked if true the player will be unable to unset the pause.
 139                  */
 140                 void pause(bool p_locked = false);
 141
 142                 /**
 143                  * Pauses / unpauses the game.
 144                  * @param p_locked if true the player will be unable to unset the pause.
 145                  */
 146                 void switchPause(bool p_locked = false);
 147
 148                 /**
 149                  * @return the Maze instance
 150                  */
 151                 Maze* getMaze() const;
 152
 153                 /**
 154                  * @return the Kapman model
 155                  */
 156                 Kapman* getKapman() const;
 157
 158                 /**
 159                  * @return the Ghost models
 160                  */
 161                 QList<Ghost*> getGhosts () const;
 162
 163                 /**
 164                  * @return the Bonus instance
 165                  */
 166                 Bonus* getBonus();
 167
 168                 /**
 169                  * @return the main timer
 170                  */
 171                 QTimer* getTimer() const;
 172
 173                 /**
 174                  * @return true if the Game is paused, false otherwise
 175                  */
 176                 bool isPaused() const;
 177
 178                 /**
 179                  * @return true if the player has cheated during the game, false otherwise
 180                  */
 181                 bool isCheater() const;
 182
 183                 /**
 184                  * @return the score
 185                  */
 186                 int getScore () const;
 187
 188                 /**
 189                  * @return the number of remaining lives
 190                  */
 191                 int getLives() const;
 192
 193                 /**
 194                  * @return the current level
 195                  */
 196                 int getLevel() const;
 197
 198                 /**
 199                  * Sets the level to the given number.
 200                  * @param p_level the new level
 201                  */
 202                 void setLevel(int p_level);
 203
 204                 /**
 205                  * Create the new Bonus
 206                  * @param p_position the Bonus position
 207                  */
 208                 void createBonus(QPointF p_position);
 209
 210                 /**
 211                  * Create the new Kapman
 212                  * @param p_position the Kapman position
 213                  */
 214                 void createKapman(QPointF p_position);
 215
 216                 /**
 217                  * Create the new Ghost
 218                  * @param p_position the Ghost position
 219                  * @param p_imageId the image of the Ghost
 220                  */
 221                 void createGhost(QPointF p_position, const QString & p_imageId);
 222
 223                 /**
 224                  * Initializes a Maze
 225                  * @param p_nbRows the number of rows
 226                  * @param p_nbColumns the number of columns
 227                  */
 228                 void initMaze(const int p_nbRows, const int p_nbColumns);
 229
 230                 /**
 231                  * Initializes a Ghost
 232                  */
 233                 void initGhost();
 234
 235                 /**
 236                  * Initializes a Kapman
 237                  */
 238                 void initKapman();
 239
 240                 /**
 241                  * Enables / disables the sounds.
 242                  * @param p_enabled if true the sounds will be enabled, otherwise they will be disabled
 243                  */
 244                 void setSoundsEnabled(bool p_enabled);
 245
 246         private:
 247
 248                 /**
 249                  * Initializes the character coordinates.
 250                  */
 251                 void initCharactersPosition();
 252
 253                 /**
 254                  * Calculates and update the ghosts speed depending on the ghosts speed
 255                  * The value is in Ghost::s_speed
 256                  */
 257                 void setTimersDuration();
 258
 259                 /**
 260                  * Plays the given sound.
 261                  * @param p_sound the path to the sound to play
 262                  */
 263                 void playSound(const QString& p_sound);
 264
 265         public slots:
 266
 267                 /**
 268                  * Manages the key press events.
 269                  * @param p_event the key press event
 270                  */
 271                 void keyPressEvent(QKeyEvent* p_event);
 272
 273                 /**
 274                  * Resumes the Game after the Kapman death.
 275                  */
 276                 void resumeAfterKapmanDeath();
 277
 278         private slots:
 279
 280                 /**
 281                  * Updates the Game data.
 282                  */
 283                 void update();
 284
 285                 /**
 286                  * Manages the loss of a life.
 287                  */
 288                 void kapmanDeath();
 289
 290                 /**
 291                  * Manages the death of a Ghost.
 292                  */
 293                 void ghostDeath(Ghost* p_ghost);
 294
 295                 /**
 296                  * Increases the score considering the eaten Element.
 297                  * @param p_element the eaten Element
 298                  */
 299                 void winPoints(Element* p_element);
 300
 301                 /**
 302                  * Starts the next level.
 303                  */
 304                 void nextLevel();
 305
 306                 /**
 307                  * Hides the Bonus.
 308                  */
 309                 void hideBonus();
 310
 311                 /**
 312                  * Ends the Ghosts prey state.
 313                  */
 314                 void endPreyState();
 315
 316         signals:
 317
 318                 /**
 319                  * Emitted when the Game is started.
 320                  */
 321                 void gameStarted();
 322
 323                 /**
 324                  * Emitted when the Game is over.
 325                  * @param p_unused this parameter must always be true !
 326                  */
 327                 void gameOver(const bool p_unused);
 328
 329                 /**
 330                  * Emitted when a level begins, if level up or if a life has been lost.
 331                  * @param p_newLevel true if a new level is beginning, false otherwise
 332                  */
 333                 void levelStarted(const bool p_newLevel);
 334
 335                 /**
 336                  * Emitted when the pause state has changed.
 337                  * @param p_pause true if the Game is paused, false otherwise
 338                  * @param p_fromUser true if the Game has been paused due to an action the player has done, false otherwise
 339                  */
 340                 void pauseChanged(const bool p_pause, const bool p_fromUser);
 341
 342                 /**
 343                  * Emitted when an Element has been eaten.
 344                  * @param p_x the Element x-coordinate
 345                  * @param p_y the Element y-coordinate
 346                  */
 347                 void elementEaten(const qreal p_x, const qreal p_y);
 348
 349                 /**
 350                  * Emitted when the Bonus has to be displayed.
 351                  */
 352                 void bonusOn();
 353
 354                 /**
 355                  * Emitted when the Bonus has to disappear.
 356                  */
 357                 void bonusOff();
 358
 359                 /**
 360                  * Emitted when the Game data (score, level, lives) have changed.
 361                  * @param p_infoType the type of data that have changed
 362                  */
 363                 void dataChanged(Game::InformationTypes p_infoType);
 364
 365                 /**
 366                  * Emitted when a ghost or a bonus is eaten. It tells to the scene to
 367                  * display the number of won points
 368                  * @param p_wonPoints the value to display
 369                  * @param p_xPos the x position of the label
 370                  * @param p_yPos the y position of the label
 371                  */
 372                 void pointsToDisplay(long p_wonPoints, qreal p_xPos, qreal p_yPos);
 373 };
 374
 375 #endif
 376