• Skip to content
• Skip to link menu

KDE 4.0 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

kgoldrunner

kgrfigure.cpp

Go to the documentation of this file.

/***************************************************************************
 *                      kgrfigure.cpp  -  description                      *
 *                           -------------------                           *
    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.                                   *
 ***************************************************************************/

/*
 * Many thanks to Kevin Krammer and Alex Sopicki for translating the
 * original comments in this program code from German into English.
 */

#include "kgrfigure.h"

#include "kgrconsts.h"
#include "kgrobject.h"
#include "kgrcanvas.h"

#include <stdio.h>
#include <QList>

KGrFigure :: KGrFigure (int px, int py) : direction(RIGHT)
{
  x = mem_x = px;
  y = mem_y = py;
  relx = mem_relx = 0;
  rely = mem_rely = 0;

  absx = px*16;
  absy = py*16;

  nuggets = 0;
  status = STANDING;

  walkTimer = new QTimer (this);
  fallTimer = new QTimer (this);
}

// Initialise the global settings flags.
bool           KGrFigure::variableTiming = true;
bool           KGrFigure::alwaysCollectNugget    = true;
bool           KGrFigure::runThruHole    = true;
bool           KGrFigure::reappearAtTop  = true;
SearchStrategy KGrFigure::searchStrategy = LOW;

int KGrFigure::herox = 0;
int KGrFigure::heroy = 0;

// Initialise the global game-speed factors.
int KGrFigure::speed = NSPEED;
int KGrBrick::speed  = NSPEED;

// Initialise constants for fixed (KGoldrunner) and variable (Traditional)
// timing.  Each row contains timings for hero walk and fall, enemy walk and
// fall, enemy captured in hole and dug brick.

Timing KGrFigure::fixedTiming = {45, 50, 55, 100, 500, 40}; // KGr original.

Timing KGrFigure::varTiming[6] = {              // Traditional.
                {40, 58, 78, 88, 170, 23},  // No enemies.
                {50, 68, 78, 88, 170, 32},  // 1 enemy.
                {57, 67, 114, 128, 270, 37},    // 2 enemies.
                {60, 70, 134, 136, 330, 40},    // 3 enemies.
                {63, 76, 165, 150, 400, 46},    // 4 enemies.
                {70, 80, 189, 165, 460, 51} // >4 enemies.
};

int KGrBrick::HOLETIME = 0;

int KGrFigure::getx()
{
  return absx;
}

int KGrFigure::gety()
{
  return absy;
}

Status KGrFigure::getStatus()
{
    return status;
}

void KGrFigure::init(int a,int b)
{
  walkTimer->stop();
  fallTimer->stop();
  x = mem_x = a;
  y = mem_y = b;
  relx = mem_relx = 0;
  rely = mem_rely = 0;
  nuggets = 0;
  status = STANDING;
}

void KGrFigure:: setNuggets(int n)
{
  nuggets = n;
}


bool KGrFigure::canWalkRight()
{
  return (((*playfield)[x+1][y]->whatIam() != BRICK) &&
      ((*playfield)[x+1][y]->whatIam() != BETON) &&
      ((*playfield)[x+1][y]->whatIam() != FBRICK));
}

bool KGrFigure::canWalkLeft()
{
  return (((*playfield)[x-1][y]->whatIam() != BRICK) &&
      ((*playfield)[x-1][y]->whatIam() != BETON) &&
      ((*playfield)[x-1][y]->whatIam() != FBRICK));
      }

bool KGrFigure::canWalkUp()
{
  return (((*playfield)[x][y-1]->whatIam() != BRICK) &&
      ((*playfield)[x][y-1]->whatIam() != BETON) &&
      ((*playfield)[x][y-1]->whatIam() != FBRICK) &&
      ((*playfield)[x][y]->whatIam() == LADDER));
}

bool KGrFigure::canWalkDown()
{
  return (((*playfield)[x][y+1]->whatIam() != BRICK) &&
      ((*playfield)[x][y+1]->whatIam() != BETON) &&
      // v0.3 FIX - Let figure step down into FBRICK from a ladder.
      //      ((*playfield)[x][y+1]->whatIam() != FBRICK)&&
      (((*playfield)[x][y+1]->whatIam() == LADDER)||
       ((*playfield)[x][y]->whatIam() == LADDER)));
}

