changed keys

1 files changed, 7 insertions, 2 deletions

diff --git a/noncore/games/kpacman/referee.cpp b/noncore/games/kpacman/referee.cpp
index 9edaabd..70916f0 100644
--- a/noncore/games/kpacman/referee.cpp
+++ b/noncore/games/kpacman/referee.cpp
@@ -605,473 +605,478 @@ void Referee::confTiming(bool defGroup)
         introPostAnimationMS = cfg->readNumEntry("IntroPostAnimationMS", 1000);
     if (defGroup || cfg->hasKey("LevelUpPreAnimationMS"))
         levelUpPreAnimationMS = cfg->readNumEntry("LevelUpPreAnimationMS", 2000);
     if (defGroup || cfg->hasKey("LevelUpAnimationMS"))
         levelUpAnimationMS = cfg->readNumEntry("LevelUpAnimationMS", 2000);
     if (defGroup || cfg->hasKey("EnergizerAnimationMS"))
         energizerAnimationMS = cfg->readNumEntry("EnergizerAnimationMS", 200);
     APP_CONFIG_END( cfg );
 }
 
 void Referee::confScoring(bool defGroup)
 {
     APP_CONFIG_BEGIN( cfg );
     if (defGroup || cfg->hasKey("PointScore"))
         pointScore = cfg->readNumEntry("PointScore", 10);
     if (defGroup || cfg->hasKey("EnergizerScore"))
         energizerScore = cfg->readNumEntry("EnergizerScore", 50);
     if (defGroup || cfg->hasKey("FruitScore"))
         fillArray(fruitScore, cfg->readEntry("FruitScore", "100,300,500,,700,,1000,,2000,,3000,,5000"), maxLevel+1);
     if (defGroup || cfg->hasKey("MonsterScore"))
         fillArray(monsterScore, cfg->readEntry("MonsterScore", "200,400,800,1600"), 4);
     if (defGroup || cfg->hasKey("ExtraLifeScore"))
         fillArray(extraLifeScore, cfg->readEntry("ExtraLifeScore", "10000"), -1);
     APP_CONFIG_END( cfg );
 }
 
 void Referee::confScheme()
 {
     APP_CONFIG_BEGIN( cfg );
     SAVE_CONFIG_GROUP( cfg, oldgroup );
     QString newgroup;
 
     // if not set, read mode and scheme from the configfile
     if (mode == -1 && scheme == -1) {
         scheme = cfg->readNumEntry("Scheme", -1);
         mode = cfg->readNumEntry("Mode", -1);
 
         // if mode is not set in the defGroup-group, lookup the scheme group
         if (scheme != -1 || mode == -1) {
             newgroup.sprintf("Scheme %d", scheme);
             cfg->setGroup(newgroup);
 
             mode = cfg->readNumEntry("Mode", -1);
             RESTORE_CONFIG_GROUP( cfg, oldgroup );
         }
     }
 
     confLevels();
 
     if (mode != -1) {
         newgroup.sprintf("Mode %d", mode);
         cfg->setGroup(newgroup);
 
         confLevels(FALSE);
     }
 
     if (scheme != -1) {
         newgroup.sprintf("Scheme %d", scheme);
         cfg->setGroup(newgroup);
 
         confLevels(FALSE);
     }
 
     RESTORE_CONFIG_GROUP( cfg, oldgroup );
 
     confMisc();
     confTiming();
     confScoring();
 
     if (mode != -1) {
         newgroup.sprintf("Mode %d", mode);
         cfg->setGroup(newgroup);
 
         confMisc(FALSE);
         confTiming(FALSE);
         confScoring(FALSE);
     }
 
     if (scheme != -1) {
         newgroup.sprintf("Scheme %d", scheme);
         cfg->setGroup(newgroup);
 
         confMisc(FALSE);
         confTiming(FALSE);
         confScoring(FALSE);
     }
 
     fillMapName();
 
     RESTORE_CONFIG_GROUP( cfg, oldgroup );
     APP_CONFIG_END( cfg );
 }
 
 void Referee::setScheme(int Scheme, int Mode, Bitfont *font)
 {
     mode = Mode;
     scheme = Scheme;
 
     confScheme();
 
     pix->setScheme(scheme, mode, font);
 
     pacman->setMaxPixmaps(pix->maxPixmaps(PacmanPix));
     fruit->setMaxPixmaps(pix->maxPixmaps(FruitPix));
 
     for (Monster *m = monsters->first(); m != 0; m = monsters->next())
         if (m)
             m->setMaxPixmaps(pix->maxPixmaps(MonsterPix), pix->maxPixmaps(EyesPix));
 
     for (Energizer *e = energizers->first(); e != 0; e = energizers->next())
         if (e)
             e->setMaxPixmaps(pix->maxPixmaps(EnergizerPix));
 
     if (gameState.testBit(Introducing))
         for (int i = 0; i < (gameState.testBit(Init) ? timerCount : 15); i++)
             introPaint(i);
 
     setFixedSize(pix->levelPix().size());
     repaint();
 }
 
 void Referee::keyPressEvent( QKeyEvent *k )
 {
     uint key = k->key();
 #ifdef QWS
     // "OK" => new game
     if ( key == Key_F33 || key == Key_F2 || key == Key_Enter )
         play();
-    else if ( !gameState.testBit(Playing) && key == Key_Space )
+    else if ( !gameState.testBit(Playing) &&
+                                                key == Key_Up ||
+                                key == Key_Down ||
+                                key == Key_Right ||
+                                key == Key_Left ) 
         play();
     // "Space" => pause
     //else if ( key == Key_Space || key == Key_F3 )
     //    pause();
     // "Menu" => hall of fame
     //else if ( key == Key_F11 || key == Key_F4 )
     //    toggleHallOfFame();
 #endif
 
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame) ||
         gameState.testBit(Demonstration) || gameState.testBit(Dying) ||
         gameState.testBit(Ready) || gameState.testBit(LevelDone) ||
         !gameState.testBit(Playing))
         return;
 
     if (key == UpKey)
         pacman->setDirection(N);
     else if (key == DownKey)
         pacman->setDirection(S);
     else if (key == RightKey)
         pacman->setDirection(E);
     else if (key == LeftKey)
         pacman->setDirection(W);
 
 #ifdef CHEATS
     else if (key == Key_L) { printf("levelUp()\n"); levelUp(); }
     else if (key == Key_F) { printf("fruit->move(TRUE)\n"); fruit->move(TRUE); repaint(FALSE); }
     else if (key == Key_E) { printf("setLifes(++lifes)\n"); emit setLifes(++lifes); }
 #endif
 
     else {
         k->ignore();
         return;
     }
     k->accept();
 }
 
 void Referee::score(int p)
 {
     if (!gameState.testBit(Playing))
         return;
 
     if ((points += p) < 0)
         points = 0;
 
     emit setPoints(points);
 
     if (points >= nextExtraLifeScore) {
         emit setLifes(++lifes);
         if (extraLifeScoreIndex < (int) extraLifeScore.size()-1)
             extraLifeScoreIndex++;
         if (extraLifeScore[extraLifeScoreIndex] < 0)
             nextExtraLifeScore = extraLifeScore[extraLifeScoreIndex] * -1;
         else
             nextExtraLifeScore += extraLifeScore[extraLifeScoreIndex];
     }
 }
 
 void Referee::eaten()
 {
     if (gameState.testBit(Ready))
         return;
 
     stop();
 
     if (monstersEaten < 4)
         monstersEaten++;
 
     gameState.setBit(Scoring);
     score(monsterScore[monstersEaten-1]);
 
     repaint(pix->rect(pix->rect(pacman->position(), MonsterPix),
                       pix->rect(pacman->position(), MonsterScorePix, monstersEaten-1)));
 
     if (--timerCount > 0)
         QTimer::singleShot( monsterScoreDurMS, this, SLOT(eaten()));
     else {
         for (Monster *m = monsters->first(); m != 0; m = monsters->next())
             if (m && m->direction() == X && !gameState.testBit(Introducing))
                 m->setDirection(N);
         if (monstersEaten != 4 || !gameState.testBit(Introducing))
             QTimer::singleShot( monsterScoreDurMS, this, SLOT(start()));
     }
 }
 
 void Referee::toggleHallOfFame()
 {
     gameState.toggleBit(HallOfFame);
 }
 
 void Referee::hallOfFame()
 {
     if (gameState.testBit(HallOfFame))  // If the HallOfFame is switched on manually, toggle the
         toggleHallOfFame();             // bit twice.
 
     emit setLevel(0);                   // Clear status display for hall of fame
     emit setScore(level, 0);
     emit forcedHallOfFame(TRUE);
 }
 
 void Referee::pause()
 {
     static int pausedTimer = 0;
 
     if (!gameState.testBit(Paused)) {
         pausedTimer = gameTimer;
         stop();
         stopEnergizer();
         gameState.setBit(Paused);
         repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, tr("PAUSED")), FALSE);
     } else {
         gameState.clearBit(Paused);
         repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, tr("PAUSED")), FALSE);
         if (pausedTimer) {
             pausedTimer = 0;
             start();
         }
     }
     emit togglePaused();
 }
 
 void Referee::intro()
 {
     stop();
     stopEnergizer();
     bool paused = gameState.testBit(Paused);
 
     gameState.fill(FALSE);
     gameState.setBit(Introducing);
     gameState.setBit(Init);
 
     if (paused)
         gameState.setBit(Paused);
 
     level = 0;
     emit setLevel(level);
 
     board->init(Intro);
     pix->setLevel(level);
 
     initPacman();
     initFruit();
     initMonsters();
     initEnergizers();
 
     repaint();
 
     monstersEaten = 0;
     timerCount = 0;
     introPlay();
 }
 
 void Referee::introMonster(int id)
 {
     Monster *m = new Monster(board, id);
 
     m->setPosition((10+id*6)*BoardWidth+10);
     m->setDirection(E);
     m->setDangerous(dangerousTicks[level], monsterIQ[level]);
     m->setMaxPixmaps(pix->maxPixmaps(MonsterPix), pix->maxPixmaps(EyesPix));
 
     if (m->body() != -1)
         pix->draw(m->position(), RoomPix, MonsterPix, m->body());
     if (m->eyes() != -1)
         pix->draw(m->position(), RoomPix, EyesPix, m->eyes());
 
     repaint(pix->rect(m->position(), MonsterPix), FALSE);
     m->setPosition(OUT);
 }
 
 void Referee::introPaint(int t)
 {
     QString pts;
 
     switch (t) {
         case  0 : repaint(pix->draw(16, 6, RoomPix, tr("CHARACTER"), WHITE, QColor(), AlignLeft), FALSE);
                   repaint(pix->draw(36, 6, RoomPix, tr("/"), WHITE, QColor(), AlignLeft), FALSE);
                   repaint(pix->draw(40, 6, RoomPix, tr("NICKNAME"), WHITE, QColor(), AlignLeft), FALSE);
                   break;
         case  1 : introMonster(0);
                   break;
         case  2 : repaint(pix->draw(16, 10, RoomPix, tr("-SHADOW"), RED, QColor(), AlignLeft), FALSE);
                   break;
         case  3 : repaint(pix->draw(38, 10, RoomPix, tr("\"BLINKY\""), RED, QColor(), AlignLeft), FALSE);
                   break;
         case  4 : introMonster(1);
                   break;
         case  5 : repaint(pix->draw(16, 16, RoomPix, tr("-SPEEDY"), PINK, QColor(), AlignLeft), FALSE);
                   break;
         case  6 : repaint(pix->draw(38, 16, RoomPix, tr("\"PINKY\""), PINK, QColor(), AlignLeft), FALSE);
                   break;
         case  7 : introMonster(2);
                   break;
         case  8 : repaint(pix->draw(16, 22, RoomPix, tr("-BASHFUL"), CYAN, QColor(), AlignLeft), FALSE);
                   break;
         case  9 : repaint(pix->draw(38, 22, RoomPix, tr("\"INKY\""), CYAN, QColor(), AlignLeft), FALSE);
                   break;
         case 10 : introMonster(3);
                   break;
         case 11 : repaint(pix->draw(16, 28, RoomPix, tr("-POKEY"), ORANGE, QColor(), AlignLeft), FALSE);
                   break;
         case 12 : repaint(pix->draw(38, 28, RoomPix, tr("\"CLYDE\""), ORANGE, QColor(), AlignLeft), FALSE);
                   break;
         case 13 : pts.sprintf("%d", pointScore);
                   repaint(pix->draw(28, 44, RoomPix, pts.data(), WHITE, QColor(), AlignRight), FALSE);
                   repaint(pix->draw(31, 44, RoomPix, "\x1C\x1D\x1E", WHITE, QColor(), AlignLeft), FALSE);
                   pts.sprintf("%d", energizerScore);
                   repaint(pix->draw(28, 48, RoomPix, pts.data(), WHITE, QColor(), AlignRight), FALSE);
                   repaint(pix->draw(31, 48, RoomPix, "\x1C\x1D\x1E", WHITE, QColor(), AlignLeft), FALSE);
                   break;
         case 14 : // "@ 1980 MIDWAY MFG.CO."
 #if defined( KDE2_PORT )
                   repaint(pix->draw(30, 58, RoomPix, "© 1998-2002 J.THÖNNISSEN", PINK), FALSE);
 #elif defined( QPE_PORT )
                   repaint(pix->draw(30, 55, RoomPix, "© 1998-2002 J.THÖNNISSEN", PINK), FALSE);
-                  repaint(pix->draw(29, 60, RoomPix, "Qtopia port: Catalin CLIMOV", GREEN), FALSE);
+                  repaint(pix->draw(29, 58, RoomPix, tr("QTOPIA PORT: CATALIN CLIMOV"), GREEN), FALSE);
+                  repaint(pix->draw(29, 61, RoomPix, tr("PRESS CURSOR TO START"), GREEN), FALSE);
 #endif
                   break;
     }
 }
 
 void Referee::introPlay()
 {
     if (!gameState.testBit(Introducing) || gameState.testBit(Ready))
         return;
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
         QTimer::singleShot(afterPauseMS, this, SLOT(introPlay()));
         return;
     }
 
     if (!gameState.testBit(Init)) {
         if (monstersEaten == 4) {
             stop();
             QTimer::singleShot(introPostAnimationMS, this, SLOT(demo()));
         }
         if (pacman->direction() == W) {
             int id = -1;
             if (pacman->position() == 37*BoardWidth-6)
                 id = 0;
             else
                 if (board->isMonster(37*BoardWidth-6))
                     for (Monster *m = monsters->first(); m != 0; m = monsters->next())
                         if (m && m->position() == 37*BoardWidth-6) {
                             id = m->id();
                             id++;
                             break;
                         }
                 
             if (id >= 0 && id <= 4)
                 for (Monster *m = monsters->first(); m != 0; m = monsters->next())
                     if (m && m->id() == id && m->position() == OUT) {
                         m->setPosition(37*BoardWidth-1);
                         m->setDirection(W);
                         m->setDangerous(dangerousTicks[level], monsterIQ[level]);
                         board->set(37*BoardWidth-1, monsterhome, id);
                         repaint(pix->rect(m->position(), MonsterPix));
                         break;
                     }
         }
         return;
     }
 
     if (timerCount < 15)
         introPaint(timerCount);
 
     switch (timerCount) {
         case 13 : board->set(44*BoardWidth+22, Point);
                   pix->drawPoint(44*BoardWidth+22);
                   repaint(pix->rect(44*BoardWidth+22, PointPix), FALSE);
                   energizers->at(0)->setPosition(48*BoardWidth+22);
                   energizers->at(0)->setOn();
                   repaint(pix->rect(48*BoardWidth+22, EnergizerPix), FALSE);
                   break;
         case 14 : energizers->at(1)->setPosition(36*BoardWidth+10);
                   energizers->at(1)->setOn();
                   repaint(pix->rect(36*BoardWidth+10, EnergizerPix), FALSE);
                   for (int pos = 8; pos < BoardWidth; pos++) {
                       board->set(34*BoardWidth+pos, out);
                       board->set(38*BoardWidth+pos, out);
                   }
                   board->set(36*BoardWidth+8, out);
                   break;
         case 15 : gameState.clearBit(Init);
                   initPacman();
                   pacman->setDemo(TRUE);
                   pacman->setPosition(37*BoardWidth-1);
                   repaintFigures();
                   start();
                   return;               
     }
 
     if (timerCount++ < 15)
         QTimer::singleShot(introAnimationMS, this, SLOT(introPlay()));
 }
 
 void Referee::demo()
 {
     if (gameState.testBit(Ready))
         return;
 
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {   
         QTimer::singleShot(afterPauseMS, this, SLOT(demo()));
         return;
     }
 
     stop();
     stopEnergizer();
 
     gameState.fill(FALSE);
     gameState.setBit(Init);
     gameState.setBit(Demonstration);
 
     level = 0;
     emit setLevel(level);
 
     board->init(Demo, mapName.at(0));
     pix->setLevel(level);
 
     initPacman();
     initFruit();
     initMonsters();
     initEnergizers();
 
     gameState.clearBit(Init);
 
     repaint();
 
     timerCount = 0;
     QTimer::singleShot(playerDurMS, this, SLOT(start()));
 }
 
 void Referee::play()
 {
     stop();
     stopEnergizer();
 
     gameState.fill(FALSE);
     gameState.setBit(Init);
     gameState.setBit(Playing);
     gameState.setBit(Player);
     gameState.setBit(Ready);
 
     lifes = 3;
     level = 1;