• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kgoldrunner

kgrgame.cpp

Go to the documentation of this file.

/***************************************************************************
 *    Copyright 2003 Marco Krüger <grisuji@gmx.de>                         *
 *    Copyright 2003 Ian Wadham <ianw2@optusnet.com.au>                    *
 *                                                                         *
 *   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.                                   *
 ***************************************************************************/

#include "kgrgame.h"

#include "kgrconsts.h"
#include "kgrobject.h"
#include "kgrfigure.h"
#include "kgrcanvas.h"
#include "kgrdialog.h"
#include "kgrsoundbank.h"

// Obsolete - #include <iostream.h>
#include <iostream>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>

#include <kpushbutton.h>
#include <KStandardGuiItem>
#include <KStandardDirs>
#include <KApplication>
#include <kdebug.h>

// Do NOT change KGoldrunner over to KScoreDialog until we have found a way
// to preserve high-score data pre-existing from the KGr high-score methods.
// #define USE_KSCOREDIALOG 1 // IDW - 11 Aug 07.

#ifdef USE_KSCOREDIALOG
#include <KScoreDialog>
#include <QDate>
#else

#include <QByteArray>
#include <QTextStream>
#include <QLabel>
#include <QVBoxLayout>
#include <QDate>
#include <QSpacerItem>
#include <QTreeWidget>
#include <QHeaderView>
#include <QTreeWidgetItem>
#include <QDir>

#endif

// Moved this to kgrconsts.h, Ian W. 31 May 08 // #define ENABLE_SOUND_SUPPORT

/******************************************************************************/
/***********************    KGOLDRUNNER GAME CLASS    *************************/
/******************************************************************************/

KGrGame::KGrGame (KGrCanvas * theView, 
                const QString &theSystemDir, const QString &theUserDir) : 
        view (theView), systemDataDir (theSystemDir), userDataDir (theUserDir), level (0), fx (NumSounds)
{
    // Set the game-editor OFF, but available.
    editMode = false;
    paintEditObj = false;
    paintAltObj = false;
    editObj  = BRICK;
    shouldSave = false;

    hero = new KGrHero (view, 0, 0);    // The hero is born ... Yay !!!
    hero->setPlayfield (&playfield);

    setBlankLevel (true);       // Fill the playfield with blank walls.

    enemy = NULL;
    newLevel = true;            // Next level will be a new one.
    loading  = true;            // Stop input until it is loaded.

    modalFreeze = false;
    messageFreeze = false;

#ifdef ENABLE_SOUND_SUPPORT
    effects = new KGrSoundBank(8);
    fx[GoldSound] = effects->loadSound (KStandardDirs::locate ("appdata", "themes/default/gold.wav"));
    fx[StepSound] = effects->loadSound (KStandardDirs::locate ("appdata", "themes/default/step.wav"));
    fx[ClimbSound] = effects->loadSound (KStandardDirs::locate ("appdata", "themes/default/climb.wav"));
    fx[FallSound] = effects->loadSound (KStandardDirs::locate ("appdata", "themes/default/falling.wav"));
    fx[DigSound] = effects->loadSound (KStandardDirs::locate ("appdata", "themes/default/dig.wav"));

    connect(hero, SIGNAL (stepDone (bool)), this, SLOT (heroStep (bool)));
    connect(hero, SIGNAL (falling (bool)), this, SLOT (heroFalls (bool)));
    connect(hero, SIGNAL (digs()), this, SLOT (heroDigs()));

#endif

    connect (hero, SIGNAL (gotNugget (int)),  SLOT (incScore (int)));
    connect (hero, SIGNAL (caughtHero()),     SLOT (herosDead()));
    connect (hero, SIGNAL (haveAllNuggets()), SLOT (showHiddenLadders()));
    connect (hero, SIGNAL (leaveLevel()),     SLOT (levelCompleted()));

    dyingTimer = new QTimer (this);
    connect (dyingTimer, SIGNAL (timeout()),  SLOT (finalBreath()));

    // Get the mouse position every 40 msec.  It is used to steer the hero.
    mouseSampler = new QTimer (this);
    connect (mouseSampler, SIGNAL (timeout()), SLOT (readMousePos()));
    mouseSampler->start (40);

    srand (time (0));           // Initialise random number generator.
}

KGrGame::~KGrGame()
{
    //release collections
    while (!collections.isEmpty())
        delete collections.takeFirst();
}