bool KGrFigure::canStand()
{
  return (((*playfield)[x][y+1]->whatIam() == BRICK) ||
      ((*playfield)[x][y+1]->whatIam() == BETON) ||
      ((*playfield)[x][y+1]->whatIam() == USEDHOLE)||
      ((*playfield)[x][y+1]->whatIam() == LADDER)||
      ((*playfield)[x][y]->whatIam() == LADDER)||
      standOnEnemy());
      }

bool KGrFigure::hangAtPole()
{
  return ((*playfield)[x][y]->whatIam() == POLE);
}

void KGrFigure::walkUp(int WALKDELAY)
{
    actualPixmap = (actualPixmap == CLIMB1) ? CLIMB2 : CLIMB1;
    if (walkCounter++ < gameCycle) {
    // Not end of 4-step cycle: move one step up, if possible.
    if (canWalkUp()) {
        rely -= STEP;
        absy -= STEP;
    }
    walkTimer->setSingleShot( true );
    walkTimer->start ((WALKDELAY * NSPEED) / speed);
    }
    else {
    // End of 4-step cycle: move up to next cell, if possible.
    if (canWalkUp()) {
        y--;
    }
    // Always reset position, in case we are stuck partly into a brick.
    rely = 0;
    absy = y*16;

    // Wait for caller to set next direction.
    status = STANDING;
    }
}

void KGrFigure::walkDown(int WALKDELAY, int FALLDELAY)
{
    if (hangAtPole() || (! canStand())) {
    // On bar or no firm ground underneath: so must fall.
    initFall (FALL2, FALLDELAY);
    }
    else {
    actualPixmap = (actualPixmap == CLIMB1) ? CLIMB2 : CLIMB1;
    if (walkCounter++ < gameCycle) {
        // Not end of 4-step cycle: move one step down, if possible.
        if (canWalkDown()) {
        rely += STEP;
        absy += STEP;
        }
        walkTimer->setSingleShot( true );
        walkTimer->start ((WALKDELAY * NSPEED) / speed);
    }
    else {
        // End of 4-step cycle: move down to next cell, if possible.
        if (canWalkDown()) {
        y++;
        }
        // Always reset position, in case we are stuck partly into a brick.
        rely = 0;
        absy = y*16;

        // Must be able to halt at a pole when going down.
        if (! (canStand() || hangAtPole()))
        initFall(FALL2, FALLDELAY); // Nothing to hold: so fall.
        else
        // Wait for caller to set next direction.
        status = STANDING;
    }
    }
}

void KGrFigure::walkLeft (int WALKDELAY, int FALLDELAY)
{
    // If counter != 0, the figure is walking, otherwise he is turning around.
    if (walkCounter++ != 0) {
    // Change to the next pixmap in the animation.
    if ((++actualPixmap % gameCycle) != 0) {
        // Not end of 4-pixmap cycle: move one step left, if possible.
        if (canWalkLeft()) {
        relx -= STEP;
        absx -=STEP;
        }
        walkTimer->setSingleShot( true );
        walkTimer->start ((WALKDELAY * NSPEED) / speed);
    }
    else {
        // Check if we are half way through the 8-frame graphics cycle.
            alternateStepGraphics = true;
            if ((actualPixmap % graphicsCycle) == 0) {
                alternateStepGraphics = false;  // Finished the 8-frame cycle.
                actualPixmap -= graphicsCycle;  // Repeat it.
            }

        if (canWalkLeft()) {
        x--;
        }
        // Always reset position, in case we are stuck partly into a brick.
        relx = 0;
        absx = x*16;

        // If cannot stand or hang, start fall, else await next assignment.
        if (! (canStand() || hangAtPole()))
        initFall (FALL1, FALLDELAY);
        else
        status = STANDING;  // Caller should set next direction.
    }
    }
    else {
    status = STANDING;      // The figure is turning around.
    }
}

void KGrFigure::walkRight(int WALKDELAY, int FALLDELAY)
{
    if (walkCounter++) {        // If 0, just turn the figure around.
    if ((++actualPixmap % gameCycle) != 0)  {
            // The 4-frame cycle per playfield tile is incomplete.
        if (canWalkRight()) {   // Move right, if it's possible.
        relx += STEP;
        absx += STEP;
        }
        walkTimer->setSingleShot( true );
        walkTimer->start ((WALKDELAY * NSPEED) / speed);
    }
    else {
        // Check if we are half way through the 8-frame graphics cycle.
            alternateStepGraphics = true;
            if ((actualPixmap % graphicsCycle) == 0) {
                alternateStepGraphics = false;  // Finished the 8-frame cycle.
                actualPixmap -= graphicsCycle;  // Repeat it.
            }

        if (canWalkRight()) {
        x++;
        }               // Set the figure's new position.
        // Always reset position, in case we are stuck partly into a brick.
        relx = 0;
        absx = x*16;

        if (!(canStand()||hangAtPole())) // Cannot hold on: so fall.
        initFall (FALL2, FALLDELAY);
        else
        status = STANDING;       // Else, stand.
    }
    }
    else {
    status = STANDING;      // Just turn the figure around.
    }
}

