summaryrefslogtreecommitdiffstats
path: root/tdepacman/referee.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tdepacman/referee.cpp')
-rw-r--r--tdepacman/referee.cpp1393
1 files changed, 1393 insertions, 0 deletions
diff --git a/tdepacman/referee.cpp b/tdepacman/referee.cpp
new file mode 100644
index 0000000..1f4e2bc
--- /dev/null
+++ b/tdepacman/referee.cpp
@@ -0,0 +1,1393 @@
+#include <stdlib.h>
+
+#include <kapp.h>
+#include <kstddirs.h>
+
+#include <tdeconfig.h>
+#include <tqdatetm.h>
+#include <tqtimer.h>
+#include <tqevent.h>
+#include <tqcolor.h>
+#include <tqkeycode.h>
+#include <tqfileinfo.h>
+#include <tdeaccel.h>
+
+#include "referee.h"
+#include "board.h"
+#include "pacman.h"
+#include "monster.h"
+#include "fruit.h"
+#include "painter.h"
+
+Referee::Referee( TQWidget *parent, const char *name, int Scheme, int Mode, Bitfont *font)
+ : TQWidget( parent, name )
+{
+ gameState.resize(12);
+ gameTimer = 0;
+ energizerTimer = 0;
+
+ focusedPause = false;
+ setFocusPolicy(TQWidget::StrongFocus);
+
+ initKeys();
+
+ scheme = Scheme;
+ mode = Mode;
+ confScheme();
+
+ board = new Board(BoardWidth*BoardHeight);
+
+ pix = new Painter(board, this, scheme, mode, font);
+ setFixedSize(pix->levelPix().size());
+
+ pacman = new Pacman(board);
+
+ fruit = new Fruit(board);
+
+ monsters = new TQPtrList<Monster>;
+ monsters->setAutoDelete(TRUE);
+
+ monsterRect = new TQPtrList<TQRect>;
+ monsterRect->setAutoDelete(TRUE);
+
+ energizers = new TQPtrList<Energizer>;
+ energizers->setAutoDelete(TRUE);
+
+ energizerRect = new TQPtrList<TQRect>;
+ energizerRect->setAutoDelete(TRUE);
+
+ pacmanRect.setRect(0, 0, 0, 0);
+ fruitRect.setRect(0, 0, 0, 0);
+
+ TQTime midnight( 0, 0, 0 );
+ srand( midnight.secsTo(TQTime::currentTime()) );
+
+ lifes = 0;
+ points = 0;
+
+ emit setLifes(lifes);
+ emit setPoints(points);
+
+ intro();
+}
+
+void Referee::paintEvent( TQPaintEvent *e)
+{
+ if (gameState.testBit(HallOfFame))
+ return;
+
+ TQRect rect = e->rect();
+
+ if (!rect.isEmpty()) {
+ TQPixmap p = pix->levelPix();
+ bitBlt(this, rect.x(), rect.y(),
+ &p, rect.x(), rect.y(), rect.width(), rect.height());
+ }
+
+ if ((gameState.testBit(GameOver) || gameState.testBit(Demonstration)) &&
+ rect.intersects(pix->rect(board->position(fruithome), i18n("GAME OVER"))))
+ pix->draw(board->position(fruithome), Widget, i18n("GAME OVER"), RED);
+
+ for (Energizer *e = energizers->first(); e != 0; e = energizers->next()) {
+ if (e && e->state() == on &&
+ rect.intersects(pix->rect(e->position(), EnergizerPix)) &&
+ !(e->position() == pacman->position() && gameState.testBit(Scoring))) {
+ if (e->pix() != -1)
+ pix->draw(e->position(), Widget, EnergizerPix, e->pix());
+ }
+ }
+
+ if (!gameState.testBit(Init)) {
+
+ if (!gameState.testBit(Dying) && (fruit->pix() != -1))
+ if (fruit->state() != active) {
+ if (rect.intersects(pix->rect(fruit->position(), FruitScorePix, fruit->pix())))
+ pix->draw(fruit->position(), Widget, FruitScorePix, fruit->pix());
+ } else {
+ if (rect.intersects(pix->rect(fruit->position(), FruitPix, fruit->pix())))
+ pix->draw(fruit->position(), Widget, FruitPix, fruit->pix());
+ }
+
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m && m->state() == harmless &&
+ rect.intersects(pix->rect(m->position(), MonsterPix)) &&
+ !(m->position() == pacman->position() && gameState.testBit(Scoring))) {
+ if (m->body() != -1)
+ pix->draw(m->position(), Widget, MonsterPix, m->body());
+ if (m->eyes() != -1)
+ pix->draw(m->position(), Widget, EyesPix, m->eyes());
+ }
+
+ if (!gameState.testBit(Scoring) && !gameState.testBit(LevelDone) &&
+ rect.intersects(pix->rect(pacman->position(), PacmanPix)) && pacman->pix() != -1)
+ pix->draw(pacman->position(), Widget, PacmanPix, pacman->pix());
+
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m && m->state() != harmless &&
+ rect.intersects(pix->rect(m->position(), MonsterPix)) &&
+ !(m->position() == pacman->position() && gameState.testBit(Scoring))) {
+ if (m->body() != -1)
+ pix->draw(m->position(), Widget, MonsterPix, m->body());
+ if (m->eyes() != -1)
+ pix->draw(m->position(), Widget, EyesPix, m->eyes());
+ }
+ }
+
+ if (gameState.testBit(Scoring) &&
+ rect.intersects(pix->rect(pacman->position(), MonsterScorePix, monstersEaten-1)))
+ pix->draw(pacman->position(), Widget, MonsterScorePix, monstersEaten-1);
+
+ if (gameState.testBit(Init) && gameState.testBit(Dying) &&
+ timerCount < pix->maxPixmaps(DyingPix) &&
+ rect.intersects(pix->rect(pacman->position(), PacmanPix)))
+ pix->draw(pacman->position(), Widget, DyingPix, timerCount);
+
+ if (gameState.testBit(LevelDone) &&
+ rect.intersects(pix->rect(pacman->position(), PacmanPix)))
+ pix->draw(pacman->position(), Widget, PacmanPix, pacman->pix());
+
+ if (gameState.testBit(Player) &&
+ rect.intersects(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE"))))
+ pix->draw(board->position(monsterhome, 0), Widget, i18n("PLAYER ONE"), CYAN);
+
+ if (gameState.testBit(Ready) &&
+ rect.intersects(pix->rect(board->position(fruithome), i18n("READY!"))))
+ pix->draw(board->position(fruithome), Widget, i18n("READY!"), YELLOW);
+
+ if (gameState.testBit(Paused) &&
+ rect.intersects(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("PAUSED"))))
+ pix->draw((BoardWidth*BoardHeight)/2-BoardWidth, Widget, i18n("PAUSED"), RED, BLACK);
+}
+
+void Referee::timerEvent( TQTimerEvent *e )
+{
+ if (gameState.testBit(HallOfFame))
+ return;
+
+ TQRect lastRect;
+ int lastPix;
+ bool moved = FALSE;
+ int eated = 0;
+
+ if (e->timerId() == energizerTimer) {
+ for (int e = 0; e < board->energizers(); e++) {
+ lastRect = pix->rect(energizers->at(e)->position(), EnergizerPix);
+ lastPix = energizers->at(e)->pix();
+ if (energizers->at(e)->move()) {
+ moved = TRUE;
+ *energizerRect->at(e) = pix->rect(energizers->at(e)->position(), EnergizerPix);
+ if (lastPix == energizers->at(e)->pix() &&
+ lastRect == pix->rect(energizers->at(e)->position(), EnergizerPix))
+ energizerRect->at(e)->setRect(0, 0, 0, 0);
+ else
+ *energizerRect->at(e) = pix->rect(*energizerRect->at(e), lastRect);
+ }
+ }
+
+ for (int e = 0; e < board->energizers(); e++)
+ if (!energizerRect->at(e)->isNull())
+ repaint(*energizerRect->at(e), FALSE);
+
+ return;
+ }
+
+ timerCount++;
+
+ lastRect = pix->rect(pacman->position(), PacmanPix);
+ lastPix = pacman->pix();
+
+ if (moved = pacman->move()) { // pacman really moved
+ pacmanRect = pix->rect(pacman->position(), PacmanPix);
+ if (lastPix == pacman->pix() &&
+ lastRect == pix->rect(pacman->position(), PacmanPix))
+ pacmanRect.setRect(0, 0, 0, 0); // nothing to do, because the pixmap
+ else // and the position isn't changed.
+ pacmanRect = pix->rect(pacmanRect, lastRect);
+ } else
+ pacmanRect.setRect(0, 0, 0, 0);
+
+ int pos = pacman->position();
+
+ if (moved && board->isMonster(pos) && !gameState.testBit(Dying)) {
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m && m->position() == pos) {
+ if (m->state() == harmless && !gameState.testBit(Dying)) {
+ m->setREM(remTicks[level]);
+ m->setDirection(X); // prevent movement before eaten()
+ eated++;
+ if (gameState.testBit(Introducing))
+ m->setPosition(OUT);
+ }
+ if (m->state() == dangerous && !gameState.testBit(Dying))
+ killed();
+ }
+ }
+
+ if (moved && !gameState.testBit(Dying)) {
+ if (board->isPoint(pos)) {
+ board->reset(pos, Point);
+ score(pointScore);
+ pix->erase(pos, PointPix);
+ }
+ if (board->isEnergizer(pos)) {
+ for (int e = 0; e < board->energizers();e++) {
+ if (energizers->at(e)->position() == pos) {
+ energizers->at(e)->setOff();
+ energizers->remove(e);
+ energizerRect->remove(e);
+ e = board->energizers();
+ }
+ }
+ board->reset(pos, energizer);
+ score(energizerScore);
+ monstersEaten = 0;
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m && m->state() != rem) {
+ m->setHarmless(harmlessTicks[level], harmlessDurTicks[level],
+ harmlessWarnTicks[level]);
+ if (gameState.testBit(Introducing))
+ m->setDirection(board->turn(m->direction()));
+ }
+ }
+ if (pos == fruit->position() && fruit->state() == active) {
+ fruit->setEaten(fruitScoreDurTicks[level]);
+ initFruit(FALSE);
+ score(fruitScore[fruit->pix()]);
+ }
+ }
+
+ if (!gameState.testBit(Introducing)) {
+ if (fruit->state() != active && fruit->pix() >= 0)
+ lastRect = pix->rect(fruit->position(), FruitScorePix, fruit->pix());
+ else
+ lastRect = pix->rect(fruit->position(), FruitPix, fruit->pix());
+
+ lastPix = fruit->pix();
+ if (fruit->move()) {
+ if (pos == fruit->position() && fruit->state() == active) {
+ fruit->setEaten(fruitScoreDurTicks[level]);
+ initFruit(FALSE);
+ score(fruitScore[fruit->pix()]);
+ }
+ if (fruit->state() != active && fruit->pix() >= 0)
+ fruitRect = pix->rect(fruit->position(), FruitScorePix, fruit->pix());
+ else
+ fruitRect = pix->rect(fruit->position(), FruitPix, fruit->pix());
+ if (lastPix == fruit->pix() && lastRect == fruitRect)
+ fruitRect.setRect(0, 0, 0, 0);
+ else
+ fruitRect = pix->rect(fruitRect, lastRect);
+ } else
+ fruitRect.setRect(0, 0, 0, 0);
+ } else
+ fruitRect.setRect(0, 0, 0, 0);
+
+ int lastBodyPix;
+ int lastEyesPix;
+
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m) {
+ lastRect = pix->rect(m->position(), MonsterPix);
+ lastBodyPix = m->body();
+ lastEyesPix = m->eyes();
+ if (m->move()) {
+ moved = TRUE;
+ *monsterRect->at(m->id()) = pix->rect(m->position(), MonsterPix);
+ if (lastBodyPix == m->body() && lastEyesPix == m->eyes() &&
+ lastRect == pix->rect(m->position(), MonsterPix))
+ monsterRect->at(m->id())->setRect(0, 0, 0, 0);
+ else
+ *monsterRect->at(m->id()) = pix->rect(*monsterRect->at(m->id()), lastRect);
+ if (m->position() == pos && !gameState.testBit(Dying)) {
+ if (m->state() == harmless && !gameState.testBit(Dying)) {
+ m->setREM(remTicks[level]);
+ eated++;
+ if (gameState.testBit(Introducing)) {
+ m->setPosition(OUT);
+ m->setDirection(X);
+ }
+ }
+ if (m->state() == dangerous && !gameState.testBit(Dying))
+ killed();
+ }
+ } else
+ monsterRect->at(m->id())->setRect(0, 0, 0, 0);
+ }
+
+ for (int m = 0; m < board->monsters(); m++)
+ if (pacmanRect.intersects(*monsterRect->at(m))) {
+ pacmanRect = pix->rect(pacmanRect, *monsterRect->at(m));
+ monsterRect->at(m)->setRect(0, 0, 0, 0);
+ } else
+ for (int im = m+1; im < board->monsters(); im++)
+ if (monsterRect->at(m)->intersects(*monsterRect->at(im))) {
+ *monsterRect->at(m) = pix->rect(*monsterRect->at(m), *monsterRect->at(im));
+ monsterRect->at(im)->setRect(0, 0, 0, 0);
+ }
+
+ if (!pacmanRect.isNull())
+ repaint(pacmanRect, FALSE);
+
+ if (!fruitRect.isNull())
+ repaint(fruitRect, FALSE);
+
+ for (int m = 0; m < board->monsters(); m++)
+ if (!monsterRect->at(m)->isNull())
+ repaint(*monsterRect->at(m), FALSE);
+
+ if (board->points() == 0 && !gameState.testBit(Dying))
+ levelUp();
+
+ if (eated > 0 && !gameState.testBit(Dying)) {
+ timerCount = eated;
+ eaten();
+ }
+
+ if (gameState.testBit(Introducing) && moved)
+ introPlay();
+}
+
+void Referee::repaintFigures()
+{
+ pacmanRect = pix->rect(pacman->position(), PacmanPix);
+
+ for (int e = 0; e < board->energizers(); e++) {
+ *energizerRect->at(e) = pix->rect(board->position(energizer, e), EnergizerPix);
+
+ if (pacmanRect.intersects(*energizerRect->at(e))) {
+ pacmanRect = pix->rect(pacmanRect, *energizerRect->at(e));
+ energizerRect->at(e)->setRect(0, 0, 0, 0);
+ } else
+ for (int ie = e+1; ie < board->energizers(); ie++)
+ if (energizerRect->at(e)->intersects(*energizerRect->at(ie))) {
+ *energizerRect->at(e) = pix->rect(*energizerRect->at(e), *energizerRect->at(ie));
+ energizerRect->at(ie)->setRect(0, 0, 0, 0);
+ }
+ }
+
+ if (fruit->pix() != -1 && fruit->state() != active)
+ fruitRect = pix->rect(fruit->position(), FruitScorePix, fruit->pix());
+ else
+ fruitRect = pix->rect(fruit->position(), FruitPix, fruit->pix());
+
+ if (pacmanRect.intersects(fruitRect)) {
+ pacmanRect = pix->rect(pacmanRect, fruitRect);
+ fruitRect.setRect(0, 0, 0, 0);
+ }
+
+ for (int m = 0; m < board->monsters(); m++) {
+ *monsterRect->at(m) = pix->rect(board->position(monster, m), MonsterPix);
+
+ if (pacmanRect.intersects(*monsterRect->at(m))) {
+ pacmanRect = pix->rect(pacmanRect, *monsterRect->at(m));
+ monsterRect->at(m)->setRect(0, 0, 0, 0);
+ } else
+ for (int im = m+1; im < board->monsters(); im++)
+ if (monsterRect->at(m)->intersects(*monsterRect->at(im))) {
+ *monsterRect->at(m) = pix->rect(*monsterRect->at(m), *monsterRect->at(im));
+ monsterRect->at(im)->setRect(0, 0, 0, 0);
+ }
+ }
+
+ if (!pacmanRect.isNull())
+ repaint(pacmanRect, FALSE);
+
+ if (!fruitRect.isNull())
+ repaint(fruitRect, FALSE);
+
+ for (int m = 0; m < board->monsters(); m++)
+ if (!monsterRect->at(m)->isNull())
+ repaint(*monsterRect->at(m), FALSE);
+
+ for (int e = 0; e < board->energizers(); e++)
+ if (!energizerRect->at(e)->isNull())
+ repaint(*energizerRect->at(e), FALSE);
+
+}
+
+void Referee::initKeys()
+{
+ TQString up("Up");
+ up = kapp->config()->readEntry("upKey", up);
+ UpKey = TDEShortcut(up);
+
+ TQString down("Down");
+ down = kapp->config()->readEntry("downKey", down);
+ DownKey = TDEShortcut(down);
+
+ TQString left("Left");
+ left = kapp->config()->readEntry("leftKey", left);
+ LeftKey = TDEShortcut(left);
+
+ TQString right("Right");
+ right = kapp->config()->readEntry("rightKey", right);
+ RightKey = TDEShortcut(right);
+}
+
+void Referee::fillArray(TQMemArray<int> &array, TQString values, int max)
+{
+ if (max < 0)
+ max = values.contains(',')+1;
+
+ array.resize(max);
+ int last = 0;
+ bool ok;
+ TQString value;
+
+ for (uint i = 0; i < array.size(); i++) {
+ if (values.find(',') < 0 && values.length() > 0) {
+ value = values;
+ values = "";
+ }
+ if (values.find(',') >= 0) {
+ value = values.left(values.find(','));
+ values.remove(0,values.find(',')+1);
+ }
+ array[i] = value.toInt(&ok);
+ if (ok)
+ last = array[i];
+ else
+ array[i] = last;
+ }
+}
+
+void Referee::fillStrList(TQStrList &list, TQString values, int max)
+{
+ if (!list.isEmpty())
+ list.clear();
+
+ TQString last = "";
+ TQString value;
+
+ for (uint i = 0; i < (uint) max; i++) {
+ if (values.find(',') < 0 && values.length() > 0) {
+ value = values;
+ values = "";
+ }
+ if (values.find(',') >= 0) {
+ value = values.left(values.find(','));
+ values.remove(0,values.find(',')+1);
+ }
+ if (!value.isEmpty())
+ last = value;
+
+ list.append(last.latin1());
+ }
+}
+
+void Referee::fillMapName()
+{
+ TQStrList list = mapName;
+
+ if (!mapName.isEmpty())
+ mapName.clear();
+
+ TQString map;
+
+ TQFileInfo fileInfo;
+
+ for (uint i = 0; i < list.count(); i++) {
+ map = list.at(i);
+
+ if (map.left(1) != "/" && map.left(1) != "~")
+ map = TDEGlobal::dirs()->findResource("appdata", mapDirectory+map);
+
+ fileInfo.setFile(map);
+ if (!fileInfo.isReadable())
+ map = "";
+
+ mapName.append(map.utf8());
+ }
+}
+
+void Referee::confLevels(bool defGroup)
+{
+ if (defGroup || kapp->config()->hasKey("Levels"))
+ maxLevel = kapp->config()->readNumEntry("Levels", 13);
+}
+
+void Referee::confMisc(bool defGroup)
+{
+ if (defGroup || kapp->config()->hasKey("PixmapDirectory")) {
+ pixmapDirectory = kapp->config()->readEntry("PixmapDirectory");
+
+ if (pixmapDirectory.left(1) != "/" && pixmapDirectory.left(1) != "~")
+ pixmapDirectory.insert(0, "pics/");
+ if (pixmapDirectory.right(1) != "/")
+ pixmapDirectory.append("/");
+ }
+
+ if (defGroup || kapp->config()->hasKey("MapDirectory")) {
+ mapDirectory = kapp->config()->readEntry("MapDirectory");
+
+ if (mapDirectory.left(1) != "/" && mapDirectory.left(1) != "~")
+ mapDirectory.insert(0, "maps/");
+ if (mapDirectory.right(1) != "/")
+ mapDirectory.append("/");
+ }
+
+ if (defGroup || kapp->config()->hasKey("MapName"))
+ fillStrList(mapName, kapp->config()->readEntry("MapName", "map"), maxLevel+1);
+
+ if (defGroup || kapp->config()->hasKey("MonsterIQ"))
+ fillArray(monsterIQ, kapp->config()->readEntry("MonsterIQ", "0,170,180,170,180,170,180"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitIQ"))
+ fillArray(fruitIQ, kapp->config()->readEntry("FruitIQ", "0,170,180,170,180,170,180"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitIndex"))
+ fillArray(fruitIndex, kapp->config()->readEntry("FruitIndex", "0"), maxLevel+1);
+}
+
+void Referee::confTiming(bool defGroup)
+{
+ if (defGroup || kapp->config()->hasKey("SpeedMS"))
+ fillArray(speed, kapp->config()->readEntry("SpeedMS", "20"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("PacmanTicks"))
+ fillArray(pacmanTicks,kapp->config()->readEntry("PacmanTicks", "3"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("RemTicks"))
+ fillArray(remTicks, kapp->config()->readEntry("RemTicks", "1"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("DangerousTicks"))
+ fillArray(dangerousTicks, kapp->config()->readEntry("DangerousTicks", "3"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("HarmlessTicks"))
+ fillArray(harmlessTicks, kapp->config()->readEntry("HarmlessTicks", "7,6,,5,,4"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("HarmlessDurationTicks"))
+ fillArray(harmlessDurTicks, kapp->config()->readEntry("HarmlessDurationTicks", "375,,,300,,250,200,150"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("HarmlessWarningTicks"))
+ fillArray(harmlessWarnTicks, kapp->config()->readEntry("HarmlessWarningTicks", "135"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("ArrestTicks"))
+ fillArray(arrestTicks, kapp->config()->readEntry("ArrestTicks", "6"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("ArrestDurationTicks"))
+ fillArray(arrestDurTicks, kapp->config()->readEntry("ArrestDurationTicks", "200,,,150"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitTicks"))
+ fillArray(fruitTicks, kapp->config()->readEntry("FruitTicks", "7,6,,5,,4"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitAppearsTicks"))
+ fillArray(fruitAppearsTicks, kapp->config()->readEntry("FruitAppearsTicks", "1000,,1500,2000,2500,3000,3500,4000"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitDurationTicks"))
+ fillArray(fruitDurTicks, kapp->config()->readEntry("FruitDurationTicks", "500,,,400,350,300,,250,200,150"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("FruitScoreDurationTicks"))
+ fillArray(fruitScoreDurTicks, kapp->config()->readEntry("FruitScoreDurationTicks", "150"), maxLevel+1);
+
+ if (defGroup || kapp->config()->hasKey("MonsterScoreDurationMS"))
+ monsterScoreDurMS = kapp->config()->readNumEntry("MonsterScoreDurationMS", 1000);
+ if (defGroup || kapp->config()->hasKey("PlayerDurationMS"))
+ playerDurMS = kapp->config()->readNumEntry("PlayerDurationMS", 3000);
+ if (defGroup || kapp->config()->hasKey("ReadyDurationMS"))
+ readyDurMS = kapp->config()->readNumEntry("ReadyDurationMS", 2000);
+ if (defGroup || kapp->config()->hasKey("GameOverDurationMS"))
+ gameOverDurMS = kapp->config()->readNumEntry("GameOverDurationMS", 3000);
+ if (defGroup || kapp->config()->hasKey("AfterPauseMS"))
+ afterPauseMS = kapp->config()->readNumEntry("AfterPauseMS", 1000);
+ if (defGroup || kapp->config()->hasKey("DyingPreAnimationMS"))
+ dyingPreAnimationMS = kapp->config()->readNumEntry("DyingPreAnimationMS", 1000);
+ if (defGroup || kapp->config()->hasKey("DyingAnimationMS"))
+ dyingAnimationMS = kapp->config()->readNumEntry("DyingAnimationMS", 100);
+ if (defGroup || kapp->config()->hasKey("DyingPostAnimationMS"))
+ dyingPostAnimationMS = kapp->config()->readNumEntry("DyingPostAnimationMS", 500);
+ if (defGroup || kapp->config()->hasKey("IntroAnimationMS"))
+ introAnimationMS = kapp->config()->readNumEntry("IntroAnimationMS", 800);
+ if (defGroup || kapp->config()->hasKey("IntroPostAnimationMS"))
+ introPostAnimationMS = kapp->config()->readNumEntry("IntroPostAnimationMS", 1000);
+ if (defGroup || kapp->config()->hasKey("LevelUpPreAnimationMS"))
+ levelUpPreAnimationMS = kapp->config()->readNumEntry("LevelUpPreAnimationMS", 2000);
+ if (defGroup || kapp->config()->hasKey("LevelUpAnimationMS"))
+ levelUpAnimationMS = kapp->config()->readNumEntry("LevelUpAnimationMS", 2000);
+ if (defGroup || kapp->config()->hasKey("EnergizerAnimationMS"))
+ energizerAnimationMS = kapp->config()->readNumEntry("EnergizerAnimationMS", 200);
+}
+
+void Referee::confScoring(bool defGroup)
+{
+ if (defGroup || kapp->config()->hasKey("PointScore"))
+ pointScore = kapp->config()->readNumEntry("PointScore", 10);
+ if (defGroup || kapp->config()->hasKey("EnergizerScore"))
+ energizerScore = kapp->config()->readNumEntry("EnergizerScore", 50);
+ if (defGroup || kapp->config()->hasKey("FruitScore"))
+ fillArray(fruitScore, kapp->config()->readEntry("FruitScore", "100,300,500,,700,,1000,,2000,,3000,,5000"), maxLevel+1);
+ if (defGroup || kapp->config()->hasKey("MonsterScore"))
+ fillArray(monsterScore, kapp->config()->readEntry("MonsterScore", "200,400,800,1600"), 4);
+ if (defGroup || kapp->config()->hasKey("ExtraLifeScore"))
+ fillArray(extraLifeScore, kapp->config()->readEntry("ExtraLifeScore", "10000"), -1);
+}
+
+void Referee::confScheme()
+{
+ TQString oldgroup = kapp->config()->group();
+ TQString newgroup;
+
+ // if not set, read mode and scheme from the configfile
+ if (mode == -1 && scheme == -1) {
+ scheme = kapp->config()->readNumEntry("Scheme", -1);
+ mode = kapp->config()->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);
+ kapp->config()->setGroup(newgroup);
+
+ mode = kapp->config()->readNumEntry("Mode", -1);
+ kapp->config()->setGroup(oldgroup);
+ }
+ }
+
+ confLevels();
+
+ if (mode != -1) {
+ newgroup.sprintf("Mode %d", mode);
+ kapp->config()->setGroup(newgroup);
+
+ confLevels(FALSE);
+ }
+
+ if (scheme != -1) {
+ newgroup.sprintf("Scheme %d", scheme);
+ kapp->config()->setGroup(newgroup);
+
+ confLevels(FALSE);
+ }
+
+ kapp->config()->setGroup(oldgroup);
+
+ confMisc();
+ confTiming();
+ confScoring();
+
+ if (mode != -1) {
+ newgroup.sprintf("Mode %d", mode);
+ kapp->config()->setGroup(newgroup);
+
+ confMisc(FALSE);
+ confTiming(FALSE);
+ confScoring(FALSE);
+ }
+
+ if (scheme != -1) {
+ newgroup.sprintf("Scheme %d", scheme);
+ kapp->config()->setGroup(newgroup);
+
+ confMisc(FALSE);
+ confTiming(FALSE);
+ confScoring(FALSE);
+ }
+
+ fillMapName();
+
+ kapp->config()->setGroup(oldgroup);
+}
+
+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( TQKeyEvent *k )
+{
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame) ||
+ gameState.testBit(Demonstration) || gameState.testBit(Dying) ||
+ gameState.testBit(Ready) || gameState.testBit(LevelDone) ||
+ !gameState.testBit(Playing))
+ return;
+
+ uint key = k->key();
+ 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)
+ TQTimer::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))
+ TQTimer::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 forcedGameHighscores();
+}
+
+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, i18n("PAUSED")), FALSE);
+ } else {
+ gameState.clearBit(Paused);
+ repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("PAUSED")), FALSE);
+ if (pausedTimer) {
+ pausedTimer = 0;
+ start();
+ }
+ // manual pause deactivating (also) deactivates a focusedPause
+ focusedPause = false;
+ }
+ //0.3.2 emit gamePause();
+}
+
+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)
+{
+ TQString pts;
+
+ switch (t) {
+ case 0 : repaint(pix->draw(16, 6, RoomPix, i18n("CHARACTER"), WHITE, TQColor(), AlignLeft), FALSE);
+ repaint(pix->draw(36, 6, RoomPix, i18n("/"), WHITE, TQColor(), AlignLeft), FALSE);
+ repaint(pix->draw(40, 6, RoomPix, i18n("NICKNAME"), WHITE, TQColor(), AlignLeft), FALSE);
+ break;
+ case 1 : introMonster(0);
+ break;
+ case 2 : repaint(pix->draw(16, 10, RoomPix, i18n("-SHADOW"), RED, TQColor(), AlignLeft), FALSE);
+ break;
+ case 3 : repaint(pix->draw(38, 10, RoomPix, i18n("\"BLINKY\""), RED, TQColor(), AlignLeft), FALSE);
+ break;
+ case 4 : introMonster(1);
+ break;
+ case 5 : repaint(pix->draw(16, 16, RoomPix, i18n("-SPEEDY"), PINK, TQColor(), AlignLeft), FALSE);
+ break;
+ case 6 : repaint(pix->draw(38, 16, RoomPix, i18n("\"PINKY\""), PINK, TQColor(), AlignLeft), FALSE);
+ break;
+ case 7 : introMonster(2);
+ break;
+ case 8 : repaint(pix->draw(16, 22, RoomPix, i18n("-BASHFUL"), CYAN, TQColor(), AlignLeft), FALSE);
+ break;
+ case 9 : repaint(pix->draw(38, 22, RoomPix, i18n("\"INKY\""), CYAN, TQColor(), AlignLeft), FALSE);
+ break;
+ case 10 : introMonster(3);
+ break;
+ case 11 : repaint(pix->draw(16, 28, RoomPix, i18n("-POKEY"), ORANGE, TQColor(), AlignLeft), FALSE);
+ break;
+ case 12 : repaint(pix->draw(38, 28, RoomPix, i18n("\"CLYDE\""), ORANGE, TQColor(), AlignLeft), FALSE);
+ break;
+ case 13 : pts.sprintf("%d", pointScore);
+ repaint(pix->draw(28, 44, RoomPix, pts, WHITE, TQColor(), AlignRight), FALSE);
+ repaint(pix->draw(31, 44, RoomPix, "\x1C\x1D\x1E", WHITE, TQColor(), AlignLeft), FALSE);
+ pts.sprintf("%d", energizerScore);
+ repaint(pix->draw(28, 48, RoomPix, pts, WHITE, TQColor(), AlignRight), FALSE);
+ repaint(pix->draw(31, 48, RoomPix, "\x1C\x1D\x1E", WHITE, TQColor(), AlignLeft), FALSE);
+ break;
+ case 14 : // "@ 1980 MIDWAY MFG.CO."
+ repaint(pix->draw(30, 58, RoomPix, "© 1998-2003 J.THÖNNISSEN", PINK), FALSE);
+ break;
+ }
+}
+
+void Referee::introPlay()
+{
+ if (!gameState.testBit(Introducing) || gameState.testBit(Ready))
+ return;
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(introPlay()));
+ return;
+ }
+
+ if (!gameState.testBit(Init)) {
+ if (monstersEaten == 4) {
+ stop();
+ TQTimer::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)
+ TQTimer::singleShot(introAnimationMS, this, SLOT(introPlay()));
+}
+
+void Referee::demo()
+{
+ if (gameState.testBit(Ready))
+ return;
+
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::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;
+ TQTimer::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;
+ points = 0;
+
+ extraLifeScoreIndex = 0;
+ nextExtraLifeScore = extraLifeScore[extraLifeScoreIndex];
+ if (nextExtraLifeScore < 0)
+ nextExtraLifeScore *= -1;
+
+ board->init(Level, mapName.at(level));
+ pix->setLevel(level);
+
+ initPacman();
+ initFruit();
+ initMonsters();
+ initEnergizers();
+
+ repaint();
+ //0.3.2 emit toggleNew();
+ emit setLifes(lifes);
+ emit setLevel(level);
+ emit setPoints(points);
+
+ repaint(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE")), FALSE);
+ repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+
+ timerCount = 0;
+ TQTimer::singleShot(playerDurMS, this, SLOT(ready()));
+}
+
+void Referee::ready()
+{
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(ready()));
+ return;
+ }
+
+ if (gameState.testBit(Player)) {
+ emit setLifes(--lifes);
+ gameState.clearBit(Player);
+ gameState.clearBit(Init);
+ repaint(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE")), FALSE);
+ repaintFigures();
+ TQTimer::singleShot(playerDurMS, this, SLOT(ready()));
+ return;
+ }
+
+ if (gameState.testBit(Ready)) {
+ gameState.clearBit(Ready);
+ repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+ start();
+ } else {
+ gameState.setBit(Ready);
+ gameState.clearBit(Init);
+ repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+ TQTimer::singleShot(readyDurMS, this, SLOT(ready()));
+ }
+}
+
+
+void Referee::levelUp()
+{
+ stop();
+ stopEnergizer();
+
+ gameState.setBit(LevelDone);
+ pacman->setPosition(pacman->position()); // set mouthPosition to "0"
+ repaint(pix->rect(pacman->position(), PacmanPix));
+
+ timerCount = 0;
+ TQTimer::singleShot(levelUpPreAnimationMS, this, SLOT(levelUpPlay()));
+}
+
+void Referee::levelUpPlay()
+{
+ if (gameState.testBit(Ready))
+ return;
+
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(levelUpPlay()));
+ return;
+ }
+
+ switch (timerCount) {
+ case 0 : gameState.setBit(Init);
+ setOnEnergizers();
+ repaintFigures();
+ break;
+ case 1 : gameState.clearBit(LevelDone);
+ repaint(pix->rect(pacman->position(), PacmanPix));
+ break;
+ }
+
+ if (timerCount++ < 2) {
+ TQTimer::singleShot(levelUpAnimationMS, this, SLOT(levelUpPlay()));
+ return;
+ }
+
+ gameState.clearBit(Init);
+
+ if (gameState.testBit(Demonstration)) {
+ hallOfFame();
+ return;
+ }
+
+ if (level < maxLevel)
+ level++;
+
+ board->init(Level, mapName.at(level));
+ pix->setLevel(level);
+
+ initPacman();
+ initFruit();
+ initMonsters();
+ initEnergizers();
+
+ repaint();
+ emit setLevel(level);
+
+ ready();
+}
+
+void Referee::start()
+{
+ if (gameState.testBit(Ready))
+ return;
+
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(start()));
+ return;
+ }
+
+ if (gameState.testBit(Scoring)) {
+ gameState.clearBit(Scoring);
+ repaint(pix->rect(pix->rect(pacman->position(), MonsterPix),
+ pix->rect(pacman->position(), MonsterScorePix, monstersEaten-1)));
+ }
+
+ if (!gameTimer)
+ gameTimer = startTimer( speed [level] );
+
+ if (!energizerTimer)
+ energizerTimer = startTimer( energizerAnimationMS );
+}
+
+void Referee::start(int t)
+{
+ gameTimer = startTimer(t);
+}
+
+void Referee::stop()
+{
+ if (gameTimer) {
+ killTimer (gameTimer);
+ gameTimer = 0;
+ }
+}
+
+void Referee::stopEnergizer()
+{
+ if (energizerTimer) {
+ killTimer (energizerTimer);
+ energizerTimer = 0;
+ }
+}
+
+void Referee::killed()
+{
+ if (gameState.testBit(Ready))
+ return;
+
+ if (!gameState.testBit(Dying)) {
+ gameState.setBit(Dying);
+
+ pacman->setDirection(X, TRUE);
+ for (Monster *m = monsters->first(); m != 0; m = monsters->next())
+ if (m)
+ m->setDirection(X);
+ TQTimer::singleShot(dyingPreAnimationMS, this, SLOT(killed()));
+ } else {
+ stop();
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(killed()));
+ return;
+ }
+
+ gameState.setBit(Init);
+
+ repaintFigures();
+
+ timerCount = 0;
+ killedPlay();
+ }
+}
+
+void Referee::killedPlay()
+{
+ if (!gameState.testBit(Dying) || gameState.testBit(Ready))
+ return;
+ if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+ TQTimer::singleShot(afterPauseMS, this, SLOT(killedPlay()));
+ return;
+ }
+
+ if (timerCount <= pix->maxPixmaps(DyingPix)) {
+ repaint(pix->rect(pacman->position(), PacmanPix), FALSE);
+ if (timerCount >= pix->maxPixmaps(DyingPix)-1 || timerCount == 0)
+ TQTimer::singleShot(dyingPostAnimationMS, this, SLOT(killedPlay()));
+ else
+ TQTimer::singleShot(dyingAnimationMS, this, SLOT(killedPlay()));
+ timerCount++;
+ } else {
+ gameState.clearBit(Dying);
+ stopEnergizer();
+ if (lifes == 0) {
+ gameState.setBit(GameOver);
+ gameState.clearBit(Playing);
+ for (int e = 0; e < board->energizers(); e++) {
+ energizers->at(e)->setOff();
+ repaint(pix->rect(board->position(energizer, e), EnergizerPix), FALSE);
+ }
+ repaint(pix->rect(board->position(fruithome), i18n("GAME OVER")), FALSE);
+ TQTimer::singleShot(gameOverDurMS, this, SLOT(hallOfFame()));
+ } else {
+ gameState.clearBit(Init);
+ initPacman();
+ initFruit();
+ initMonsters();
+ initEnergizers();
+ emit setLifes(--lifes);
+ repaintFigures();
+ ready();
+ }
+ }
+}
+
+void Referee::initPacman()
+{
+ pacman->setMaxPixmaps(pix->maxPixmaps(PacmanPix));
+ pacman->setDemo(gameState.testBit(Demonstration));
+ pacman->setPosition(board->position(pacmanhome));
+ pacman->setDirection(W, TRUE);
+ pacman->setAlive(pacmanTicks[level]);
+}
+
+void Referee::initFruit(bool fullInitialization)
+{
+ if (fullInitialization) {
+ fruit->setMaxPixmaps(pix->maxPixmaps(FruitPix));
+ if (fruitIndex[level] == 0)
+ fruit->setLevel(level, fruitAppearsTicks[level],
+ fruitDurTicks[level], fruitTicks[level]);
+ else if (fruitIndex[level] < 0)
+ fruit->setLevel(pix->maxPixmaps(FruitPix)+1,
+ fruitAppearsTicks[level],
+ fruitDurTicks[level], fruitTicks[level]);
+ else
+ fruit->setLevel(fruitIndex[level], fruitAppearsTicks[level],
+ fruitDurTicks[level], fruitTicks[level]);
+ }
+
+ if (board->tunnels() > 0)
+ fruit->setMovement(board->position(tunnel, rand() % board->tunnels()),
+ board->position(tunnel, rand() % board->tunnels()),
+ fruitIQ[level]);
+}
+
+void Referee::initMonsters()
+{
+ if( !monsters->isEmpty())
+ monsters->clear();
+ if( !monsterRect->isEmpty())
+ monsterRect->clear();
+
+ for (int id = 0; id < (gameState.testBit(Introducing) ? 4 : board->monsters()); id++) {
+ Monster *m = new Monster(board, id);
+ monsters->append(m);
+ TQRect *r = new TQRect();
+ monsterRect->append(r);
+ if (!gameState.testBit(Introducing)) {
+ m->setFreedom(board->position(prisonexit));
+ m->setDangerous(dangerousTicks[level], monsterIQ[level]);
+ if (id == 0)
+ m->setPrison(board->position(prisonentry));
+ else {
+ m->setPrison(board->position(monsterhome, id));
+ m->setArrested(arrestTicks[level], arrestDurTicks[level]*id);
+ }
+ m->setPosition(board->position(monsterhome, id));
+ switch(id) {
+ case 0 : m->setDirection(W); break;
+ case 1 : m->setDirection(N); break;
+ default : m->setDirection(S);
+ }
+ }
+ m->setMaxPixmaps(pix->maxPixmaps(MonsterPix), pix->maxPixmaps(EyesPix));
+ }
+}
+
+void Referee::initEnergizers()
+{
+ if( !energizers->isEmpty())
+ energizers->clear();
+ if( !energizerRect->isEmpty())
+ energizerRect->clear();
+
+ for (int id = 0; id < (gameState.testBit(Introducing) ? 2 : board->energizers()); id++) {
+ Energizer *e = new Energizer(board);
+ energizers->append(e);
+ TQRect *r = new TQRect();
+ energizerRect->append(r);
+ if (!gameState.testBit(Introducing)) {
+ e->setPosition(board->position(energizer, id));
+ e->setOn();
+ }
+ e->setMaxPixmaps(pix->maxPixmaps(EnergizerPix));
+ }
+}
+
+void Referee::setOnEnergizers()
+{
+ for (int e = 0; e < board->energizers(); e++) {
+ energizers->at(e)->setOn();
+ }
+}
+
+void Referee::setFocusOutPause(bool FocusOutPause)
+{
+ focusOutPause = FocusOutPause;
+}
+
+void Referee::setFocusInContinue(bool FocusInContinue)
+{
+ focusInContinue = FocusInContinue;
+}
+
+void Referee::focusInEvent(TQFocusEvent *)
+{
+ if (focusInContinue && focusedPause &&
+ gameState.testBit(Paused) && gameState.testBit(Playing)) {
+ focusedPause = false;
+ // this also calls the Referee::pause() function
+ emit focusedGamePause();
+ }
+}
+
+void Referee::focusOutEvent(TQFocusEvent *)
+{
+ if (focusOutPause && !focusedPause &&
+ !gameState.testBit(Paused) && gameState.testBit(Playing)) {
+ focusedPause = true;
+ // this also calls the Referee::pause() function
+ emit focusedGamePause();
+ }
+}
+
+#include "referee.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-10 03:37:42 +0000