void KGrGame::setInitialTheme (const QString & themeFilepath)
{
    initialThemeFilepath = themeFilepath;
}

void KGrGame::initGame()
{
    kDebug() << "Entered, draw the initial graphics now ...";

    // Get the most recent collection and level that was played by this user.
    // If he/she has never played before, set it to Tutorial, level 1.
    KConfigGroup gameGroup (KGlobal::config(), "KDEGame"); // Get prev game.
    QString prevGamePrefix = gameGroup.readEntry ("GamePrefix", "tute");
    int prevLevel = gameGroup.readEntry ("Level_" + prevGamePrefix, 1);
    kDebug()<< "Config() Game and Level" << prevGamePrefix << prevLevel;

    // Use that collection and level, if it is among the current collections.
    int n = 0;
    collnIndex = -1;
    foreach (collection, collections) {
        if (collection->prefix == prevGamePrefix) {
            collnIndex = n;
            level = prevLevel;
            break;
        }
        n++;
    }

    // If not found, set the first collection in the list and level 1.
    if (collnIndex < 0) {
        collnIndex = 0;
        level = 1;
    }

    collection = collections.at (collnIndex);

    kDebug() << "Calling the first view->changeTheme() ...";
    view->changeTheme (initialThemeFilepath);

    emit markRuleType (collection->settings);
    newGame (level, collnIndex);
}

/******************************************************************************/
/**********************  QUICK-START DIALOG AND SLOTS  ************************/
/******************************************************************************/

void KGrGame::quickStartDialog()
{
    // Make sure the game will not start during the Quick Start dialog.
    freeze();

    qs = new KDialog (view);

    // Modal dialog, 4 buttons, vertically: the PLAY button has the focus.
    qs->setModal (true);
    qs->setCaption ("Quick Start");
    qs->setButtons
            (KDialog::Ok | KDialog::Cancel | KDialog::User1 | KDialog::User2);
    qs->setButtonFocus (KDialog::Ok);
    qs->setButtonsOrientation (Qt::Vertical);

    // Set up the PLAY button.
    qs->setButtonText (KDialog::Ok,
            i18nc ("Button text: start playing a game", "&PLAY"));
    qs->setButtonToolTip (KDialog::Ok, i18n ("Start playing this level"));
    qs->setButtonWhatsThis (KDialog::Ok,
            i18n ("Set up to start playing the game and level being shown, "
                 "as soon as you click, move the mouse or press a key"));

    // Set up the Quit button.
    qs->setButtonText (KDialog::Cancel, i18n ("&Quit"));
    qs->setButtonToolTip (KDialog::Cancel, i18n ("Close KGoldrunner"));

    // Set up the New Game button.
    qs->setButtonText (KDialog::User1, i18n ("&New Game..."));
    qs->setButtonToolTip (KDialog::User1,
            i18n ("Start a different game or level"));
    qs->setButtonWhatsThis (KDialog::User1,
            i18n ("Use the Select Game dialog box to choose a "
                 "different game or level and start playing it"));

    // Set up the Use Menu button.
    qs->setButtonText (KDialog::User2, i18n ("&Use Menu"));
    qs->setButtonToolTip (KDialog::User2,
            i18n ("Use the menus to choose other actions"));
    qs->setButtonWhatsThis (KDialog::User2,
            i18n ("Before playing, use the menus to choose other actions, "
                 "such as loading a saved game or changing the theme"));

    // Add the KGoldrunner application icon to the dialog box.
    QLabel * logo = new QLabel();
    qs->setMainWidget (logo);
    logo->setPixmap (kapp->windowIcon().pixmap (240));
    logo->setAlignment (Qt::AlignTop | Qt::AlignHCenter);

    connect (qs, SIGNAL (okClicked()),     this, SLOT (quickStartPlay()));
    connect (qs, SIGNAL (user1Clicked()),  this, SLOT (quickStartNewGame()));
    connect (qs, SIGNAL (user2Clicked()),  this, SLOT (quickStartUseMenu()));
    connect (qs, SIGNAL (cancelClicked()), this, SLOT (quickStartQuit()));

    qs->show();
}

void KGrGame::quickStartPlay()
{
    // KDialog calls QDialog::accept() after the OK slot, so must hide it
    // now, to avoid interference with any tutorial messages there may be.
    qs->hide();
    showTutorialMessages (level);
    unfreeze();
}