void KGrFigure::initFall(int apm, int FALLDELAY)
{
  status = FALLING;
  actualPixmap = apm;
  walkCounter=1;
  walkTimer->stop();
  fallTimer->setSingleShot( true );
  fallTimer->start((FALLDELAY * NSPEED) / speed);
}

void KGrFigure::showFigure ()
{
}

void KGrFigure::setPlayfield (KGrObject * (*p)[30][22])
{
  playfield = p;
}

KGrFigure :: ~KGrFigure ()
{
}

KGrHero :: KGrHero (KGrCanvas * view, int x, int y)
  :KGrFigure (x, y)
{
  heroView = view;
  status = STANDING;
  actualPixmap = FALL1;

  herox = x;
  heroy = y;

  started = false;
  mouseMode = true;
  walkCounter = 1;

  walkFrozen = false;
  fallFrozen = false;
  alternateStepGraphics = false;

  connect (walkTimer, SIGNAL (timeout ()), SLOT (walkTimeDone ()));
  connect (fallTimer, SIGNAL (timeout ()), SLOT (fallTimeDone ()));
}

int KGrHero::WALKDELAY = 0;
int KGrHero::FALLDELAY = 0;

/* It is necessary to execute startWalk before the timer-function code, in order
   to take changes of direction into account when doing the animation steps.
*/
void KGrHero::startWalk ()
{
  switch (nextDir) {
    case UP:
      if ((*playfield)[x][y]->whatIam () == LADDER)
    {walkCounter = 1;
    direction = UP;}
      break;
    case RIGHT:
      if (hangAtPole()) 
    actualPixmap = (alternateStepGraphics) ? RIGHTCLIMB5 : RIGHTCLIMB1;
       else 
    actualPixmap = (alternateStepGraphics) ? RIGHTWALK5 : RIGHTWALK1;
      if (direction != RIGHT)
    walkCounter = 0;
      else
    walkCounter = 1;
      direction = RIGHT;
      break;
    case DOWN:
      if (((*playfield)[x][y]->whatIam () == LADDER)||
      ((*playfield)[x][y+1]->whatIam () == LADDER))
    {walkCounter = 1;
    direction = DOWN;}
      else          // If the hero is hanging from a pole and there
                // is nothing to stand on, let him fall.
    if (hangAtPole() && (!canStand()))
      { status = STANDING;
      actualPixmap = (direction==RIGHT)?FALL2:FALL1;
      walkCounter=1;
      direction=STAND;
      walkTimer->stop();
      }
      break;
    case LEFT:
      if (hangAtPole())
    actualPixmap = (alternateStepGraphics) ? LEFTCLIMB5 : LEFTCLIMB1;
      else
    actualPixmap = (alternateStepGraphics) ? LEFTWALK5 : LEFTWALK1;
      if (direction != LEFT)
    walkCounter = 0;
      else
    walkCounter = 1;
      direction = LEFT;
      break;
    default :
      direction = STAND;
      status = FALLING;
      break;
    }
  nextDir = STAND;
  if (status != FALLING)    // Always execute, unless we are falling, in
    { status = WALKING;     // which case the state change would be wrong
    showFigure ();      // and the wrong timer would be triggered.
    }
} // END KGrHero::startWalk

void KGrHero::setKey(Direction key)
{
    // Keyboard control of hero: direction is fixed until next key is pressed.
    // Sets a simulated mouse-pointer above, below, left, right or on the hero.
    mouseMode = false;
    stopped = false;
    switch (key) {
    case UP:    mousex = x; mousey = 0; break;
    case DOWN:  mousex = x; mousey = FIELDHEIGHT + 1; break;
    case LEFT:  mousex = 0; mousey = y; break;
    case RIGHT: mousex = FIELDWIDTH + 1; mousey = y; break;
    case STAND: stopped = true;  mousex = x; mousey = y; break;
    }
}

