kgrlevelplayer.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 KGRLEVELPLAYER_H
#define KGRLEVELPLAYER_H

#include "kgrglobals.h"

#include <QObject>
#include <QList>
#include <QVarLengthArray>

#include <QTime> // IDW testing

class KGrTimer;
class KGrLevelGrid;
class KGrRuleBook;
class KGrView;
class KGrHero;
class KGrEnemy;

class KRandomSequence;

class KGrLevelPlayer : public QObject
{
    Q_OBJECT
public:
    KGrLevelPlayer             (QObject * parent, KRandomSequence * pRandomGen);
    ~KGrLevelPlayer();

    void init                   (KGrView *            view,
                                 KGrRecording *       pRecording,
                                 const bool           pPlayback,
                                 const bool           gameFrozen);

    void prepareToPlay          ();

    void pause                  (bool stop);

    void interruptPlayback();

    void killHero();

    void setControlMode  (const int mode);

    void setHoldKeyOption  (const int option);

    void setTimeScale    (const int timeScale);

    void setTarget              (int pointerI, int pointerJ);

    void setDirectionByKey      (const Direction dirn, const bool pressed);

    Direction getDirection      (int heroI, int heroJ);

    Direction getEnemyDirection (int enemyI, int enemyJ, bool leftRightSearch);

    int  runnerGotGold          (const int  spriteId, const int i, const int j,
                                 const bool hasGold, const bool lost = false);

    bool heroCaught             (const int heroX, const int heroY);

    KGrEnemy * standOnEnemy     (const int spriteId, const int x, const int y);

    bool bumpingFriend          (const int spriteId, const Direction dirn,
                                 const int gridI,    const int gridJ);

    void unstackEnemy           (const int spriteId,
                                 const int gridI, const int gridJ,
                                 const int prevEnemy);
    void enemyReappear          (int & gridI, int & gridJ);

    uchar randomByte            (const uchar limit);

    void dbgControl             (int code); // Authors' debugging aids.

signals:
    void endLevel       (const int result);
    void getMousePos    (int & i, int & j);
    void setMousePos    (const int i, const int j);

    void animation      (bool missed);

    void paintCell      (int i, int j, char tileType);

    int  makeSprite     (char spriteType, int i, int j);

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

    void deleteSprite   (const int spriteId);
    void gotGold        (const int  spriteId, const int i, const int j,
                         const bool hasGold, const bool lost);
    void interruptDemo  ();

private slots:
    void tick           (bool missed, int scaledTime);

    void doDig          (int button);   // Dig using mouse-buttons.

private:
    QObject *            game;
    KRandomSequence *    randomGen;
    KGrLevelGrid *       grid;
    KGrRuleBook *        rules;
    KGrHero *            hero;
    int                  heroId;
    QList<KGrEnemy *>    enemies;

    int                  controlMode;
    int                  holdKeyOption;
    int                  levelWidth;
    int                  levelHeight;

    int                  nuggets;

    enum                 PlayState {NotReady, Ready, Playing};
    PlayState            playState;

    KGrRecording *       recording;
    bool                 playback;
    int                  recIndex;
    int                  recCount;
    int                  randIndex;

    int                  targetI;   // Where the mouse is pointing.
    int                  targetJ;

    Direction setDirectionByDelta (const int di, const int dj,
                                   const int heroI, const int heroJ);
    Direction            direction; // Direction for the hero to take.
    Direction            newDirection;  // Next direction for the hero to take.
    KGrTimer *           timer;     // The time-standard for the level.

    void startDigging (Direction diggingDirection);
    void processDugBricks (const int scaledTime);

    int  digCycleTime;          // Milliseconds per dig-timing cycle.
    int  digCycleCount;         // Number of cycles hole is fully open.
    int  digOpeningCycles;      // Cycles for brick-opening animation.
    int  digClosingCycles;      // Cycles for brick-closing animation.
    int  digKillingTime;        // Cycle when enemy/hero gets killed.

    int                  dX;        // X motion for KEYBOARD + HOLD_KEY.
    int                  dY;        // Y motion for KEYBOARD + HOLD_KEY.

    typedef struct {
        int  id;
        int  cycleTimeLeft;
        int  digI;
        int  digJ;
        int  countdown;
        int  startTime; // IDW testing
    } DugBrick;

    QList <DugBrick *> dugBricks;

    int          reappearIndex;
    QVector<int> reappearPos;
    void         makeReappearanceSequence();
    bool         doRecordedMove();
    void         recordInitialWaitTime (const int ms);
    void         record (const int bytes, const int n1, const int n2 = 0);

/******************************************************************************/
/**************************  AUTHORS' DEBUGGING AIDS **************************/
/******************************************************************************/

    static int playerCount;

    void bugFix();      // Turn a bug fix on/off dynamically.
    void startLogging();    // Turn logging on/off.
    void showFigurePositions(); // Show everybody's co-ordinates.
    void showObjectState(); // Show an object's state.
    void showEnemyState (int);  // Show enemy's co-ordinates and state.

    QTime t; // IDW testing
    int   T; // IDW testing
};

#endif // KGRLEVELPLAYER_H