void KGrGame::quickStartNewGame()
{
    qs->accept();
    unfreeze();
    startAnyLevel();
}

void KGrGame::quickStartUseMenu()
{
    qs->accept();
    myMessage (view, i18n ("Game Paused"),
            i18n ("The game is halted. You will need to press the Pause key "
                 "(default P or Esc) when you are ready to play."));
}

void KGrGame::quickStartQuit()
{
    emit quitGame();
}

/******************************************************************************/
/*************************  GAME SELECTION PROCEDURES  ************************/
/******************************************************************************/

void KGrGame::startLevelOne()
{
    startLevel (SL_START, 1);
}

void KGrGame::startAnyLevel()
{
    startLevel (SL_ANY, level);
}

void KGrGame::startNextLevel()
{
    startLevel (SL_ANY, level + 1);
}

void KGrGame::startLevel (int startingAt, int requestedLevel)
{
    if (! saveOK (false)) {             // Check unsaved work.
        return;
    }
    // Use dialog box to select game and level: startingAt = ID_FIRST or ID_ANY.
    int selectedLevel = selectLevel (startingAt, requestedLevel);
    if (selectedLevel > 0) {    // If OK, start the selected game and level.
        newGame (selectedLevel, selectedGame);
        showTutorialMessages (level);
    } else {
        level = 0;
    }
}

/******************************************************************************/
/************************  MAIN GAME EVENT PROCEDURES  ************************/
/******************************************************************************/

void KGrGame::incScore (int n)
{
#ifdef ENABLE_SOUND_SUPPORT
    // I don't think this is the right place, but it's just for testing...
    switch (n) {
    case 250: 
    effects->play (fx[GoldSound]);
    break;
    default:
    break;
    }
#endif
    score = score + n;      // SCORING: trap enemy 75, kill enemy 75,
    emit showScore (score); // collect gold 250, complete the level 1500.
}

void KGrGame::herosDead()
{
    if ((level < 1) || (lives <= 0))
        return;         // Game over: we are in the "ENDE" screen.

    // Lose a life.
    if (--lives > 0) {
        // Still some life left, so PAUSE and then re-start the level.
        emit showLives (lives);
        KGrObject::frozen = true;   // Freeze the animation and let
        dyingTimer->setSingleShot (true);
        dyingTimer->start (1500);   // the player see what happened.
        view->fadeOut();
    }
    else {
        // Game over.
        emit showLives (lives);
        freeze();
        QString gameOver = "<NOBR><B>" + i18n ("GAME OVER !!!") + "</B></NOBR>";
        KGrMessage::information (view, collection->name, gameOver);
        checkHighScore();   // Check if there is a high score for this game.

        // Offer the player a chance to start this level again with 5 new lives.
        switch (KGrMessage::warning (view, i18n ("Retry Level?"),
                            i18n ("Would you like to try this level again?"),
                            i18n ("&Try Again"), i18n ("&Finish"))) {
        case 0:
            unfreeze();         // Offer accepted.
            newGame (level, collnIndex);
            showTutorialMessages (level);
            return;
            break;
        case 1:
            break;          // Offer rejected.
        }

        // Game completely over: display the "ENDE" screen.
        enemyCount = 0;
        //todo enemies.clear(); // Stop the enemies catching the hero again ...
        while (!enemies.isEmpty())
                delete enemies.takeFirst();

        view->deleteEnemySprites();
        unfreeze();     //    ... NOW we can unfreeze.
        newLevel = true;
        level = 0;
        loadLevel (level);  // Display the "ENDE" screen.
        newLevel = false;
    }
}

void KGrGame::finalBreath()
{
    // Fix bug 95202:   Avoid re-starting if the player selected
    //          edit mode before the 1.5 seconds were up.
    if (! editMode) {
        enemyCount = 0;     // Hero is dead: re-start the level.
        loadLevel (level);
    }
    KGrObject::frozen = false;  // Unfreeze the game, but don't move yet.
}

void KGrGame::showHiddenLadders()
{
    int i, j;
    for (i = 1; i < 21; i++)
        for (j = 1; j < 29; j++)
            if (playfield[j][i]->whatIam() == HLADDER)
                ((KGrHladder *)playfield[j][i])->showLadder();
    initSearchMatrix();
}
        
void KGrGame::levelCompleted()
{
    connect (view, SIGNAL (fadeFinished()), this, SLOT (goUpOneLevel()));
    view->fadeOut();
}