void KGrHero::setDirection(int i, int j)
{
    // Mouse control of hero: direction is updated continually on a timer.
    mouseMode = true;
    stopped = false;
    mousex = i;
    mousey = j;
}

void KGrHero::setNextDir()
{
    int dx, dy;

    if (! mouseMode) {
    // Keyboard control of hero: adjust simulated mouse-pointer.
    if (stopped) {
        mousex = x;
        mousey = y;
    }
    if ((mousey < 1) || (mousey > FIELDHEIGHT)) {
        mousex = x;     // Stay directly above/below the hero.
    }
    else if ((mousex < 1) || (mousex > FIELDWIDTH)) {
        mousey = y;     // Stay directly left/right of the hero.
    }
    }

    dx = mousex - x; dy = mousey - y;

    if ((dy == 0) && (y == 1) && (nuggets <= 0)) {
    nextDir = UP;
    }
    else if ((dy > 0) &&
         (canWalkDown() ||
          // Trial fix, 10 Aug 07.  Removing the next test makes enemies
          // behave like bricks if you are standing, walking or falling on
          // their heads.  So you cannot die when walking over a trapped
          // enemy in mouse-mode, preventing a common beginner's problem.
          // standOnEnemy() ||
          (hangAtPole() && ((*playfield)[x][y+1]->whatIam() != BRICK) &&
                   ((*playfield)[x][y+1]->whatIam() != BETON)))) {
    nextDir = DOWN;
    }
    else if ((dy < 0) && canWalkUp ()) {
    nextDir = UP;
    }
    else if (dx > 0) {
    nextDir = RIGHT;
    }
    else if (dx < 0) {
    nextDir = LEFT;
    }
    else if (dx == 0) {
    nextDir = STAND;
    }
}

void KGrHero::doStep() {
    if (walkFrozen) {
    walkFrozen = false;
    walkTimeDone();
    }
    if (fallFrozen) {
    fallFrozen = false;
    fallTimeDone();
    }
}

void KGrHero::showState(char option)
{
  printf("(%02d,%02d) - Hero      ", x, y);
  switch (option) {
      case 'p': printf ("\n"); break;
      case 's': printf (" nuggets %02d status %d walk-ctr %d ",
            nuggets, status, walkCounter);
        printf ("dirn %d next dirn %d\n", direction, nextDir);
        printf ("                     rel (%02d,%02d) abs (%03d,%03d)",
            relx, rely, absx, absy);
        printf (" pix %02d", actualPixmap);
        printf (" mem %d %d %d %d", mem_x, mem_y, mem_relx, mem_rely);
        if (walkFrozen) printf (" wBlock");
        if (fallFrozen) printf (" fBlock");
        printf ("\n");
        break;
  }
}

void KGrHero::init(int a,int b)
{
    walkTimer->stop();
    fallTimer->stop();
    walkCounter = 1;
    started = false;

    x = mem_x = a;
    y = mem_y = b;
    relx = mem_relx = 0;
    rely = mem_rely = 0;

    absx = 16*x;
    absy = 16*y;

    nuggets = 0;

    if (herox < 1) {                // If first call to init, ...
    heroView->makeHeroSprite (x, y, actualPixmap);
    }
    herox = x;
    heroy = y;

    actualPixmap = FALL2;
    heroView->moveHero (absx, absy, actualPixmap);
}

void KGrHero::start()
{
    started = true;
    walkFrozen = false;
    fallFrozen = false;

    if (!(canStand()||hangAtPole())) {      // Hero must fall ...
    status = FALLING;
    fallTimeDone();
    }
    else {
    status = STANDING;
    walkTimeDone();
    }
}

void KGrHero::setSpeed (int gamespeed)
{
  if (gamespeed >= 0) {
    if (gamespeed < MINSPEED)
    speed++;        // Increase speed.
    else
    speed = gamespeed;  // Set selected speed.
    if (speed > MAXSPEED)
    speed = MAXSPEED;   // Set upper limit.
  }
  else {
    speed--;            // Reduce speed.
    if (speed < MINSPEED)
    speed = MINSPEED;   // Set lower limit.
  }

  KGrBrick::speed = speed;  // Make a copy for bricks.
}

