• Skip to content
• Skip to link menu

KDE 4.0 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"

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

#include <kpushbutton.h>
#include <KStandardGuiItem>
#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

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

KGrGame::KGrGame (KGrCanvas * theView, 
        const QString &theSystemDir, const QString &theUserDir) : 
    view(theView), systemDataDir(theSystemDir), userDataDir(theUserDir), level(0)
{
    //view = theView;
    //systemDataDir = theSystemDir;
    //userDataDir = theUserDir;

    // 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;

    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 (goUpOneLevel()));

    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();
}

/******************************************************************************/
/**********************  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)
{
  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::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::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 (freebg, nuggetbg, false, view);
        playfield[i+1][j+1] = new KGrFree (FREE,i+1,j+1,view);
    }
    else {
        //playfield[i+1][j+1] = new KGrEditable (freebg, view);
        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 KGrBeton(QPixmap ());
      playfield[j][0]=new KGrObject (BETON);
      editObjArray[j][0] = BETON;
      //playfield[j][21]=new KGrBeton(QPixmap ());
      playfield[j][21]=new KGrObject (BETON);
      editObjArray[j][21] = BETON;
    }
    for (int i=0;i<22;i++) {
      //playfield[0][i]=new KGrBeton(QPixmap ());
      playfield[0][i]=new KGrObject (BETON);
      editObjArray[0][i] = BETON;
      //playfield[29][i]=new KGrBeton(QPixmap ());
      playfield[29][i]=new KGrObject (BETON);
      editObjArray[29][i] = BETON;
    }
    //for (int j=0;j<22;j++)
      //for (int i=0;i<30;i++) {
    //playfield[i][j]->move(16+i*16,16+j*16);
    //}
}

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;

    // During startup, kgoldrunner.cpp makes a queued call to game->newGame and
    // the default parameters are (-1, -1), so in that case we load the game and
    // level already read from KConfig by initCollections(), for a quick start.
    if (lev >= 0) {
    level = lev;            // Not default, so use the parameters.
    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;
    if (level == 0) {
    // Generate a special title: end of game or creating a new level.
    if (! editMode)
        levelTitle = "E N D --- F I N --- E N D E";
    else
        levelTitle = i18n("New Level");
    }
    else {
    // Generate title string "Collection-name - NNN - Level-name".
    levelTitle.setNum (level);
    levelTitle = levelTitle.rightJustified (3,'0');
    levelTitle = collection->name + " - " + levelTitle;
    if (levelName.length() > 0) {
        levelTitle = levelTitle + " - " + 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)) {
        KGrMessage::information (view, i18n("Save Game"),
        i18n("Cannot open file '%1' for read-only.",
         userDataDir + "savegame.dat"));
        return;
    }

    QTextStream text1 (&file1);
    int n = 30;         // Limit the file to the last 30 saves.
    while ((! text1.endData()) && (--n > 0)) {
        saved = text1.readLine() + '\n';
        text2 << saved;
    }
    file1.close();
    }

    file2.close();

    if (safeRename (userDataDir+"savegame.tmp", userDataDir+"savegame.dat")) {
    KGrMessage::information (view, i18n("Save Game"),
                i18n("Your game has been saved."));
    }
    else {
    KGrMessage::information (view, i18n("Save Game"),
                i18n("Error: Failed to save your game."));
    }
}

bool KGrGame::safeRename (const QString & oldName, const QString & newName)
{
    QFile newFile (newName);
    if (newFile.exists()) {
    // On some file systems we cannot rename if a file with the new name
    // already exists.  We must delete the existing file, otherwise the
    // upcoming QFile::rename will fail, according to Qt4 docs.  This
    // seems to be true with reiserfs at least.
    if (! newFile.remove()) {
        KGrMessage::information (view, i18n("Rename File"),
        i18n("Cannot delete previous version of file '%1'.", newName));
        return false;
    }
    }
    QFile oldFile (oldName);
    if (! oldFile.rename (newName)) {
    KGrMessage::information (view, i18n("Rename File"),
        i18n("Cannot rename file '%1' to '%2'.", oldName, newName));
    return false;
    }
    return true;
}

void KGrGame::loadGame()        // Re-load game, score and level.
{
    if (! saveOK (false)) {             // Check unsaved work.
    return;
    }

    QFile savedGames (userDataDir + "savegame.dat");
    if (! savedGames.exists()) {
    // Use myMessage() because it stops the game while the message appears.
    myMessage (view, i18n("Load Game"),
            i18n("Sorry, there are no saved games."));
    return;
    }

    if (! savedGames.open (QIODevice::ReadOnly)) {
    KGrMessage::information (view, i18n("Load Game"),
        i18n("Cannot open file '%1' for read-only.",
         userDataDir + "savegame.dat"));
    return;
    }

    // Halt the game during the loadGame() dialog.
    modalFreeze = false;
    if (!KGrObject::frozen) {
    modalFreeze = true;
    freeze();
    }

    QString s;

    KGrLGDialog * lg = new KGrLGDialog (&savedGames, collections, view);

    if (lg->exec() == QDialog::Accepted) {
    s = lg->getCurrentText();
    }

    bool found = false;
    QString pr;
    int  lev;
    int i;
    int imax = collections.count();

    if (! s.isNull()) {
    pr = s.mid (21, 7);         // Get the collection prefix.
    pr = pr.left (pr.indexOf (" ", 0, Qt::CaseInsensitive));

    for (i = 0; i < imax; i++) {        // Find the collection.
        if (collections.at(i)->prefix == pr) {
        collection = collections.at(i);
        collnIndex  = i;
        owner = collections.at(i)->owner;
        found = true;
        break;
        }
    }
    if (found) {
        // Set the rules for the selected game.
        emit markRuleType (collection->settings);
        lev   = s.mid (28, 3).toInt();
        newGame (lev, collnIndex);      // Re-star