// 
void KGrGame::goUpOneLevel()
{
    disconnect (view, SIGNAL (fadeFinished()), this, SLOT (goUpOneLevel()));
    lives++;            // Level completed: gain another life.
    emit showLives (lives);
    incScore (1500);

    if (level >= collection->nLevels) {
        freeze();
        KGrMessage::information (view, collection->name,
            i18n ("<b>CONGRATULATIONS !!!!</b>"
            "<p>You have conquered the last level in the "
            "<b>\"%1\"</b> game !!</p>", collection->name));
        checkHighScore();   // Check if there is a high score for this game.

        unfreeze();
        level = 0;      // Game completed: display the "ENDE" screen.
    }
    else {
        level++;        // Go up one level.
        emit showLevel (level);
    }

    enemyCount = 0;
    //enemies.clear();
    while (!enemies.isEmpty())
        delete enemies.takeFirst();

    view->deleteEnemySprites();
    newLevel = true;
    loadLevel (level);
    showTutorialMessages (level);
    newLevel = false;
}

void KGrGame::loseNugget()
{
    hero->loseNugget();     // Enemy trapped/dead and holding a nugget.
}

KGrHero * KGrGame::getHero()
{
    return (hero);      // Return a pointer to the hero.
}

int KGrGame::getLevel()     // Return the current game-level.
{
    return (level);
}

bool KGrGame::inMouseMode()
{
    return (mouseMode);     // Return true if game is under mouse control.
}

bool KGrGame::inEditMode()
{
    return (editMode);      // Return true if the game-editor is active.
}

bool KGrGame::isLoading()
{
    return (loading);       // Return true if a level is being loaded.
}

void KGrGame::setMouseMode (bool on_off)
{
    mouseMode = on_off;     // Set Mouse OR keyboard control.
}

void KGrGame::setPlaySounds (bool on_off)
{
    KConfigGroup gameGroup (KGlobal::config(), "KDEGame");
    gameGroup.writeEntry ("Sound", on_off);
#ifdef ENABLE_SOUND_SUPPORT
    effects->setMuted (!on_off);
#endif
}

void KGrGame::freeze()
{
    if ((! modalFreeze) && (! messageFreeze)) {
        emit gameFreeze (true); // Do visual feedback in the GUI.
    }
    KGrObject::frozen = true;   // Halt the game, by blocking all timer events.
}

void KGrGame::unfreeze()
{
    if ((! modalFreeze) && (! messageFreeze)) {
        emit gameFreeze (false);// Do visual feedback in the GUI.
    }
    KGrObject::frozen = false;  // Restart the game.  Because frozen == false,
    restart();          // the game goes on running after the next step.
}

void KGrGame::setMessageFreeze (bool on_off)
{
    if (on_off) {       // Freeze the game action during a message.
        messageFreeze = false;
        if (! KGrObject::frozen) {
            messageFreeze = true;
            freeze();
        }
    }
    else {          // Unfreeze the game action after a message.
        if (messageFreeze) {
            unfreeze();
            messageFreeze = false;
        }
    }
}

void KGrGame::setBlankLevel (bool playable)
{
    for (int j = 0; j < 20; j++)
        for (int i = 0; i < 28; i++) {
            if (playable) {
                playfield[i+1][j+1] = new KGrFree (FREE, i+1, j+1, view);
            }
            else {
                playfield[i+1][j+1] = new KGrEditable (FREE);
                view->paintCell (i+1, j+1, FREE);
            }
            editObjArray[i+1][j+1] = FREE;
        }
    for (int j = 0; j < 30; j++) {
        playfield[j][0] = new KGrObject (BETON);
        editObjArray[j][0] = BETON;
        playfield[j][21] = new KGrObject (BETON);
        editObjArray[j][21] = BETON;
    }
    for (int i = 0; i < 22; i++) {
        playfield[0][i] = new KGrObject (BETON);
        editObjArray[0][i] = BETON;
        playfield[29][i] = new KGrObject (BETON);
        editObjArray[29][i] = BETON;
    }
}
    