void KGrHero::walkTimeDone ()
{
  if (! started) return;    // Ignore signals from earlier play.
  if (KGrObject::frozen) {walkFrozen = true; return; }

  if ((*playfield)[x][y]->whatIam() == BRICK) {
    emit caughtHero();      // Brick closed over hero.
    return;
  }

  if ((y==1)&&(nuggets<=0)) {   // If on top row and all nuggets collected,
    emit leaveLevel();      // the hero has won and can go to next level.
    return;
  }

  if (status == STANDING)
    setNextDir();
  if ((status == STANDING) && (nextDir != STAND)) {
    if ((standOnEnemy()) && (nextDir == DOWN)) {
    emit caughtHero();  // Hero is going to step down into an enemy.
    return;
    }
    startWalk();
  }
  if (status != STANDING) {
      switch (direction) {
      case UP:      walkUp (WALKDELAY); break;
      case DOWN:    walkDown (WALKDELAY, FALLDELAY); break;
      case RIGHT:   walkRight (WALKDELAY, FALLDELAY); break;
      case LEFT:    walkLeft (WALKDELAY, FALLDELAY); break;
      default :
    // The following code is strange.  It makes the hero fall off a pole.
    // It works because of other strange code in "startWalk(), case DOWN:".
    if (!canStand()||hangAtPole()) // falling
      initFall(FALL1, FALLDELAY);
    else  status = STANDING;
      break;
      }
    herox=x; heroy=y;           // Set the hero's new position.
    if ((relx==0)&&(rely==0)) {     // If he has just completed a move, see
      collectNugget();          // if there is a nugget to collect.
      }
  }
  if (status == STANDING)
    if (!canStand()&&!hangAtPole())
      initFall(FALL1, FALLDELAY);
    else
    {
        walkTimer->setSingleShot( true );
        walkTimer->start ((WALKDELAY * NSPEED) / speed);
    }

  // This additional showFigure() is to update the hero position after it is
  // altered by the hero-enemy deadlock fix in standOnEnemy().  Messy, but ...
  showFigure();
  if(isInEnemy()) {
    walkTimer->stop();
    emit caughtHero();
  }
}

void KGrHero::fallTimeDone()
{
    if (! started) return;      // Ignore signals from earlier play.
    if (KGrObject::frozen) {fallFrozen = true; return; }

    if (!standOnEnemy()) {
    if (walkCounter++ < gameCycle) {// The hero must fall four steps.
        fallTimer->setSingleShot(true);
        fallTimer->start((FALLDELAY * NSPEED) / speed);
        rely+=STEP;
        absy+=STEP;
    }
    else {              // When done, move to the start position
                    // of the next object (brick, etc.).
        heroy = ++y;
        rely = 0;
        absy = y*16;
        collectNugget();        // See if there is a nugget to collect.
        if (! (canStand()||hangAtPole())) { // The hero goes on falling.
        fallTimer->setSingleShot(true);
        fallTimer->start((FALLDELAY * NSPEED) / speed);
        walkCounter = 1;
        }
        else {          // The hero can stand or hang on a pole,
        status = STANDING;  // so change his state to STANDING.
        walkTimer->setSingleShot(true);
        walkTimer->start((WALKDELAY * NSPEED) / speed);
        direction = (actualPixmap == FALL2) ? RIGHT : LEFT;
        if ((*playfield)[x][y]->whatIam() == POLE)
            actualPixmap = (direction == RIGHT)? RIGHTCLIMB1:LEFTCLIMB1;
        // else
            // Reduce jerkiness when descending over a falling enemy.
            // actualPixmap = (direction == RIGHT)? RIGHTWALK1:LEFTWALK1;
        }
    }
    showFigure();
    }
    else {
    if (rely == 0) {
        // If at the bottom of a cell, try to walk or just stand still.
        status = STANDING;
        direction = (actualPixmap == FALL2) ? RIGHT : LEFT;
        if ((*playfield)[x][y]->whatIam() == POLE)
        actualPixmap = (direction == RIGHT)? RIGHTCLIMB1:LEFTCLIMB1;
        // else
        // Reduce jerkiness when descending over a falling enemy.
        // actualPixmap = (direction == RIGHT)? RIGHTWALK1:LEFTWALK1;
        walkTimer->setSingleShot( true );
        walkTimer->start((WALKDELAY * NSPEED) / speed);
    }
    else {
        // Else, freeze hero until enemy moves out of the way.
        fallTimer->setSingleShot(true);
        fallTimer->start((FALLDELAY * NSPEED) / speed);
    }
    }
    if (isInEnemy() && (! standOnEnemy()))
    emit caughtHero();
}


void KGrHero::showFigure () {

  heroView->moveHero (absx, absy, actualPixmap);

  // Save old values for when we delete the figure from its old position later.
  mem_x = x;
  mem_y = y;
  mem_relx = relx;
  mem_rely = rely;
}

