kgrrunner.h

Go to the documentation of this file.

/****************************************************************************
 *    Copyright 2009  Ian Wadham <iandw.au@gmail.com>                       *
 *                                                                          *
 *    This program is free software; you can redistribute it and/or         *
 *    modify it under the terms of the GNU General Public License as        *
 *    published by the Free Software Foundation; either version 2 of        *
 *    the License, or (at your option) any later version.                   *
 *                                                                          *
 *    This program is distributed in the hope that it will be useful,       *
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *    GNU General Public License for more details.                          *
 *                                                                          *
 *    You should have received a copy of the GNU General Public License     *
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 ****************************************************************************/

#ifndef KGRRUNNER_H
#define KGRRUNNER_H

#include "kgrglobals.h"

#include <QObject>
#include <QTime> // IDW

class KGrLevelPlayer;
class KGrLevelGrid;
class KGrRuleBook;

enum  Situation {NotTimeYet, CaughtInBrick, MidCell, EndCell};

class KGrRunner : public QObject
{
    Q_OBJECT
public:
    KGrRunner (KGrLevelPlayer * pLevelPlayer, KGrLevelGrid * pGrid,
               int i, int j, const int pSpriteId,
               KGrRuleBook  * pRules, const int startDelay);
    virtual ~KGrRunner();

    inline int whereAreYou (int & x, int & y) {
                            x = gridX; y = gridY; return pointsPerCell; }

signals:
    void incScore          (const int n);

    void startAnimation    (const int spriteId, const bool repeating,
                            const int i, const int j, const int time,
                            const Direction dirn, const AnimationType type);

protected:
    KGrLevelPlayer * levelPlayer;
    KGrLevelGrid *   grid;
    KGrRuleBook *    rules;

    int              spriteId;

    int              gridI;
    int              gridJ;
    int              gridX;
    int              gridY;
    int              deltaX;
    int              deltaY;

    int              pointCtr;
    int              pointsPerCell;
    bool             turnAnywhere;

    void             getRules();

    Situation        situation (const int scaledTime);
    char             nextCell();
    bool             setNextMovement (const char spriteType,
                                      const char cellType,
                                      Direction & dir,
                                      AnimationType & anim, int & interval);

    bool             falling;
    Direction        currDirection;
    AnimationType    currAnimation;

    int              runTime;       // Time interval for hero/enemy running.
    int              fallTime;      // Time interval for hero/enemy falling.
    int              enemyFallTime; // Time interval for enemy falling.
    int              trapTime;      // Time interval for which an enemy can
                    // stay trapped in a brick.

    int              interval;      // The runner's current time interval.
    int              timeLeft;      // Time till the runner's next action.

    bool             leftRightSearch;   // KGoldrunner-rules enemy search-mode.

    QTime            t; // IDW
};


class KGrHero : public KGrRunner
{
    Q_OBJECT
public:
    KGrHero (KGrLevelPlayer * pLevelPlayer, KGrLevelGrid * pGrid,
                int i, int j, int pSpriteId, KGrRuleBook  * pRules);
    ~KGrHero();

    HeroStatus       run (const int scaledTime);

    bool             dig (const Direction dirn, int & digI, int & digJ);

    inline void      setNuggets (const int nGold) { nuggets = nGold; }

    void             showState();

signals:
    void             soundSignal (const int n, const bool onOff = true);
private:
    int              nuggets;       // Number of gold pieces remaining.
};


class KGrEnemy :     public KGrRunner
{
    Q_OBJECT
public:
    KGrEnemy (KGrLevelPlayer * pLevelPlayer, KGrLevelGrid * pGrid,
                 int i, int j, int pSpriteId, KGrRuleBook  * pRules);
    ~KGrEnemy();

    void             run (const int scaledTime);

    inline Direction direction() { return (currDirection); }

    inline int       getPrevInCell()  { return (prevInCell); }

    inline void      setPrevInCell (const int prevEnemy) {
                                    prevInCell = prevEnemy; }

    inline bool      isFalling() { return falling; }

    void             showState();

private:
    char             rulesType;     // Rules type and enemy search method.

    int              nuggets;       // Number of gold pieces an enemy holds.
    int              birthI;        // Enemy's starting position (used in
    int              birthJ;        // KGoldrunner rules for re-birth).
    int              prevInCell;    // ID of previous enemy in cell or -1.

    void             dropGold();
    void             checkForGold();
    void             dieAndReappear();

    void             reserveCell (const int i, const int j);
    void             releaseCell (const int i, const int j);
};

#endif // KGRRUNNER_H