void KGrGame::newGame (const int lev, const int gameIndex)
{
    // Ignore player input from keyboard or mouse while the screen is set up.
    loading = true;     // "loadLevel (level)" will reset it.

    view->goToBlack();
    if (editMode) {
        emit setEditMenu (false);   // Disable edit menu items and toolbar.

        editMode = false;
        paintEditObj = false;
        paintAltObj = false;
        editObj = BRICK;

        view->setHeroVisible (true);
    }

    newLevel = true;

    level = lev;
    collnIndex = gameIndex;
    collection = collections.at (collnIndex);
    owner = collection->owner;

    lives = 5;              // Start with 5 lives.
    score = 0;
    startScore = 0;

    emit showLives (lives);
    emit showScore (score);
    emit showLevel (level);

    enemyCount = 0;

    //enemies.clear();
    while (!enemies.isEmpty())
        delete enemies.takeFirst();

    view->deleteEnemySprites();

    newLevel = true;;
    loadLevel (level);
    newLevel = false;
}

void KGrGame::startTutorial()
{
    if (! saveOK (false)) {             // Check unsaved work.
        return;
    }

    int i, index;
    int imax = collections.count();
    bool found = false;

    index = 0;
    for (i = 0; i < imax; i++) {
        index = i;          // Index within owner.
        if (collections.at (i)->prefix == "tute") {
            found = true;
            break;
        }
    }
    if (found) {
        // Start the tutorial.
        collection = collections.at (index);
        owner = collection->owner;
        emit markRuleType (collection->settings);
        collnIndex = index;
        level = 1;
        newGame (level, collnIndex);
        showTutorialMessages (level);
    }
    else {
        KGrMessage::information (view, i18n ("Start Tutorial"),
            i18n ("Cannot find the tutorial game (file-prefix '%1') in "
            "the '%2' files.",
            QString ("tute"), QString ("games.dat")));
    }
}

void KGrGame::showHint()
{
    // Put out a hint for this level.
    QString caption = i18n ("Hint");

    if (levelHint.length() > 0)
        myMessage (view, caption, levelHint);
    else
        myMessage (view, caption,
                        i18n ("Sorry, there is no hint for this level."));
}

int KGrGame::loadLevel (int levelNo)
{
    // Ignore player input from keyboard or mouse while the screen is set up.
    loading = true;

    // Read the level data.
    LevelData d;
    if (! readLevelData (levelNo, d)) {
        loading = false;
        return 0;
    }

    view->setLevel (levelNo);       // Switch and render background if reqd.
    view->fadeIn();         // Then run the fade-in animation.
    nuggets = 0;
    enemyCount=0;
    startScore = score;         // The score we will save, if asked.

    int i, j;
    // Load the level-layout, hero and enemies.
    for (j = 1; j <= FIELDHEIGHT; j++) {
        for (i = 1; i <= FIELDWIDTH; i++) {
            changeObject (d.layout.at ((j - 1) * FIELDWIDTH + (i - 1)), i , j);
        }
    }

    // If there is a name, translate the UTF-8 coded QByteArray right now.
    levelName = (d.name.size() > 0) ? i18n ((const char *) d.name) : "";

    // Indicate on the menus whether there is a hint for this level.
    int len = d.hint.length();
    emit hintAvailable (len > 0);

    // If there is a hint, translate it right now.
    levelHint = (len > 0) ? i18n ((const char *) d.hint) : "";

    // Disconnect edit-mode slots from signals from "view".
    disconnect (view, SIGNAL (mouseClick (int)), 0, 0);
    disconnect (view, SIGNAL (mouseLetGo (int)), 0, 0);

    if (newLevel) {
        hero->setEnemyList (&enemies);
        QListIterator<KGrEnemy *> i (enemies);
        while (i.hasNext()) {
            KGrEnemy * enemy = i.next();
            enemy->setEnemyList (&enemies);
        }
    }

    hero->setNuggets (nuggets);
    setTimings();

    // Make a new sequence of all possible x co-ordinates for enemy rebirth.
    if (KGrFigure::reappearAtTop && (enemies.count() > 0)) {
        KGrEnemy::makeReappearanceSequence();
    }

    // Set direction-flags to use during enemy searches.
    initSearchMatrix();

    // Re-draw the playfield frame, level title and figures.
    view->setTitle (getTitle());

    // If in mouse mode, not keyboard mode, put the mouse pointer on the hero.
    if (mouseMode) {
        view->setMousePos (startI, startJ);
    }

    // If we are starting a new level, save it in the player's config file.
    if (newLevel) {
        KConfigGroup gameGroup (KGlobal::config(), "KDEGame");
        gameGroup.writeEntry ("GamePrefix", collection->prefix);
        gameGroup.writeEntry ("Level_" + collection->prefix, level);
        gameGroup.sync();       // Ensure that the entry goes to disk.
    }

    // Connect play-mode slot to signal from "view".
    connect (view, SIGNAL (mouseClick (int)), SLOT (doDig (int)));

    // Re-enable player input.
    loading = false;

    return 1;
}