void KGrHero::dig(){
  if (direction == LEFT)
    digLeft();
  else
    if (direction == RIGHT)
      digRight();
}

void KGrHero::digLeft(){
  int i = 1;        // If stationary or moving up/down, dig at x-1.
  if (status == STANDING)
      setNextDir();
  if ((status == WALKING) ||
      ((status == STANDING) && ((nextDir == LEFT) || (nextDir == RIGHT)))) {
      if ((direction == LEFT) && canWalkLeft())
          i = 2;    // If walking left, dig at x-2 and stop at x-1.
      else if ((direction == RIGHT) && canWalkRight())
          i = 0;    // If walking right, dig at x and stop at x+1.
  }
  if (((*playfield)[x-i][y+1]->whatIam() == BRICK)&&
      (((*playfield)[x-i][y]->whatIam() == HLADDER)||
       ((*playfield)[x-i][y]->whatIam() == FREE)||
       ((*playfield)[x-i][y]->whatIam() == HOLE)))
    ((KGrBrick*)(*playfield)[x-i][y+1])->dig();
}

void KGrHero::digRight(){
  int i = 1;        // If stationary or moving up/down, dig at x+1.
  if (status == STANDING)
      setNextDir();
  if ((status == WALKING) ||
      ((status == STANDING) && ((nextDir == LEFT) || (nextDir == RIGHT)))) {
      if ((direction == LEFT) && canWalkLeft())
          i = 0;    // If walking left, dig at x and stop at x-1.
      else if ((direction == RIGHT) && canWalkRight())
          i = 2;    // If walking right, dig at x+2 and stop at x+1.
  }
  if (((*playfield)[x+i][y+1]->whatIam() == BRICK)&&
      (((*playfield)[x+i][y]->whatIam() == HLADDER)||
       ((*playfield)[x+i][y]->whatIam() == FREE)||
       ((*playfield)[x+i][y]->whatIam() == HOLE)))
    ((KGrBrick*)(*playfield)[x+i][y+1])->dig();
}

void KGrHero::setEnemyList(QList<KGrEnemy *> * e)
{
  enemies = e;
}

bool KGrHero::standOnEnemy()
{
    int c = 0;
    int range = enemies->count();
    if (range > 0) {
    for (KGrEnemy * enemy = enemies->at (c); c < range;  ) {
        enemy = enemies->at(c++);
        // Test if hero's foot is at or just below enemy's head (tolerance
        // of 4 pixels) and the two figures overlap in the X direction.
        if ((((absy + 16) == enemy->gety()) ||
         ((absy + 12) == enemy->gety())) &&
        (((absx - 16) <  enemy->getx()) &&
         ((absx + 16) >  enemy->getx()))) {
                if (((absy + 12) == enemy->gety()) &&
                    (enemy->getStatus() != FALLING)) {
                    absy = absy - rely; // Bounce back from overlap, to avoid
                    rely = 0;           // hero-enemy mid-cycle deadlock.
                    walkCounter = 1;
        }
        return true;
        }
    }
    }
    return false;
}

void KGrHero::collectNugget(){

  if ((*playfield)[x][y]->whatIam() == NUGGET)
    {
      ((KGrFree *)(*playfield)[x][y])->setNugget(false);
      if (!(--nuggets))
    emit haveAllNuggets();  // Tell the application that all the nuggets are
                // gone, so that it can show the hidden ladders.
      emit gotNugget(250);  // Tell the application to increase the score.

    }
}

void KGrHero::loseNugget() {

    // Enemy trapped or dead and could not drop nugget (NO SCORE for this).
    if (! (--nuggets))
    emit haveAllNuggets();  // Tell the application that all the nuggets are
                // gone, so that it can show the hidden ladders.
}

bool KGrHero::isInEnemy(){

  int c=0;
  int range=enemies->count();
  if (range)
    for (KGrEnemy *enemy=enemies->at(c);c<range; )
      {enemy = enemies->at(c++);
      if (isInside(enemy->getx(),enemy->gety())||
      isInside(enemy->getx()-15,enemy->gety())||
      isInside(enemy->getx(),enemy->gety()-15))
    return true;}
  return false;
}

bool KGrHero::isInside(int enemyx, int enemyy){

 return ((absx >= enemyx)&&
      (absx <= enemyx+15)&&
      (absy >= enemyy)&&
      (absy