void KGrGame::showTutorialMessages (int levelNo)
{
    // Halt the game during message displays and mouse pointer moves.
    setMessageFreeze (true);

    // Check if this is a tutorial collection and not on the "ENDE" screen.
    if ((collection->prefix.left (4) == "tute") && (levelNo != 0)) {

        // At the start of a tutorial, put out an introduction.
        if (levelNo == 1) {
            KGrMessage::information (view, collection->name,
                        i18n (collection->about.toUtf8().constData()));
        }
        // Put out an explanation of this level.
        KGrMessage::information (view, getTitle(), levelHint);
    }

    // If in mouse mode, make sure the mouse pointer is back on the hero.
    if (mouseMode) {
        view->setMousePos (startI, startJ);
    }
    setMessageFreeze (false);   // Let the level begin.
}

bool KGrGame::readLevelData (int levelNo, LevelData & d)
{
    KGrGameIO io;
    // If system game or ENDE screen, choose system dir, else choose user dir.
    const QString dir = ((owner == SYSTEM) || (levelNo == 0)) ?
                                        systemDataDir : userDataDir;
    IOStatus stat = io.fetchLevelData (dir, collection->prefix, levelNo, d);

    switch (stat) {
    case NotFound:
        KGrMessage::information (view, i18n ("Read Level Data"),
            i18n ("Cannot find file '%1'.", d.filePath));
        break;
    case NoRead:
    case NoWrite:
        KGrMessage::information (view, i18n ("Read Level Data"),
            i18n ("Cannot open file '%1' for read-only.", d.filePath));
        break;
    case UnexpectedEOF:
        KGrMessage::information (view, i18n ("Read Level Data"),
            i18n ("Reached end of file '%1' without finding level data.",
            d.filePath));
        break;
    case OK:
        break;
    }

    return (stat == OK);
}

void KGrGame::changeObject (unsigned char kind, int i, int j)
{
    delete playfield[i][j];
    switch (kind) {
    case FREE:    createObject (new KGrFree (FREE,i,j,view),FREE,i,j);break;
    case LADDER:  createObject (new KGrObject (LADDER),LADDER,i,j);break;
    case HLADDER: createObject (new KGrHladder (HLADDER,i,j,view),FREE,i,j);break;
    case BRICK:   createObject (new KGrBrick (BRICK,i,j,view),BRICK,i,j);break;
    case BETON:   createObject (new KGrObject (BETON),BETON,i,j);break;
    case FBRICK:  createObject (new KGrObject (FBRICK),BRICK,i,j);break;
    case POLE:    createObject (new KGrObject (POLE),POLE,i,j);break;
    case NUGGET:  createObject (new KGrFree (NUGGET,i,j,view),NUGGET,i,j);
                                  nuggets++;break;
    case HERO:    createObject (new KGrFree (FREE,i,j,view),FREE,i,j);
        hero->init (i,j);
        startI = i; startJ = j;
        hero->started = false;
        hero->showFigure();
        break;
    case ENEMY:   createObject (new KGrFree (FREE,i,j,view),FREE,i,j);
        if (newLevel) {
            // Starting a level for the first time.
            enemy = new KGrEnemy (view, i, j);
            enemy->setPlayfield (&playfield);
            enemy->enemyId = enemyCount++;
            enemies.append (enemy);
            connect (enemy, SIGNAL (lostNugget()), SLOT (loseNugget()));
            connect (enemy, SIGNAL (trapped (int)), SLOT (incScore (int)));
            connect (enemy, SIGNAL (killed (int)),  SLOT (incScore (int)));
        }
        else {
            // Starting a level again after losing.
            enemy=enemies.at (enemyCount);
            enemy->enemyId=enemyCount++;
            enemy->setNuggets (0);
            enemy->init (i,j);  // Re-initialise the enemy's state information.
        }
        enemy->showFigure();
        break;
    default :  createObject (new KGrBrick (BRICK,i,j,view),BRICK,i,j);break;
    }
}

void KGrGame::createObject (KGrObject *o, char picType, int x, int y)
{
    playfield[x][y] = o;
    view->paintCell (x, y, picType);        // Pic maybe not same as object.
}

void KGrGame::setTimings()
{
    Timing *    timing;
    int     c = -1;

    if (KGrFigure::variableTiming) {
        c = enemies.count();            // Timing based on enemy count.
        c = (c > 5) ? 5 : c;
        timing = &(KGrFigure::varTiming[c]);
    }
    else {
        timing = &(KGrFigure::fixedTiming); // Fixed timing.
    }

    KGrHero::WALKDELAY      = timing->hwalk;
    KGrHero::FALLDELAY      = timing->hfall;
    KGrEnemy::WALKDELAY     = timing->ewalk;
    KGrEnemy::FALLDELAY     = timing->efall;
    KGrEnemy::CAPTIVEDELAY  = timing->ecaptive;
    KGrBrick::HOLETIME      = timing->hole;
}

void KGrGame::initSearchMatrix()
{
    // Called at start of level and also when hidden ladders appear.
    int i, j;

    for (i = 1; i < 21; i++) {
        for (j = 1; j < 29; j++) {
            // If on ladder, can walk L, R, U or D.
            if (playfield[j][i]->whatIam() == LADDER)
                playfield[j][i]->searchValue = CANWALKLEFT + CANWALKRIGHT +
                                              CANWALKUP + CANWALKDOWN;
            else
                // If on solid ground, can walk L or R.
                if ((playfield[j][i+1]->whatIam() == BRICK) ||
                    (playfield[j][i+1]->whatIam() == HOLE) ||
                    (playfield[j][i+1]->whatIam() == USEDHOLE) ||
                    (playfield[j][i+1]->whatIam() == BETON))
                    playfield[j][i]->searchValue = CANWALKLEFT + CANWALKRIGHT;
                else
                    // If on pole or top of ladder, can walk L, R or D.
                    if ((playfield[j][i]->whatIam() == POLE) ||
                        (playfield[j][i+1]->whatIam() == LADDER))
                        playfield[j][i]->searchValue = CANWALKLEFT +
                                              CANWALKRIGHT + CANWALKDOWN;
                    else
                        // Otherwise, gravity takes over ...
                        playfield[j][i]->searchValue = CANWALKDOWN;
      
            // Clear corresponding bits if there are solids to L, R, U or D.
            if (playfield[j][i-1]->blocker)
                playfield[j][i]->searchValue &= ~CANWALKUP;
            if (playfield[j-1][i]->blocker)
                playfield[j][i]->searchValue &= ~CANWALKLEFT;
            if (playfield[j+1][i]->blocker)
                playfield[j][i]->searchValue &= ~CANWALKRIGHT;
            if (playfield[j][i+1]->blocker)
                playfield[j][i]->searchValue &= ~CANWALKDOWN;
        }
    }
}
        
void KGrGame::startPlaying() {
    if (! hero->started) {
        // Start the enemies and the hero.
        for (--enemyCount; enemyCount>=0; --enemyCount) {
            enemy=enemies.at (enemyCount);
            enemy->startSearching();
        }
        hero->start();
    }
}

QString KGrGame::getDirectory (Owner o)
{
    return ((o == SYSTEM) ? systemDataDir : userDataDir);
}

QString KGrGame::getFilePath (Owner o, KGrCollection * colln, int lev)
{
    QString filePath;

    if (lev == 0) {
        // End of game: show the "ENDE" screen.
        o = SYSTEM;
        filePath = "level000.grl";
    }
    else {
        filePath.setNum (lev);      // Convert INT -> QString.
        filePath = filePath.rightJustified (3,'0'); // Add 0-2 zeros at left.
        filePath.append (".grl");   // Add KGoldrunner level-suffix.
        filePath.prepend (colln->prefix);   // Add collection file-prefix.
    }

    filePath.prepend (((o == SYSTEM)? systemDataDir : userDataDir) + "levels/");

    return (filePath);
}

QString KGrGame::getTitle()
{
    QString levelTitle;
    QString levelNumber;
    if (level == 0) {
        // Generate a special title: end of game or creating a new level.
        if (! editMode)
            levelTitle = i18n ("T H E   E N D");
        else
            levelTitle = i18n ("New Level");
    }
    else {
        // Generate title string "Collection-name - NNN - Level-name".
        levelNumber.setNum (level);
        levelNumber = levelNumber.rightJustified (3,'0');
        if (levelName.length() <= 0) {
            levelTitle = i18nc ("Game name - level number.",
                    "%1 - %2", collection->name, levelNumber);
        }
        else {
            levelTitle = i18nc ("Game name - level number - level name.",
                    "%1 - %2 - %3", collection->name, levelNumber, levelName);
        }
    }
    return (levelTitle);
}

void KGrGame::readMousePos()
{
    QPoint p;
    int i, j;

    // If loading a level for play or editing, ignore mouse-position input.
    if (loading) return;

    // If game control is currently by keyboard, ignore the mouse.
    if ((! mouseMode) && (! editMode)) return;

    p = view->getMousePos();
    i = p.x(); j = p.y();

    if (editMode) {
        // Editing - check if we are in paint mode and have moved the mouse.
        if (paintEditObj && ((i != oldI) || (j != oldJ))) {
            insertEditObj (i, j, editObj);
            oldI = i;
            oldJ = j;
        }
        if (paintAltObj && ((i != oldI) || (j != oldJ))) {
            insertEditObj (i, j, FREE);
            oldI = i;
            oldJ = j;
        }
        // Highlight the cursor position
    
    }
    else {
        // Playing - if  the level has started, control the hero.
        if (KGrObject::frozen) return;  // If game is stopped, do nothing.

        hero->setDirection (i, j);

        // Start playing when the mouse moves off the hero.
        if ((! hero->started) && ((i != startI) || (j != startJ))) {
            startPlaying();
        }
    }
}

void KGrGame::doDig (int button) {

    // If game control is currently by keyboard, ignore the mouse.
    if (editMode) return;
    if (! mouseMode) return;

    // If loading a level for play or editing, ignore mouse-button input.
    if ((! loading) && (! KGrObject::frozen)) {
        if (! hero->started) {
            startPlaying(); // If first player-input, start playing.
        }
        switch (button) {
        case Qt::LeftButton:    hero->digLeft(); break;
        case Qt::RightButton:   hero->digRight(); break;
        default:        break;
        }
    }
}

void KGrGame::heroAction (KBAction movement)
{
    switch (movement) {
    case KB_UP:     hero->setKey (UP); break;
    case KB_DOWN:   hero->setKey (DOWN); break;
    case KB_LEFT:   hero->setKey (LEFT); break;
    case KB_RIGHT:  hero->setKey (RIGHT); break;
    case KB_STOP:   hero->setKey (STAND); break;
    case KB_DIGLEFT:    hero->setKey (STAND); hero->digLeft(); break;
    case KB_DIGRIGHT:   hero->setKey (STAND); hero->digRight(); break;
    }
}

/******************************************************************************/
/**************************  SAVE AND RE-LOAD GAMES  **************************/
/******************************************************************************/

void KGrGame::saveGame()        // Save game ID, score and level.
{
    if (editMode) {myMessage (view, i18n ("Save Game"),
        i18n ("Sorry, you cannot save your game play while you are editing. "
        "Please try menu item \"%1\".",
        i18n ("&Save Edits...")));
        return;
    }
    if (hero->started) {myMessage (view, i18n ("Save Game"),
        i18n ("Please note: for reasons of simplicity, your saved game "
        "position and score will be as they were at the start of this "
        "level, not as they are now."));
    }

    QDate today = QDate::currentDate();
    QTime now =   QTime::currentTime();
    QString saved;
    QString day;
    day = today.shortDayName (today.dayOfWeek());
    saved = saved.sprintf
                ("%-6s %03d %03ld %7ld    %s %04d-%02d-%02d %02d:%02d\n",
                collection->prefix.myStr(), level, lives, startScore,
                day.myStr(),
                today.year(), today.month(), today.day(),
                now.hour(), now.minute());

    QFile file1 (userDataDir + "savegame.dat");
    QFile file2 (userDataDir + "savegame.tmp");

    if (! file2.open (QIODevice::WriteOnly)) {
        KGrMessage::information (view, i18n ("Save Game"),
                i18n ("Cannot open file '%1' for output.",
                 userDataDir + "savegame.tmp"));
        return;
    }
    QTextStream text2 (&file2);
    text2 << saved;

    if (file1.exists()) {
        if (! file1.open (QIODevice::ReadOnly)) {