New directory structure

54 files changed, 7690 insertions, 0 deletions

diff --git a/apps/Games/kpacman.desktop b/apps/Games/kpacman.desktop
new file mode 100644
index 0000000..da51668
--- a/dev/null
+++ b/apps/Games/kpacman.desktop
@@ -0,0 +1,8 @@
+[Desktop Entry]
+Type=Application
+Exec=kpacman
+Icon=kpacman
+Comment=
+Comment[de]=
+Name=Kpacman
+Name[de]=Kpacman
diff --git a/noncore/games/kpacman/bitfont.cpp b/noncore/games/kpacman/bitfont.cpp
new file mode 100644
index 0000000..40581c8
--- a/dev/null
+++ b/noncore/games/kpacman/bitfont.cpp
@@ -0,0 +1,71 @@
+#include "bitfont.h"
+
+Bitfont::Bitfont(QString fontname, uchar firstChar, uchar lastChar)
+{
+    if (!fontname.isEmpty())
+        font.load(fontname);
+    if (font.width() == font.height()) {
+        fontWidth = fontHeight = font.width() / 16;
+        fontFirstChar = 1;
+        fontLastChar = 255;
+    } else {
+        fontWidth = font.width()/(lastChar-firstChar+1);
+        fontHeight = font.height();
+        fontFirstChar = firstChar;
+        fontLastChar = lastChar;
+    }
+}
+
+QRect Bitfont::rect(QString str)
+{
+    return QRect(0, 0, str.length()*fontWidth, fontHeight);
+}
+
+QPixmap Bitfont::text(QString str, QColor fg, QColor bg)
+{
+    QPixmap FG(str.length()*fontWidth, fontHeight);
+    QBitmap MASK(str.length()*fontWidth, fontHeight, TRUE);
+
+    const uchar *s = (const uchar *) str.data();
+    for (uint i = 0; i < str.length(); i++) {
+        if (font.width() == font.height())
+            bitBlt(&MASK, i*fontWidth, 0, &font,
+                   (*s%16)*fontWidth, (*s/16)*fontWidth, fontWidth, fontHeight);
+        else
+            if (*s >= fontFirstChar && *s <= fontLastChar)
+                bitBlt(&MASK, i*fontWidth, 0, &font,
+                       (*s-fontFirstChar)*fontWidth, 0, fontWidth, fontHeight);         
+        s++;
+    }
+
+    FG.fill(fg);
+    FG.setMask(MASK);
+
+    if (bg.isValid()) {
+        QPixmap BG(str.length()*fontWidth, fontHeight);
+        BG.fill(bg);
+        bitBlt(&BG, 0, 0, &FG);
+        return BG;
+    } else
+        return FG;
+}
+
+uchar Bitfont::firstChar()
+{
+    return fontFirstChar;
+}
+
+uchar Bitfont::lastChar()
+{
+    return fontLastChar;
+}
+
+int Bitfont::width()
+{
+    return fontWidth;
+}
+
+int Bitfont::height()
+{
+    return fontHeight;
+}
diff --git a/noncore/games/kpacman/bitfont.h b/noncore/games/kpacman/bitfont.h
new file mode 100644
index 0000000..c12aa0f
--- a/dev/null
+++ b/noncore/games/kpacman/bitfont.h
@@ -0,0 +1,31 @@
+#ifndef BITFONT_H
+#define BITFONT_H
+
+#include <qstring.h>
+#include <qbitmap.h>
+#include <qpixmap.h>
+#include <qrect.h>
+
+#include "colors.h"
+
+class Bitfont
+{
+public:
+    Bitfont(QString fontname, uchar firstChar, uchar lastChar);
+
+    QPixmap text(QString str, QColor fg = BLACK, QColor bg = QColor());
+    QRect rect(QString str);
+    int width();
+    int height();
+    uchar firstChar();
+    uchar lastChar();
+private:
+    QBitmap font;
+    int fontWidth;
+    int fontHeight;
+    uchar fontFirstChar;
+    uchar fontLastChar;
+};
+
+#endif // BITFONT_H
+
diff --git a/noncore/games/kpacman/bitmaps.h b/noncore/games/kpacman/bitmaps.h
new file mode 100644
index 0000000..f430384
--- a/dev/null
+++ b/noncore/games/kpacman/bitmaps.h
@@ -0,0 +1,67 @@
+static unsigned char demo_bits[] = {
+    "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
+    "++*******************************************************++"
+    "+*********************************************************+"
+    "+**                         ***                         **+"
+    "+** . . . . . . . . . . . . *** . . . . . . . . . . . . **+"
+    "+**                         ***                         **+"
+    "+** . ******* . ********* . *** . ********* . ******* . **+"
+    "+**   *******   *********   ***   *********   *******   **+"
+    "+** o ******* . ********* . *** . ********* . ******* o **+"
+    "+**   *******   *********   ***   *********   *******   **+"
+    "+** . ******* . ********* . *** . ********* . ******* . **+"
+    "+**                                                     **+"
+    "+** . . . . . . . . . . . . . . . . . . . . . . . . . . **+"
+    "+**                                                     **+"
+    "+** . ******* . *** . *************** . *** . ******* . **+"
+    "+**   *******   ***   ***************   ***   *******   **+"
+    "+** . ******* . *** . *************** . *** . ******* . **+"
+    "+**             ***         ***         ***             **+"
+    "+** . . . . . . *** . . . . *** . . . . *** . . . . . . **+"
+    "+**             ***         ***         ***             **+"
+    "+************ . *********   ***   ********* . ************+"
+    "++***********   *********   ***   *********   ***********++"
+    "+++++++++++** . *********   ***   ********* . **+++++++++++"
+    "+++++++++++**   ***                     ***   **+++++++++++"
+    "+++++++++++** . ***          0          *** . **+++++++++++"
+    "+++++++++++**   ***                     ***   **+++++++++++"
+    "+++++++++++** . ***   ######---######   *** . **+++++++++++"
+    "+************   ***   ######---######   ***   ************+"
+    "+************ . ***   ##           ##   *** . ************+"
+    "                      ##           ##                      "
+    "              .       ## 2   1   3 ##       .              "
+    "                      ##           ##                      "
+    "+************ . ***   ##           ##   *** . ************+"
+    "+************   ***   ###############   ***   ************+"
+    "+++++++++++** . ***   ###############   *** . **+++++++++++"
+    "+++++++++++**   ***                     ***   **+++++++++++"
+    "+++++++++++** . ***          F          *** . **+++++++++++"
+    "+++++++++++**   ***                     ***   **+++++++++++"
+    "+++++++++++** . ***   ***************   *** . **+++++++++++"
+    "++***********   ***   ***************   ***   ***********++"
+    "+************ . ***   ***************   *** . ************+"
+    "+**                         ***                         **+"
+    "+** . . . . . . . . . . . . *** . . . . . . . . . . . . **+"
+    "+**                         ***                         **+"
+    "+** . ******* . ********* . *** . ********* . ******* . **+"
+    "+**   *******   *********   ***   *********   *******   **+"
+    "+** . ******* . ********* . *** . ********* . ******* . **+"
+    "+**       ***                                 ***       **+"
+    "+** o . . *** . . . . . . .  P  . . . . . . . *** . . o **+"
+    "+**       ***                                 ***       **+"
+    "+****** . *** . *** . *************** . *** . *** . ******+"
+    "+******   ***   ***   ***************   ***   ***   ******+"
+    "+****** . *** . *** . *************** . *** . *** . ******+"
+    "+**             ***         ***         ***             **+"
+    "+** . . . . . . *** . . . . *** . . . . *** . . . . . . **+"
+    "+**             ***         ***         ***             **+"
+    "+** . ******************* . *** . ******************* . **+"
+    "+**   *******************   ***   *******************   **+"
+    "+** . ******************* . *** . ******************* . **+"
+    "+**                                                     **+"
+    "+** . . . . . . . . . . . . . . . . . . . . . . . . . . **+"
+    "+**                                                     **+"
+    "+*********************************************************+"
+    "++*******************************************************++"
+    "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
+};
diff --git a/noncore/games/kpacman/board.cpp b/noncore/games/kpacman/board.cpp
new file mode 100644
index 0000000..849e75b
--- a/dev/null
+++ b/noncore/games/kpacman/board.cpp
@@ -0,0 +1,425 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <klocale.h>
+#endif
+
+#include <qrect.h>
+#include <qregexp.h>
+#include <qmessagebox.h>
+#include <qfile.h>
+#include <qtextstream.h>
+
+#include "board.h"
+#include "bitmaps.h"
+
+Board::Board(int size) : QArray<int> (size)
+{
+    sz = size;                          // set size of board
+
+    map = "";                   
+    mapName = "";                       // no map loaded so far
+
+    init(None);                         // initialize varibales
+}
+
+void Board::init(Image image, QString levelName)
+{
+    prisonEntry = OUT;
+    prisonExit = OUT;
+    fruitHome = OUT;
+    fruitPosition = OUT;
+    pacmanHome = OUT;
+    pacmanPosition = OUT;
+    for (int m = 0; m < 8; m++) {
+        monsterHome[m] = OUT;
+        monsterPosition[m] = OUT;
+    }
+    for (int e = 0; e < 8; e++) {
+        energizerPosition[e] = OUT;
+    }
+    for (int e = 0; e < 8; e++) {
+        tunnelPosition[e] = OUT;
+    }
+
+    fill(0);
+    numPoints = 0;
+    numEnergizers = 0;
+    numMonsters = 0;
+    numTunnels = 0;
+
+    if (!levelName.isNull() && !levelName.isEmpty())
+        if (mapName == levelName)
+            image = File;
+        else {
+            QFile levelFile(levelName);
+            if (!levelFile.open(IO_ReadOnly)) {
+
+                QString msg = i18n("The levelmap could not be constructed.\n\n"
+                                   "The file '@LEVELNAME@' does not exist,\n"
+                                   "or could not be opened for reading.");
+                msg.replace(QRegExp("@LEVELNAME@"), levelName);
+                // QMessageBox::information(0, i18n("Initialization Error"), msg);
+                printf("%s\n", msg.data());
+            } else {
+                map.fill(' ', BoardHeight*BoardWidth);
+                int height = 0; 
+
+                QTextStream levelStream(&levelFile);
+                while (!levelStream.eof() && height < BoardHeight) {
+                    QString line = levelStream.readLine();
+                
+                    if (line.find(QRegExp("^ *;")) == -1) {     
+
+                        line.replace(QRegExp(";.*"), "");       // strip off comments
+                        line.replace(QRegExp("\" *$"), "");     // strip off trailing "
+                        line.replace(QRegExp("^ *\""), "");     // strip off leading "
+
+                        map.replace(height*BoardWidth,
+                                    (line.length() > BoardWidth) ? BoardWidth : line.length(),
+                                    line.data());
+
+                        height++;
+                    }
+                }
+                mapName = levelName;
+                levelFile.close();
+                image = File;
+            }
+        }
+
+    switch (image) {
+        case Intro : // setup(demo_bits);
+                     break;
+        case Demo  : setup(demo_bits);
+                     break;
+        case Level : setup(demo_bits);
+                     break;
+        case File  : setup((uchar *) map.data());
+                     break;
+        default    : break;
+    }
+}
+
+void Board::setup(const uchar *buf)
+{
+    for ( int index = 0; buf[index] != 0 && index < BoardWidth*BoardHeight; index++ ) {
+        switch (buf[index]) {
+            case '*' : set(index, brick); break;
+            case '+' : set(index, out); break;
+            case '#' : set(index, prison); break;
+            case '-' : set(index, gate); break;
+            case 'E' : set(index, tunnel); break;
+            case '.' : set(index, Point); break;
+            case 'o' : set(index, energizer); break;
+            case 'I' : set(index, prisonentry); break;
+            case 'O' : set(index, prisonexit); break;
+            case 'F' : set(index, fruithome); break;
+            case 'P' : set(index, pacmanhome);  break;
+            default  : if (buf[index] >= '0' && buf[index] <= '7') {
+                           set(index, monsterhome, buf[index]-(uchar)'0');
+                       }
+        }
+    }
+}
+
+bool Board::inBounds(int pos)
+{
+  return ( pos < 0 || pos > sz-1 ? FALSE : TRUE);
+}
+
+void Board::set(int pos, Square sq, int m)
+{
+    if (inBounds(pos))
+        switch (sq) {
+            case out         : at(pos) = OUT; break;
+            case Point       : at(pos) |= pointBit; numPoints++; break;
+            case tunnel      : at(pos) = sq;
+                               for (int e = 0; e < numTunnels; e++) {           // if tunnel is already on board
+                                   if (tunnelPosition[e] == pos)                // don't do it again.
+                                       pos = OUT;
+                               }
+                               if (pos != OUT) {
+                                   tunnelPosition[numTunnels] = pos;
+                                   numTunnels++;
+                               }
+                               break;
+            case energizer   : at(pos) |= energizerBit;
+                               for (int e = 0; e < numEnergizers; e++) {
+                                   if (energizerPosition[e] == pos)     
+                                       pos = OUT;
+                               }
+                               if (pos != OUT) {
+                                   energizerPosition[numEnergizers] = pos;
+                                   numEnergizers++;
+                               }
+                               break;
+            case fruit       : at(pos) |= fruitBit; fruitPosition = pos; break;
+            case pacman      : at(pos) |= pacmanBit; pacmanPosition = pos; break;
+            case monster     : at(pos) |= (monsterBit << m); 
+                               monsterPosition[m] = pos; break;
+            case prisonentry : prisonEntry = pos; at(pos) = empty; break;
+            case prisonexit  : prisonExit = pos; at(pos) = empty; break;
+            case fruithome   : fruitHome = pos; at(pos) = empty; break;
+            case pacmanhome  : pacmanHome = pos; at(pos) = empty; break;
+            case monsterhome : monsterHome[m] = pos; at(pos) = empty; 
+                               if (m == 0 && prisonExit == OUT)
+                                   prisonExit = pos;
+                               if (m == 1 && prisonEntry == OUT)
+                                   prisonEntry = pos;
+                               numMonsters++;
+                               break;
+            default          : at(pos) = sq;
+        }
+}
+
+void Board::reset(int pos, Square sq, int m)
+{
+    bool found = FALSE;
+    if (inBounds(pos))
+        switch (sq) {
+            case out       : at(pos) = empty; break;
+            case Point     : at(pos) &= ~ pointBit; numPoints--; break;
+            case energizer : at(pos) &= ~ energizerBit;
+                             for (int e = 0; e < numEnergizers; e++) {          // delete the position of the eaten
+                                 if (found)                                     // energizer in the position array
+                                     energizerPosition[e-1] = energizerPosition[e];
+                                 if (energizerPosition[e] == pos)               
+                                     found = TRUE;
+                             }
+                             energizerPosition[numEnergizers--] = OUT;
+                             break;
+            case fruit     : at(pos) &= ~ fruitBit; fruitPosition = OUT; break;
+            case pacman    : at(pos) &= ~ pacmanBit; pacmanPosition = OUT; break;
+            case monster   : at(pos) &= ~ (monsterBit << m);
+                             monsterPosition[m] = OUT; break;
+            default        : at(pos) = at(pos) & varBits;
+        }
+}
+
+int Board::position(Square sq, int m)
+{
+    switch(sq) {
+        case prisonentry  : return prisonEntry;
+        case prisonexit   : return prisonExit;
+        case fruit        : return fruitPosition;
+        case fruithome    : return fruitHome;
+        case pacman       : return pacmanPosition;
+        case pacmanhome   : return pacmanHome;
+        case monster      : return monsterPosition[m];
+        case monsterhome  : return monsterHome[m];
+        case energizer    : return energizerPosition[m];
+        case tunnel       : return tunnelPosition[m];
+        default           : return OUT;
+    }
+}
+
+bool Board::isOut(int pos)
+{
+    if (inBounds(pos))
+        return (at(pos) == OUT ? TRUE : FALSE);
+    return TRUE;
+}
+
+bool Board::isEmpty(int pos)
+{
+    if (inBounds(pos))
+        return ((at(pos) & fixBits) == empty ? TRUE : FALSE);
+    return TRUE;
+}
+
+bool Board::isBrick(int pos)
+{
+    if (inBounds(pos))
+        return ((at(pos) & fixBits) == brick ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isPrison(int pos)
+{
+    if (inBounds(pos))
+        return ((at(pos) & fixBits) == prison ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isGate(int pos)
+{
+    if (inBounds(pos))
+        return ((at(pos) & fixBits) == gate ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isTunnel(int pos)
+{
+    if (inBounds(pos))
+        return ((at(pos) & fixBits) == tunnel ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isPoint(int pos)
+{
+    if (inBounds(pos) && at(pos) != OUT)
+        return ((at(pos) & pointBit) != 0 ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isEnergizer(int pos)
+{
+    if (inBounds(pos) && at(pos) != OUT)
+        return ((at(pos) & energizerBit) != 0 ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isFruit(int pos)
+{
+    if (inBounds(pos) && at(pos) != OUT)
+        return ((at(pos) & fruitBit) != 0 ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isPacman(int pos)
+{
+    if (inBounds(pos) && at(pos) != OUT)
+        return ((at(pos) & pacmanBit) != 0 ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isMonster(int pos)
+{
+    if (inBounds(pos) && at(pos) != OUT)
+        return ((at(pos) & monsterBits) != 0 ? TRUE : FALSE);
+    return FALSE;
+}
+
+bool Board::isWay(int pos, int dir, Square sq) {
+    int p1 = move(pos, dir, 2);
+    if (p1 == OUT)
+        return (sq == out ? TRUE : FALSE);
+    int p2, p3;
+    if (dir == N || dir == S) {
+        p2 = move(p1, E);
+        p3 = move(p1, W);
+    } else {
+        p2 = move(p1, N);
+        p3 = move(p1, S);
+    }
+    switch (sq) {
+        case out    : return isOut(p1) | isOut(p2) | isOut(p3); 
+        case empty  : return isEmpty(p1) & isEmpty(p2) & isEmpty(p3);
+        case brick  : return isBrick(p1) | isBrick(p2) | isBrick(p3);
+        case prison : return isPrison(p1) | isPrison(p2) | isPrison(p3);
+        case gate   : return isGate(p1) & isGate(p2) & isGate(p3);
+        case tunnel : return isTunnel(p1) &
+                             (isTunnel(p2) || isEmpty(p2)) &
+                             (isTunnel(p3) || isEmpty(p3));
+        default     : return FALSE;
+    }
+}
+
+bool Board::isJump(int pos, int dir) {
+    switch (dir) {
+        case NW: return pos < BoardWidth || x(pos) == 0;
+        case N:  return pos < BoardWidth;
+        case NE: return pos < BoardWidth || x(pos) == BoardWidth-1;
+        case W:  return x(pos) == 0;
+        case E:  return x(pos) == BoardWidth-1;
+        case SW: return pos >= sz-BoardWidth || x(pos) == 0;
+        case S:  return pos >= sz-BoardWidth;
+        case SE: return pos >= sz-BoardWidth || x(pos) == BoardWidth-1;
+    }
+    return FALSE;
+}
+
+int Board::move(int pos, int dir, int steps)
+{
+    if (steps < 0) {                    // move backwards
+        dir = turn(dir);                // turn around and do your steps
+        steps *= -1;
+    }
+
+    while (steps-- != 0) {              // until all steps are gone
+        switch (dir) {
+            case NW: pos = pos >= BoardWidth && x(pos) > 0 ? (pos-BoardWidth)-1 : sz-1;
+                     break;
+            case N:  pos = pos >= BoardWidth ? pos-BoardWidth : (sz-BoardWidth)+x(pos);
+                     break;
+            case NE: pos = pos >= BoardWidth && x(pos) < BoardWidth-1 ?
+                        (pos-BoardWidth)+1 : sz-BoardWidth;
+                     break;
+            case W:  pos = x(pos) > 0 ? pos-1 : pos+(BoardWidth-1);
+                     break;
+            case E:  pos = x(pos) < BoardWidth-1 ? pos+1 : pos-(BoardWidth-1);
+                     break;
+            case SW: pos = pos < sz-BoardWidth && x(pos) > 0 ? (pos+BoardWidth)-1 : BoardWidth-1;
+                     break;
+            case S:  pos = pos < sz-BoardWidth ? pos+BoardWidth : x(pos);
+                     break;
+            case SE: pos = pos < sz-BoardWidth && x(pos) < BoardWidth-1 ? (pos+BoardWidth)+1 : 0;
+                     break;
+        }
+    }
+    return pos;                         // here we are
+}
+
+int Board::closeup(int pos, int dir, int target)
+{
+    if (dir == N || dir == S) {
+        if (x(target) < x(pos))
+            return W;
+        if (x(target) > x(pos))
+            return E;
+    } else {
+        if (y(target) < y(pos))
+            return N;
+        if (y(target) > y(pos))
+            return S;
+    }
+    return dir;
+}
+
+int Board::x(int pos)
+{
+    return pos % BoardWidth;
+}
+
+int Board::y(int pos)
+{
+    return pos/BoardWidth;
+}
+
+int Board::turn(int dir)
+{
+    switch (dir) {
+        case N  : return S;
+        case NE : return SW;
+        case E  : return W;
+        case SE : return NW;
+        case S  : return N;
+        case SW : return NE;
+        case W  : return E;
+        case NW : return SE;
+        default : return dir;
+    }
+}
+
+int Board::points()
+{
+    return numPoints;
+}
+
+int Board::energizers()
+{
+    return numEnergizers;
+}
+
+int Board::monsters()
+{
+    return numMonsters;
+}
+
+int Board::tunnels()
+{
+    return numTunnels;
+}
diff --git a/noncore/games/kpacman/board.h b/noncore/games/kpacman/board.h
new file mode 100644
index 0000000..fffde95
--- a/dev/null
+++ b/noncore/games/kpacman/board.h
@@ -0,0 +1,102 @@
+#ifndef BOARD_H
+#define BOARD_H
+
+#include <qarray.h>
+#include <qstring.h>
+#include <qlist.h>
+#include <qrect.h>
+
+#define OUT -1
+
+enum Square {out = OUT, empty, brick, prison, gate, tunnel, prisonentry, prisonexit,
+             Point, energizer, fruit, pacman, monster,
+             fruithome, pacmanhome, monsterhome};
+
+enum Image { None, Intro, Demo, Level, File };
+
+#define X -1
+#define N  0
+#define S  1
+#define E  2
+#define W  3
+#define NE 4
+#define SE 5
+#define NW 6
+#define SW 7
+
+#define BoardWidth 59
+#define BoardHeight 65
+
+#define fixBits      0x0007
+#define varBits      0xFFF8
+#define monsterBits  0xFF00
+
+#define pointBit     0x0008
+#define energizerBit 0x0010
+#define fruitBit     0x0020
+#define pacmanBit    0x0040
+#define monsterBit   0x0100
+
+class Board : public QArray<int>
+{
+public:
+  Board  (int size);
+  ~Board() {};
+  void   init(Image image, QString levelName=0);
+  void   setup(const uchar *buf);
+
+  void   set(int pos, Square sq, int m = 0);
+  void   reset(int pos, Square sq, int m = 0);
+  int    position(Square sq, int m = 0);
+
+  bool   isOut(int pos);
+  bool   isEmpty(int pos);
+  bool   isBrick(int pos);
+  bool   isPrison(int pos);
+  bool   isGate(int pos);
+  bool   isTunnel(int pos);
+  bool   isPoint(int pos);
+  bool   isEnergizer(int pos);
+  bool   isFruit(int pos);
+  bool   isPacman(int pos);
+  bool   isMonster(int pos);
+  bool   isWay(int pos, int dir, Square sq);
+  bool   isJump(int pos, int dir);
+
+  int    move(int pos, int dir, int steps = 1);
+  int    closeup(int pos, int dir, int target);
+  int    x(int pos);
+  int    y(int pos);
+  int    turn(int dir);
+
+  int    points();
+  int    energizers();
+  int    monsters();
+  int    tunnels();
+
+private:
+    bool inBounds(int pos);
+    int  sz;                            // size of board
+
+    QString map;
+    QString mapName;                    // Filename of the latest loaded map
+
+    int  prisonEntry;                   // position of prisonentry
+    int  prisonExit;                    // position of prisonexit
+    int  pacmanHome;                    // startposition of pacman
+    int  monsterHome[8];                // startposition of monsters
+    int  fruitHome;                     // startposition of fruit
+
+    int  pacmanPosition;                // actual position of pacman
+    int  monsterPosition[8];            // actual position of monsters
+    int  fruitPosition;                 // actual position of fruit
+    int  energizerPosition[8];          // actual position of energizers
+    int  tunnelPosition[8];             // position of tunnels
+
+    int  numMonsters;                   // number of monsters on the board
+    int  numPoints;                     // number of points (left) on the board
+    int  numEnergizers;                 // number of energizers (left)
+    int  numTunnels;                    // number of tunnels on the board
+};
+
+#endif // BOARD_H
diff --git a/noncore/games/kpacman/colors.h b/noncore/games/kpacman/colors.h
new file mode 100644
index 0000000..6abf385
--- a/dev/null
+++ b/noncore/games/kpacman/colors.h
@@ -0,0 +1,21 @@
+#ifndef COLORS_H
+#define COLORS_H
+
+#include <qcolor.h>
+
+#define BLACK QColor(Qt::black)
+#define RED QColor(Qt::red)
+#define BROWN QColor(0xde, 0x95, 0x41)
+#define PINK QColor(0xff, 0xba, 0xde)
+#define CYAN QColor(0x00, 0xff, 0xde)
+#define LIGHTBLUE QColor(0x41, 0xba, 0xde)
+#define ORANGE QColor(0xff, 0xba, 0x41)
+#define YELLOW QColor(Qt::yellow)
+#define BLUE QColor(0x20, 0x20, 0xde)
+#define GREEN QColor(Qt::green)
+#define LIGHTGREEN QColor(0x41, 0xba, 0x94)
+#define FLESH QColor(0xff, 0xba, 0x94)
+#define WHITE QColor(0xd8, 0xdc, 0xd8)
+
+#endif // COLORS_H
+
diff --git a/noncore/games/kpacman/config.cpp b/noncore/games/kpacman/config.cpp
new file mode 100644
index 0000000..b9e3607
--- a/dev/null
+++ b/noncore/games/kpacman/config.cpp
@@ -0,0 +1,394 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of Qt Palmtop Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+** $Id$
+**
+**********************************************************************/
+
+#include "config.h"
+
+#include <qfile.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qtextstream.h>
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+#include <qtextcodec.h>
+#endif
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/*!
+  \internal
+*/
+QString Config::configFilename(const QString& name, Domain d)
+{
+    switch (d) {
+	case File:
+	    return name;
+	case User: {
+	    QDir dir = (QString(getenv("HOME")) + "/Settings");
+	    if ( !dir.exists() )
+		mkdir(dir.path().local8Bit(),0700);
+	    return dir.path() + "/" + name + ".conf";
+	}
+    }
+    return name;
+}
+
+/*!
+  \class Config config.h
+  \brief The Config class provides for saving application cofniguration state.
+
+  You should keep a Config in existence only while you do not want others
+  to be able to change the state. There is no locking currently, but there
+  may be in the future.
+*/
+
+/*!
+  \enum Config::ConfigGroup
+  \internal
+*/
+
+/*!
+  \enum Config::Domain
+
+  \value File
+  \value User
+
+  See Config for details.
+*/
+
+/*!
+  Constructs a config that will load or create a configuration with the
+  given \a name in the given \a domain.
+
+  You must call setGroup() before doing much else with the Config.
+
+  In the default Domain, \e User,
+  the configuration is user-specific. \a name should not contain "/" in
+  this case, and in general should be the name of the C++ class that is
+  primarily responsible for maintaining the configuration.
+
+  In the File Domain, \a name is an absolute filename.
+*/
+Config::Config( const QString &name, Domain domain )
+    : filename( configFilename(name,domain) )
+{
+    git = groups.end();
+    read();
+
+    lang = getenv("LANG");
+    int i  = lang.find(".");
+    if ( i > 0 )
+	lang = lang.left( i );
+    i = lang.find( "_" );
+    if ( i > 0 )
+	glang = lang.left(i);
+}
+
+/*!
+  Writes any changes to disk and destroys the in-memory object.
+*/
+Config::~Config()
+{
+    if ( changed )
+	write();
+}
+
+/*!
+  Returns whether the current group has an entry called \a key.
+*/
+bool Config::hasKey( const QString &key ) const
+{
+    if ( groups.end() == git )
+	return FALSE;
+    ConfigGroup::ConstIterator it = ( *git ).find( key );
+    return it != ( *git ).end();
+}
+
+/*!
+  Sets the current group for subsequent reading and writing of
+  entries to \a gname. Grouping allows the application to partition the namespace.
+
+  This function must be called prior to any reading or writing
+  of entries.
+
+  The \a gname must not be empty.
+*/
+void Config::setGroup( const QString &gname )
+{
+    QMap< QString, ConfigGroup>::Iterator it = groups.find( gname );
+    if ( it == groups.end() ) {
+	ConfigGroup *grp = new ConfigGroup;
+	git = groups.insert( gname, *grp );
+	changed = TRUE;
+	return;
+    }
+    git = it;
+}
+
+/*!
+  Writes a (\a key, \a value) entry to the current group.
+
+  \sa readEntry()
+*/
+void Config::writeEntry( const QString &key, const QString &value )
+{
+    if ( git == groups.end() ) {
+	qWarning( "no group set" );
+	return;
+    }
+    if ( (*git)[key] != value ) {
+	( *git ).insert( key, value );
+	changed = TRUE;
+    }
+}
+
+/*!
+  Writes a (\a key, \a num) entry to the current group.
+
+  \sa readNumEntry()
+*/
+void Config::writeEntry( const QString &key, int num )
+{
+    QString s;
+    s.setNum( num );
+    writeEntry( key, s );
+}
+
+#ifdef Q_HAS_BOOL_TYPE
+/*!
+  Writes a (\a key, \a b) entry to the current group.
+
+  \sa readBoolEntry()
+*/
+void Config::writeEntry( const QString &key, bool b )
+{
+    QString s;
+    s.setNum( ( int )b );
+    writeEntry( key, s );
+}
+#endif
+
+/*!
+  Writes a (\a key, \a lst) entry to the current group. The list
+  is separated by \a sep, so the strings must not contain that character.
+
+  \sa readListEntry()
+*/
+void Config::writeEntry( const QString &key, const QStringList &lst, const QChar &sep )
+{
+    QString s;
+    QStringList::ConstIterator it = lst.begin();
+    for ( ; it != lst.end(); ++it )
+	s += *it + sep;
+    writeEntry( key, s );
+}
+
+
+
+/*!
+  Reads a string entry stored with \a key, defaulting to \a deflt if there is no entry.
+*/
+QString Config::readEntry( const QString &key, const QString &deflt )
+{
+    QString res = readEntryDirect( key+"["+lang+"]" );
+    if ( !res.isNull() )
+	return res;
+    if ( !glang.isEmpty() ) {
+	res = readEntryDirect( key+"["+glang+"]" );
+	if ( !res.isNull() )
+	    return res;
+    }
+    return readEntryDirect( key, deflt );
+}
+
+/*!
+  \internal
+*/
+QString Config::readEntryDirect( const QString &key, const QString &deflt )
+{
+    if ( git == groups.end() ) {
+	//qWarning( "no group set" );
+	return deflt;
+    }
+    ConfigGroup::Iterator it = ( *git ).find( key );
+    if ( it != ( *git ).end() )
+	return *it;
+    else
+	return deflt;
+}
+
+/*!
+  Reads a numeric entry stored with \a key, defaulting to \a deflt if there is no entry.
+*/
+int Config::readNumEntry( const QString &key, int deflt )
+{
+    QString s = readEntry( key );
+    if ( s.isEmpty() )
+	return deflt;
+    else
+	return s.toInt();
+}
+
+/*!
+  Reads a bool entry stored with \a key, defaulting to \a deflt if there is no entry.
+*/
+bool Config::readBoolEntry( const QString &key, bool deflt )
+{
+    QString s = readEntry( key );
+    if ( s.isEmpty() )
+	return deflt;
+    else
+	return (bool)s.toInt();
+}
+
+/*!
+  Reads a string list entry stored with \a key, and with \a sep as the separator.
+*/
+QStringList Config::readListEntry( const QString &key, const QChar &sep )
+{
+    QString s = readEntry( key );
+    if ( s.isEmpty() )
+	return QStringList();
+    else
+	return QStringList::split( sep, s );
+}
+
+/*!
+  Removes all entries from the current group.
+*/
+void Config::clearGroup()
+{
+    if ( git == groups.end() ) {
+	qWarning( "no group set" );
+	return;
+    }
+    if ( !(*git).isEmpty() ) {
+	( *git ).clear();
+	changed = TRUE;
+    }
+}
+
+/*!
+  \internal
+*/
+void Config::write( const QString &fn )
+{
+    if ( !fn.isEmpty() )
+	filename = fn;
+
+    QFile f( filename );
+    if ( !f.open( IO_WriteOnly ) ) {
+	qWarning( "could not open for writing `%s'", filename.latin1() );
+	git = groups.end();
+	return;
+    }
+
+    QTextStream s( &f );
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+    // The below should work, but doesn't in Qt 2.3.0
+    s.setCodec( QTextCodec::codecForMib( 106 ) );
+#else
+    s.setEncoding( QTextStream::UnicodeUTF8 );
+#endif
+    QMap< QString, ConfigGroup >::Iterator g_it = groups.begin();
+    for ( ; g_it != groups.end(); ++g_it ) {
+	s << "[" << g_it.key() << "]" << "\n";
+	ConfigGroup::Iterator e_it = ( *g_it ).begin();
+	for ( ; e_it != ( *g_it ).end(); ++e_it )
+	    s << e_it.key() << " = " << *e_it << "\n";
+    }
+
+    f.close();
+}
+
+/*!
+  Returns whether the Config is in a valid state.
+*/
+bool Config::isValid() const
+{
+    return groups.end() != git;
+}
+
+/*!
+  \internal
+*/
+void Config::read()
+{
+    changed = FALSE;
+
+    if ( !QFileInfo( filename ).exists() ) {
+	git = groups.end();
+	return;
+    }
+
+    QFile f( filename );
+    if ( !f.open( IO_ReadOnly ) ) {
+	git = groups.end();
+	return;
+    }
+
+    QTextStream s( &f );
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+    // The below should work, but doesn't in Qt 2.3.0
+    s.setCodec( QTextCodec::codecForMib( 106 ) );
+#else
+    s.setEncoding( QTextStream::UnicodeUTF8 );
+#endif
+
+    QString line;
+    while ( !s.atEnd() ) {
+	line = s.readLine();
+	if ( !parse( line ) ) {
+	    git = groups.end();
+	    return;
+	}
+    }
+
+    f.close();
+}
+
+/*!
+  \internal
+*/
+bool Config::parse( const QString &l )
+{
+    QString line = l.stripWhiteSpace();
+    if ( line[ 0 ] == QChar( '[' ) ) {
+	QString gname = line;
+	gname = gname.remove( 0, 1 );
+	if ( gname[ (int)gname.length() - 1 ] == QChar( ']' ) )
+	    gname = gname.remove( gname.length() - 1, 1 );
+	ConfigGroup *grp = new ConfigGroup;
+	git = groups.insert( gname, *grp );
+    } else if ( !line.isEmpty() ) {
+	if ( git == groups.end() )
+	    return FALSE;
+	int eq = line.find( '=' );
+	if ( eq == -1 )
+	    return FALSE;
+	QString key = line.left(eq).stripWhiteSpace();
+	QString value = line.mid(eq+1).stripWhiteSpace();
+	( *git ).insert( key, value );
+    }
+    return TRUE;
+}
diff --git a/noncore/games/kpacman/config.h b/noncore/games/kpacman/config.h
new file mode 100644
index 0000000..3c26b5d
--- a/dev/null
+++ b/noncore/games/kpacman/config.h
@@ -0,0 +1,74 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of Qt Designer.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+// ##### could use QSettings with Qt 3.0
+
+#include <qmap.h>
+#include <qstringlist.h>
+
+class ConfigPrivate;
+class Config
+{
+public:
+    typedef QMap< QString, QString > ConfigGroup;
+    
+    enum Domain { File, User };
+    Config( const QString &name, Domain domain=User );
+    ~Config();
+
+    bool isValid() const;
+    bool hasKey( const QString &key ) const;
+    
+    void setGroup( const QString &gname );
+    void writeEntry( const QString &key, const QString &value );
+    void writeEntry( const QString &key, int num );
+#ifdef Q_HAS_BOOL_TYPE
+    void writeEntry( const QString &key, bool b );
+#endif
+    void writeEntry( const QString &key, const QStringList &lst, const QChar &sep );
+    
+    QString readEntry( const QString &key, const QString &deflt = QString::null );	
+    QString readEntryDirect( const QString &key, const QString &deflt = QString::null );	
+    int readNumEntry( const QString &key, int deflt = -1 );
+    bool readBoolEntry( const QString &key, bool deflt = FALSE );
+    QStringList readListEntry( const QString &key, const QChar &sep ); 
+    
+    void clearGroup();
+    
+    void write( const QString &fn = QString::null );
+    
+protected:
+    void read();
+    bool parse( const QString &line );
+    
+    QMap< QString, ConfigGroup > groups;
+    QMap< QString, ConfigGroup >::Iterator git;
+    QString filename;
+    QString lang;
+    QString glang;
+    bool changed;
+    ConfigPrivate *d;
+    static QString configFilename(const QString& name, Domain);
+};
+
+#endif
diff --git a/noncore/games/kpacman/energizer.cpp b/noncore/games/kpacman/energizer.cpp
new file mode 100644
index 0000000..ca08f3b
--- a/dev/null
+++ b/noncore/games/kpacman/energizer.cpp
@@ -0,0 +1,61 @@
+#include "energizer.h"
+
+Energizer::Energizer(Board *b)
+{
+    board = b;
+    setOn();
+    actualPosition = OUT;
+    maxPixmaps = 0;
+}
+
+void Energizer::setMaxPixmaps(int max)
+{
+    maxPixmaps = max;
+}
+
+void Energizer::setOff()
+{
+    actualState = off;
+}
+
+void Energizer::setOn()
+{
+    actualState = on;
+    actualPix = 0;
+}
+
+void Energizer::setPosition(int pos)
+{
+    board->reset(actualPosition, energizer);
+    actualPosition = pos;
+    board->set(actualPosition, energizer);
+}
+
+energizerState Energizer::state()
+{
+    return actualState;
+}
+
+int Energizer::position()
+{
+    return actualPosition;
+}
+
+bool Energizer::move()
+{
+    if (actualPosition == OUT)
+        return FALSE;
+
+    if (++actualPix >= maxPixmaps)
+        actualPix = 0;
+
+    return TRUE;
+}
+
+int Energizer::pix()
+{
+    if (actualPosition == OUT || actualState == off)
+        return -1;
+
+    return actualPix;
+}
diff --git a/noncore/games/kpacman/energizer.h b/noncore/games/kpacman/energizer.h
new file mode 100644
index 0000000..377cd02
--- a/dev/null
+++ b/noncore/games/kpacman/energizer.h
@@ -0,0 +1,30 @@
+#ifndef ENERGIZER_H
+#define ENERGIZER_H
+
+#include "board.h"
+
+enum energizerState { on, off };
+
+class Energizer {
+public:
+    Energizer(Board *b);
+    void setMaxPixmaps(int max);
+    void setOff();
+    void setOn();
+    void setPosition(int pos);
+    energizerState state();
+    int position();
+    bool move();
+    int pix();
+
+private:
+    Board   *board;
+
+    energizerState actualState;         // the state of energizer
+
+    int  actualPix;                     // last Pixmap-index
+    int  maxPixmaps;                    // Number of Pixmaps (1..)
+    int  actualPosition;                // actual position on board
+};
+
+#endif // ENERGIZER_H
diff --git a/noncore/games/kpacman/fruit.cpp b/noncore/games/kpacman/fruit.cpp
new file mode 100644
index 0000000..e6ad2d5
--- a/dev/null
+++ b/noncore/games/kpacman/fruit.cpp
@@ -0,0 +1,176 @@
+#include <stdlib.h>
+
+#include "fruit.h"
+
+Fruit::Fruit(Board *b)
+{
+    board = b;
+    maxPixmaps = 0;
+    setLevel(0, 0, 0, 0);
+}
+
+void Fruit::setEaten(int duration)
+{
+    actualState = eaten;
+    timeLeft = duration;
+    actualDirection = X;
+}
+  
+void Fruit::setLevel(int level, int wDuration, int fDuration, int ticks)
+{
+    actualLevel = level;
+    waitDuration = wDuration;
+    fruitDuration = fDuration;
+    pauseDuration = ticks;
+    pause = 0;
+    actualState = inactive;
+    timeLeft = waitDuration;
+    lastPosition = OUT;
+    setPosition(OUT);
+    setMovement(OUT, OUT, 0);
+    actualDirection = X;
+    setMaxPixmaps(maxPixmaps);
+}
+
+void Fruit::setMaxPixmaps(int max)
+{
+    maxPixmaps = max;
+    if (actualLevel-1 < maxPixmaps)
+        actualPix = actualLevel == 0 ? 0 : actualLevel-1;
+    else if (maxPixmaps > 0)
+        actualPix = rand() % maxPixmaps;
+    else
+        actualPix = -1;
+}
+
+void Fruit::setMovement(int entry, int tunnel, int iq)
+{
+    homePosition = board->position(fruithome);
+    entryPosition = entry;
+    tunnelPosition = tunnel;
+    IQ = iq;
+}
+
+void Fruit::setPosition(int pos)
+{
+    board->reset(lastPosition, fruit);
+    actualPosition = lastPosition = pos;
+    board->set(actualPosition, fruit);
+}
+
+void Fruit::setDirection(int dir)
+{
+    actualDirection = dir;
+}
+
+fruitState Fruit::state()
+{
+    return actualState;
+}
+
+int Fruit::position()
+{
+    return actualPosition;
+}
+
+int Fruit::direction()
+{
+    return actualDirection;
+}
+
+bool Fruit::move(bool activate)
+{
+    if (timeLeft > 0) {
+        timeLeft--;
+    }
+
+    if (actualDirection == X || actualState == inactive) {
+        if (timeLeft == 0 || (activate && actualState == inactive)) {
+            if (actualState == inactive) {
+                if (entryPosition == OUT || tunnelPosition == OUT) {
+                    setPosition(board->position(fruithome));
+                } else {
+                    setPosition(entryPosition);
+                    actualDirection = 0;
+                    while (!board->isWay(actualPosition, actualDirection, empty) ||
+                           board->isJump(actualPosition, actualDirection))
+                        actualDirection++;
+                }
+                timeLeft = fruitDuration;
+                setMaxPixmaps(maxPixmaps);
+                actualState = active;
+            } else {
+                actualState = inactive;
+                setPosition(OUT);
+                timeLeft = waitDuration;
+                actualDirection = X;
+            }
+            return TRUE;
+        }
+        return FALSE;
+    }
+
+    if (pause-- > 0)
+        return FALSE;
+    else
+        pause = pauseDuration;
+
+    if (actualPosition == OUT)
+        return FALSE;
+
+    if (actualDirection == X)
+        return TRUE;
+
+    int d = actualDirection;
+
+    if (rand() % (int) ((190-IQ)/10) == 0)
+        if (timeLeft > 0)               // coming home or leaving again
+            d = board->closeup(actualPosition, d, homePosition);
+        else                    
+            d = board->closeup(actualPosition, d, tunnelPosition);
+    else
+        do                              // try new direction, but not the opposite
+            d = rand() % 4;             // direction, to prevent hectic movement.
+        while (d == board->turn(actualDirection));
+
+    while ((!board->isWay(actualPosition, d, empty) &&
+            !board->isWay(actualPosition, d, tunnel)) ||
+           d == board->turn(actualDirection)) {
+        if (d != actualDirection)       // if new direction is not possible,
+            d = actualDirection;        // try current direction first.
+        else
+            d = rand() % 4;
+    }
+
+    actualDirection = d;
+    actualPosition = board->move(actualPosition, actualDirection);
+
+    if (actualPosition == homePosition) {
+        timeLeft = 0;
+    }
+
+    if (board->isTunnel(actualPosition)) {
+        setPosition(OUT);
+        timeLeft = waitDuration;
+        actualState = inactive;
+        actualDirection = X;
+        if (board->tunnels() > 0) {
+            entryPosition = board->position(tunnel, rand() % board->tunnels());
+            tunnelPosition = board->position(tunnel, rand() % board->tunnels());
+        }
+    }
+
+    if (actualPosition != lastPosition) {
+        setPosition(actualPosition);
+    }
+
+    return TRUE;
+}
+
+int Fruit::pix()
+{
+    if (actualPosition == OUT || actualState == inactive)
+        return -1;
+    else
+        return actualPix;
+}
diff --git a/noncore/games/kpacman/fruit.h b/noncore/games/kpacman/fruit.h
new file mode 100644
index 0000000..fbbd9c0
--- a/dev/null
+++ b/noncore/games/kpacman/fruit.h
@@ -0,0 +1,53 @@
+#ifndef FRUIT_H
+#define FRUIT_H
+
+#include <stdlib.h>
+
+#include "board.h"
+
+enum fruitState { inactive, active, eaten };
+
+class Fruit {
+public:
+    Fruit(Board *b);
+    void setEaten(int duration);
+    void setLevel(int level, int wDuration, int fDuration, int ticks = -1);
+    void setMaxPixmaps(int max);
+    void setMovement(int entry, int tunnel, int iq);
+    void setPosition(int pos);
+    void setDirection(int dir);
+    fruitState state();
+    int position();
+    int direction();
+    bool move(bool activate=FALSE);
+    int pix();
+
+private:
+    Board   *board;
+
+    int  IQ;                            // Intelligence of movement (0 = dumb..180=smart)
+
+    fruitState actualState;             // the state of fruit
+
+    int  pauseDuration;                 // number of ticks before next movement
+    int  pause;                         // actual ticks before movement (0 = move)
+
+    int  timeLeft;                      // Ticks remaining of current state
+
+    int  waitDuration;                  // Time before fruit appears
+    int  fruitDuration;                 // Length of active-time in ticks
+
+    int  actualDirection;               // actual direction of the fruit
+    int  actualPosition;                // actual position on board
+    int  lastPosition;                  // the last position of the fruit
+    int  actualLevel;                   // level for kind of fruit and score
+    int  actualPix;             
+    int  maxPixmaps;                    // Number of Pixmaps (1..)
+
+    int  entryPosition;                 // where to come in
+    int  homePosition;                  // where to go, on the way in
+    int  tunnelPosition;                // where to exit
+};
+
+#endif // FRUIT_H
+
diff --git a/noncore/games/kpacman/keys.cpp b/noncore/games/kpacman/keys.cpp
new file mode 100644
index 0000000..c609373
--- a/dev/null
+++ b/noncore/games/kpacman/keys.cpp
@@ -0,0 +1,203 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kconfig.h>
+#include <klocale.h>
+#include <kstddirs.h>
+#include <kaccel.h>
+
+#include <keys.h>
+#include <keys.moc>
+#elif defined( QPE_PORT )
+#include <qaccel.h>
+#include <qpe/qpeapplication.h>
+#include "config.h"
+#include "keys.h"
+#endif
+
+#include <qpushbt.h>
+#include <qlabel.h>
+#include <qframe.h>
+#include <qkeycode.h>
+#include <qpixmap.h>
+#include <qstring.h>
+
+Keys::Keys( QWidget *parent, const char *name)
+    : QDialog( parent, name, TRUE )
+{
+    //KStandardDirs *dirs = KGlobal::dirs();
+
+    QPushButton *okButton  = new QPushButton(this);
+    okButton->setText(i18n("Ok"));
+    okButton->setFixedSize(okButton->size());
+    connect( okButton, SIGNAL(clicked()),this, SLOT(ok()) );
+    okButton->move(20,210);
+
+    QPushButton *defaultButton  = new QPushButton(this);
+    defaultButton->setText(i18n("Defaults"));
+    defaultButton->setFixedSize(defaultButton->size());
+    connect( defaultButton, SIGNAL(clicked()),this, SLOT(defaults()) );
+    defaultButton->move(140,210);
+
+    QPushButton *cancelButton  = new QPushButton(this);
+    cancelButton->setText(i18n("Cancel"));
+    cancelButton->setFixedSize(cancelButton->size());
+    connect( cancelButton, SIGNAL(clicked()),this, SLOT(reject()) );
+    cancelButton->move(260,210);
+
+    QFrame *separator = new QFrame(this);
+    separator->setFrameStyle( QFrame::HLine | QFrame::Sunken );
+    separator->setGeometry( 20, 190, 340, 4 );
+
+    for ( int x = 0; x < 4; x++) {
+            QLabel *l = new QLabel(this);
+            l->setAlignment(AlignCenter);
+            labels[x] = l;
+    }
+
+    labels[0]->setGeometry(120, 20, 140, 20 );
+    labels[1]->setGeometry(120,160, 140, 20 );
+    labels[2]->setGeometry( 20, 92, 100, 20 );
+    labels[3]->setGeometry(265, 92, 100, 20 );
+
+    QString pixPath;
+
+    QPushButton *up = new QPushButton(this);
+    pixPath = FIND_APP_DATA( "pics/up.xpm" );
+    up->setPixmap( QPixmap(pixPath));
+    up->setFixedSize(up->pixmap()->size());
+    connect( up, SIGNAL(clicked()),this, SLOT(butUp()) );
+    up->move(180, 50);
+
+    QPushButton *down = new QPushButton(this);
+    pixPath = FIND_APP_DATA( "pics/down.xpm");
+    down->setPixmap( QPixmap(pixPath));
+    down->setFixedSize(down->pixmap()->size());
+    connect( down, SIGNAL(clicked()),this, SLOT(butDown()) );
+    down->move(180, 130);
+
+    QPushButton *left = new QPushButton(this);
+    pixPath = FIND_APP_DATA( "pics/left.xpm");
+    left->setPixmap( QPixmap(pixPath));
+    left->setFixedSize(left->pixmap()->size());
+    connect( left, SIGNAL(clicked()),this, SLOT(butLeft()) );
+    left->move(140, 90);
+
+    QPushButton *right = new QPushButton(this);
+    pixPath = FIND_APP_DATA( "pics/right.xpm");
+    right->setPixmap( QPixmap(pixPath));
+    right->setFixedSize(right->pixmap()->size());
+    connect( right, SIGNAL(clicked()),this, SLOT(butRight()) );
+    right->move(220, 90);
+
+
+    setCaption(i18n("Change Direction Keys"));
+    setFixedSize(380, 260);
+    lab = 0;
+    init();
+}
+
+void Keys::keyPressEvent( QKeyEvent *e )
+{
+        uint kCode = e->key() & ~(SHIFT | CTRL | ALT);
+        QString string = KAccel::keyToString(kCode);
+
+        if (lab != 0) {
+            if ( string.isNull() )
+                    lab->setText(i18n("Undefined key"));
+            else
+                lab->setText(string);
+        }
+        else if ( lab == 0 && e->key() == Key_Escape)
+            reject();
+}
+
+void Keys::butUp()
+{
+    getKey(0);
+}
+
+void Keys::butDown()
+{
+    getKey(1);
+}
+
+void Keys::butLeft()
+{
+    getKey(2);
+}
+
+void Keys::butRight()
+{
+    getKey(3);
+}
+
+void Keys::getKey(int i)
+{
+    if ( lab != 0)
+            focusOut(lab);
+
+    focusIn(labels[i]);
+}
+
+void Keys::focusOut(QLabel *l)
+{
+    l->setFrameStyle( QFrame::NoFrame );
+    l->setBackgroundColor(backgroundColor());
+    l->repaint();
+}
+
+void Keys::focusIn(QLabel *l)
+{
+    lab = l;
+    lab->setFrameStyle( QFrame::Panel | QFrame::Sunken );
+    lab->setBackgroundColor(white);
+    lab->repaint();
+}
+
+void Keys::defaults()
+{
+    if ( lab != 0)
+            focusOut(lab);
+
+    lab = 0;
+
+    labels[0]->setText("Up");
+    labels[1]->setText("Down");
+    labels[2]->setText("Left");
+    labels[3]->setText("Right");
+}
+
+void Keys::init()
+{
+    APP_CONFIG_BEGIN( cfg );
+    QString up("Up");
+    up = cfg->readEntry("upKey", (const char*) up);
+    labels[0]->setText(up);
+
+    QString down("Down");
+    down = cfg->readEntry("downKey", (const char*) down);
+    labels[1]->setText(down);
+
+    QString left("Left");
+    left = cfg->readEntry("leftKey", (const char*) left);
+    labels[2]->setText(left);
+
+    QString right("Right");
+    right = cfg->readEntry("rightKey", (const char*) right);
+    labels[3]->setText(right);
+    APP_CONFIG_END( cfg );
+}
+
+void Keys::ok()
+{
+    APP_CONFIG_BEGIN( cfg );
+    cfg->writeEntry("upKey",   (const char*) labels[0]->text() );
+    cfg->writeEntry("downKey", (const char*) labels[1]->text() );
+    cfg->writeEntry("leftKey", (const char*) labels[2]->text() );
+    cfg->writeEntry("rightKey",(const char*) labels[3]->text() );
+    APP_CONFIG_END( cfg );
+    accept();
+}
diff --git a/noncore/games/kpacman/keys.h b/noncore/games/kpacman/keys.h
new file mode 100644
index 0000000..c0c9d82
--- a/dev/null
+++ b/noncore/games/kpacman/keys.h
@@ -0,0 +1,48 @@
+#ifndef KEYS_H
+#define KEYS_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kaccel.h>
+#endif
+
+#include <qdialog.h>
+#include <qlabel.h>
+#include <qstring.h>
+
+class Keys : public QDialog
+{
+    Q_OBJECT
+public:
+    Keys( QWidget *parent=0, const char *name=0 );
+
+private slots:
+    void butRight();
+    void butLeft();
+    void butUp();
+    void butDown();
+
+    void getKey(int);
+    void defaults();
+    void focusIn(QLabel *);
+    void focusOut(QLabel *);
+
+    void ok();
+
+protected:
+    void  keyPressEvent( QKeyEvent * );
+
+private:
+    void init();
+
+    QLabel *labels[4];
+    QLabel *lab;
+};
+
+#endif // KEYS_H
diff --git a/noncore/games/kpacman/kpacman.cpp b/noncore/games/kpacman/kpacman.cpp
new file mode 100644
index 0000000..4077085
--- a/dev/null
+++ b/noncore/games/kpacman/kpacman.cpp
@@ -0,0 +1,369 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kpacman.h>
+#include <kpacman.moc>
+#include <kcolordlg.h>
+#elif defined( QPE_PORT )
+#include <qmenubar.h>
+#include "config.h"
+#include <qapplication.h>
+#include "kpacman.h"
+#endif
+
+#include <qkeycode.h>
+#include <qcolor.h>
+#include <qstring.h>
+#include <qpopmenu.h>
+#include <qmsgbox.h>
+
+Kpacman::Kpacman(QWidget *parent, const char *name)
+        : KTMainWindow(parent, name)
+{
+    schemesPopup = new QList<QPopupMenu>;
+    schemesPopup->setAutoDelete(TRUE);
+
+    menu();
+
+    view = new KpacmanWidget( this, QString(name)+"widget");
+
+#ifndef QWS
+    setFixedSize(view->width(), view->height());
+#else
+    setCaption( "Kpacman" );
+#endif
+
+    view->referee->setFocus();
+
+    connect(view->referee, SIGNAL(setScore(int, int)),
+            view->score, SLOT(setScore(int, int)));
+    connect(view->referee, SIGNAL(setPoints(int)),
+            view->score, SLOT(set(int)));
+    connect(view->referee, SIGNAL(setLifes(int)),
+            view->status, SLOT(setLifes(int)));
+    connect(view->referee, SIGNAL(setLevel(int)),
+            view->status, SLOT(setLevel(int)));
+    connect(view->referee, SIGNAL(forcedHallOfFame(bool)),
+            this, SLOT(forcedHallOfFame(bool)));
+    connect(view->referee, SIGNAL(togglePaused()), this, SLOT(togglePaused()));
+    connect(view->referee, SIGNAL(toggleNew()), this, SLOT(toggleNew()));
+
+    connect(view->score, SIGNAL(toggleNew()), this, SLOT(toggleNew()));
+    connect(view->score, SIGNAL(forcedHallOfFame(bool)),
+            this, SLOT(forcedHallOfFame(bool)));
+
+    APP_CONFIG_BEGIN( cfg );
+    focusOutPause = !cfg->readBoolEntry("FocusOutPause", TRUE);
+    focusInContinue = !cfg->readBoolEntry("FocusInContinue", TRUE);
+    hideMouseCursor = !cfg->readBoolEntry("HideMouseCursor", TRUE);
+    APP_CONFIG_END( cfg );
+
+    toggleFocusOutPause();
+    toggleFocusInContinue();
+    toggleHideMouseCursor();
+
+#ifndef QWS
+    menuBar->show();
+    view->show();
+    setMenu(menuBar);
+    setView(view);
+#else
+    setCentralWidget( view );
+#endif
+}
+
+Kpacman::~Kpacman()
+{
+    APP_CONFIG_BEGIN( cfg );
+    cfg->writeEntry("FocusOutPause", focusOutPause);
+    cfg->writeEntry("FocusInContinue", focusInContinue);
+    cfg->writeEntry("HideMouseCursor", hideMouseCursor);
+    APP_CONFIG_END( cfg );
+    delete _menuBar;
+}
+
+void Kpacman::menu()
+{
+    gamePopup = new QPopupMenu();
+    CHECK_PTR( gamePopup );
+    newID = gamePopup->insertItem(i18n("&New"), this, SLOT(newKpacman()),Key_F2);
+    pauseID = gamePopup->insertItem(i18n("&Pause"),
+                                    this, SLOT(pauseKpacman()), Key_F3);
+    hofID = gamePopup->insertItem(i18n("&Hall of fame"),
+                                    this, SLOT(toggleHallOfFame()), Key_F4);
+    gamePopup->insertSeparator();
+    gamePopup->insertItem(i18n("&Quit"), this, SLOT(quitKpacman()), CTRL+Key_Q);
+    gamePopup->setCheckable(TRUE);
+
+    optionsPopup = new QPopupMenu();
+    CHECK_PTR(optionsPopup);
+
+    modesPopup = new QPopupMenu();
+    CHECK_PTR(modesPopup);
+
+    hideMouseCursorID = optionsPopup->insertItem(i18n("&Hide Mousecursor"),
+                                                 this, SLOT(toggleHideMouseCursor()),
+                                                 CTRL+Key_H);
+    optionsPopup->insertSeparator();
+
+    if (lookupSchemes() > 0) {
+        optionsPopup->insertItem(i18n("&Select graphic scheme"),  modesPopup);
+        optionsPopup->insertSeparator();
+    }
+
+    focusOutPauseID = optionsPopup->insertItem(i18n("&Pause in Background"),
+                                               this, SLOT(toggleFocusOutPause()));
+    focusInContinueID = optionsPopup->insertItem(i18n("&Continue in Foreground"),
+                                              this, SLOT(toggleFocusInContinue()));
+    optionsPopup->insertSeparator();
+
+    optionsPopup->insertItem(i18n("Change &keys..."), this, SLOT(confKeys()));
+
+#ifndef QWS
+    QString aboutText = i18n("@PACKAGE@ - @VERSION@\n\n"
+                             "Joerg Thoennissen (joe@dsite.de)\n\n"
+                             "A pacman game for the KDE Desktop\n\n"
+                             "The program based on the source of ksnake\n"
+                             "by Michel Filippi (mfilippi@sade.rhein-main.de).\n"
+                             "The design was strongly influenced by the pacman\n"
+                             "(c) 1980 MIDWAY MFG.CO.\n\n"
+                             "I like to thank my girlfriend Elke Krueers for\n"
+                             "the last 10 years of her friendship.\n");
+    aboutText.replace(QRegExp("@PACKAGE@"), PACKAGE);
+    aboutText.replace(QRegExp("@VERSION@"), VERSION);
+    QPopupMenu *helpPopup = helpMenu(aboutText, FALSE);
+#endif
+
+    //_menuBar = new KMenuBar(this);
+    //CHECK_PTR( _menuBar );
+    //_menuBar->insertItem(i18n("&Game"), gamePopup);
+    //_menuBar->insertItem(i18n("&Options"), optionsPopup);
+    //_menuBar->insertSeparator();
+#ifndef QWS
+    _menuBar->insertItem(i18n("&Help"), helpPopup);
+#endif
+}
+
+int Kpacman::lookupSchemes()
+{
+    APP_CONFIG_BEGIN( cfg );
+    int ModeCount = cfg->readNumEntry("ModeCount", -1);
+    int Mode = cfg->readNumEntry("Mode", -1);
+    int SchemeCount = cfg->readNumEntry("SchemeCount");
+    int Scheme = cfg->readNumEntry("Scheme", -1);
+
+    if (SchemeCount == 0 || Scheme == -1) {
+        QMessageBox::warning(this, i18n("Configuration Error"),
+                                   i18n("There are no schemes defined,\n"
+                                        "or no scheme is selected."));
+        APP_CONFIG_END( cfg );
+        return 0;
+    }
+
+    connect(modesPopup, SIGNAL(activated(int)), this, SLOT(schemeChecked(int)));
+    modeID.resize(ModeCount > 0 ? ModeCount : 0);
+
+    if (!schemesPopup->isEmpty())
+        schemesPopup->clear();
+
+    SAVE_CONFIG_GROUP( cfg, oldgroup );
+
+    QString ModeGroup;
+    QString ModeName;
+
+    for (int m = 0; m < ModeCount; m++) {
+        ModeGroup.sprintf("Mode %d", m);
+        cfg->setGroup(ModeGroup);
+
+        ModeName = cfg->readEntry("Description", ModeGroup);
+
+        QPopupMenu *p = new QPopupMenu;
+        p->setCheckable(TRUE);
+        connect(p, SIGNAL(activated(int)), this, SLOT(schemeChecked(int)));
+        schemesPopup->append(p);
+
+        modeID[m] = modesPopup->insertItem(ModeName, schemesPopup->at(m));
+        modesPopup->setItemEnabled(modeID[m], FALSE);
+        modesPopup->setItemChecked(modeID[m], m == Mode);
+    }
+
+    schemeID.resize(SchemeCount);
+    schemeMode.resize(SchemeCount);
+
+    QString SchemeGroup;
+    QString SchemeName;
+    int SchemeMode;
+
+    for (int i = 0; i < SchemeCount; i++) {
+        SchemeGroup.sprintf("Scheme %d", i);
+        cfg->setGroup(SchemeGroup);
+
+        SchemeName = cfg->readEntry("Description", SchemeGroup);
+        SchemeMode = cfg->readNumEntry("Mode", -1);
+
+        schemeMode[i] = SchemeMode;
+        if (SchemeMode == -1) {
+            schemeID[i] = modesPopup->insertItem(SchemeName);
+            modesPopup->setItemChecked(schemeID[i], i == Scheme);
+        } else {
+            schemeID[i] = schemesPopup->at(SchemeMode)->insertItem(SchemeName);
+            schemesPopup->at(SchemeMode)->
+                setItemChecked(schemeID[i], i == Scheme);
+            modesPopup->setItemEnabled(modeID[SchemeMode], TRUE);
+        }
+    }
+
+    RESTORE_CONFIG_GROUP( cfg, oldgroup );
+
+    APP_CONFIG_END( cfg );
+    return SchemeCount;
+}
+
+void Kpacman::quitKpacman()
+{
+    APP_QUIT();
+}
+
+void Kpacman::newKpacman()
+{
+    if (!gamePopup->isItemEnabled(hofID))
+        gamePopup->setItemEnabled(hofID, TRUE);
+
+    if (gamePopup->isItemChecked(hofID))
+        toggleHallOfFame();
+
+    if (gamePopup->isItemChecked(pauseID))
+        pauseKpacman();
+
+    view->referee->play();
+}
+
+void Kpacman::pauseKpacman()
+{
+    view->referee->pause();
+    view->score->setPause(gamePopup->isItemChecked(pauseID));
+}
+
+void Kpacman::toggleHallOfFame()
+{
+    gamePopup->setItemChecked(hofID, !gamePopup->isItemChecked(hofID));
+    view->referee->toggleHallOfFame();
+
+    if (gamePopup->isItemChecked(hofID)) {
+        view->referee->lower();
+        view->status->lower();
+    } else {
+        view->status->raise();
+        view->referee->raise();
+        view->referee->setFocus();
+    }
+}
+
+/*
+ * Disable or enable the "Hall of fame"-menuitem if the referee says so.
+ * This is done, to disable turning off the "hall of fame"-display, in the automated
+ * sequence of displaying the introduction, the demonstration (or playing) and the
+ * hall of fame.
+ * If on == TRUE then also lower the referee and the status widgets.
+ */
+void Kpacman::forcedHallOfFame(bool on)
+{
+    if (!on && !gamePopup->isItemChecked(hofID))
+        return;
+
+    gamePopup->setItemEnabled(hofID, !on);
+    gamePopup->setItemChecked(hofID, on);
+
+    view->referee->toggleHallOfFame();
+    if (on) {
+        view->referee->lower();
+        view->status->lower();
+    } else {
+        view->status->raise();
+        view->referee->raise();
+        view->referee->setFocus();
+        view->referee->intro();
+    }
+}
+
+void Kpacman::togglePaused()
+{
+    static bool checked = FALSE;
+    checked = !checked;
+    gamePopup->setItemChecked( pauseID, checked );
+    view->score->setPause(gamePopup->isItemChecked(pauseID));
+}
+
+/*
+ * This disables the "New Game" menuitem to prevent interruptions of the current
+ * play.
+ */
+void Kpacman::toggleNew()
+{
+    gamePopup->setItemEnabled(newID, !gamePopup->isItemEnabled(newID));
+}
+
+void Kpacman::toggleHideMouseCursor()
+{
+    hideMouseCursor = !hideMouseCursor;
+    optionsPopup->setItemChecked(hideMouseCursorID, hideMouseCursor);
+    if (hideMouseCursor)
+        view->setCursor(blankCursor);
+    else
+        view->setCursor(arrowCursor);
+}
+
+void Kpacman::toggleFocusOutPause()
+{
+    focusOutPause = !focusOutPause;
+    optionsPopup->setItemChecked(focusOutPauseID, focusOutPause);
+    view->referee->setFocusOutPause(focusOutPause);
+}
+
+void Kpacman::toggleFocusInContinue()
+{
+    focusInContinue = !focusInContinue;
+    optionsPopup->setItemChecked(focusInContinueID, focusInContinue);
+    view->referee->setFocusInContinue(focusInContinue);
+}
+
+void Kpacman::confKeys()
+{
+    Keys *keys = new Keys();
+    if (keys->exec() == QDialog::Accepted) {
+        view->referee->initKeys();
+        view->score->initKeys();
+    }
+    delete keys;
+}
+
+void Kpacman::schemeChecked(int id)
+{
+    int mode = 0, scheme = -1;
+
+    for (uint s = 0; s < schemeID.size(); s++) {
+        if (schemeID[s] == id) {
+            scheme = s;
+            mode = schemeMode[s];
+        }
+        if (schemeMode[s] == -1) {
+						modesPopup->setItemChecked(schemeID[s], schemeID[s] == id);
+				} else {
+						modesPopup->setItemChecked(modeID[schemeMode[s]], schemeMode[s] == mode);
+						schemesPopup->at(schemeMode[s])->setItemChecked(schemeID[s], schemeID[s] == id);
+				}
+		}
+
+    APP_CONFIG_BEGIN( cfg );
+    cfg->writeEntry("Scheme", scheme);
+    cfg->writeEntry("Mode", mode);
+    APP_CONFIG_END( cfg );
+
+    view->setScheme(scheme, mode);
+    view->updateGeometry();
+    updateGeometry();
+    update();
+    repaint(TRUE);
+    show();
+}
diff --git a/noncore/games/kpacman/kpacman.h b/noncore/games/kpacman/kpacman.h
new file mode 100644
index 0000000..d7de9de
--- a/dev/null
+++ b/noncore/games/kpacman/kpacman.h
@@ -0,0 +1,95 @@
+#ifndef KPACMAN_H
+#define KPACMAN_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <klocale.h>
+#include <ktmainwindow.h>
+#include <kmenubar.h>
+#elif defined( QPE_PORT )
+#include <qmainwindow.h>
+class QMenuBar;
+#endif
+
+#include <qregexp.h>
+
+#include "kpacmanwidget.h"
+
+#include <qpopmenu.h>
+
+#include <qlist.h>
+#include <qfileinf.h>
+
+#if defined( KDE2_PORT )
+#include <referee.h>
+#include <status.h>
+#include <score.h>
+#include <keys.h>
+#elif defined( QPE_PORT )
+#include "referee.h"
+#include "status.h"
+#include "score.h"
+#include "keys.h"
+#endif
+
+class Kpacman : public KTMainWindow
+{
+    Q_OBJECT
+public:
+    Kpacman(QWidget *parent = 0, const char *name = 0);
+    virtual ~Kpacman();
+
+public slots:
+    void forcedHallOfFame(bool);
+
+private slots:
+    void newKpacman();
+    void pauseKpacman();
+    void toggleHallOfFame();
+    void toggleNew();
+    void togglePaused();
+    void quitKpacman();
+
+    void schemeChecked(int);
+    void toggleFocusOutPause();
+    void toggleFocusInContinue();
+    void toggleHideMouseCursor();
+    void confKeys();
+
+protected:
+
+private:
+    KpacmanWidget *view;
+
+    void menu();
+
+    int lookupSchemes();
+
+    KMenuBar *_menuBar;
+    QPopupMenu *gamePopup;
+    QPopupMenu *optionsPopup;
+    QPopupMenu *modesPopup;
+    QList<QPopupMenu> *schemesPopup;
+
+    int newID;
+    int pauseID;
+    int hofID;
+    QArray<int> modeID;
+    QArray<int> schemeID;
+    QArray<int> schemeMode;
+    int focusOutPauseID;
+    int focusInContinueID;
+    int hideMouseCursorID;
+
+    bool focusOutPause;
+    bool focusInContinue;
+    bool hideMouseCursor;
+};
+
+#endif // KPACMAN_H
diff --git a/noncore/games/kpacman/kpacman.moc.cpp b/noncore/games/kpacman/kpacman.moc.cpp
new file mode 100644
index 0000000..804e8c8
--- a/dev/null
+++ b/noncore/games/kpacman/kpacman.moc.cpp
@@ -0,0 +1,73 @@
+/****************************************************************************
+** Kpacman meta object code from reading C++ file 'kpacman.h'
+**
+** Created: Sat Jan 19 13:52:36 2002
+**      by: The Qt MOC ($Id$)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#define Q_MOC_OUTPUT_REVISION 9
+#elif Q_MOC_OUTPUT_REVISION != 9
+#error "Moc format conflict - please regenerate all moc files"
+#endif
+
+#include "kpacman.h"
+#include <qmetaobject.h>
+#include <qapplication.h>
+
+
+
+const char *Kpacman::className() const
+{
+    return "Kpacman";
+}
+
+QMetaObject *Kpacman::metaObj = 0;
+
+void Kpacman::initMetaObject()
+{
+    if ( metaObj )
+        return;
+    if ( qstrcmp(QWidget::className(), "QWidget") != 0 )
+        badSuperclassWarning("Kpacman","QWidget");
+    (void) staticMetaObject();
+}
+
+#ifndef QT_NO_TRANSLATION
+
+QString Kpacman::tr(const char* s)
+{
+    return qApp->translate( "Kpacman", s, 0 );
+}
+
+QString Kpacman::tr(const char* s, const char * c)
+{
+    return qApp->translate( "Kpacman", s, c );
+}
+
+#endif // QT_NO_TRANSLATION
+
+QMetaObject* Kpacman::staticMetaObject()
+{
+    if ( metaObj )
+        return metaObj;
+    (void) QWidget::staticMetaObject();
+#ifndef QT_NO_PROPERTIES
+#endif // QT_NO_PROPERTIES
+    QMetaData::Access *slot_tbl_access = 0;
+    metaObj = QMetaObject::new_metaobject(
+        "Kpacman", "QWidget",
+        0, 0,
+        0, 0,
+#ifndef QT_NO_PROPERTIES
+        0, 0,
+        0, 0,
+#endif // QT_NO_PROPERTIES
+        0, 0 );
+    metaObj->set_slot_access( slot_tbl_access );
+#ifndef QT_NO_PROPERTIES
+#endif // QT_NO_PROPERTIES
+    return metaObj;
+}
diff --git a/noncore/games/kpacman/kpacman.pro b/noncore/games/kpacman/kpacman.pro
new file mode 100644
index 0000000..6577e5b
--- a/dev/null
+++ b/noncore/games/kpacman/kpacman.pro
@@ -0,0 +1,42 @@
+TEMPLATE	= app
+#CONFIG		= qt warn_on debug
+CONFIG		= qt warn_on release
+#TMAKE_CXXFLAGS	+= 
+HEADERS		= kpacmanwidget.h \
+		    referee.h \
+		    status.h \
+		    painter.h \
+		    score.h \
+		    pacman.h \
+		    monster.h \
+		    keys.h \
+		    fruit.h \
+		    energizer.h \
+		    board.h \
+		    bitfont.h \
+		    kpacman.h \
+		    bitmaps.h \
+		    colors.h \
+		    config.h \
+		    portable.h
+SOURCES		= kpacmanwidget.cpp \
+		    referee.cpp \
+		    status.cpp \
+		    painter.cpp \
+		    score.cpp \
+		    pacman.cpp \
+		    monster.cpp \
+		    keys.cpp \
+		    fruit.cpp \
+		    energizer.cpp \
+		    board.cpp \
+		    bitfont.cpp \
+		    kpacman.cpp \
+		    config.cpp \
+		    main.cpp 
+
+#INCLUDEPATH	+= 
+#DEPENDPATH	+=
+LIBS            += -lqpe -ljpeg
+DESTDIR         = $(OPIEDIR)/bin
+TARGET		= kpacman
diff --git a/noncore/games/kpacman/kpacmanwidget.cpp b/noncore/games/kpacman/kpacmanwidget.cpp
new file mode 100644
index 0000000..330c88e
--- a/dev/null
+++ b/noncore/games/kpacman/kpacmanwidget.cpp
@@ -0,0 +1,162 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kconfig.h>
+#include <kstddirs.h>
+#include <kpacmanwidget.h>
+#include <kpacmanwidget.moc>
+#elif defined( QPE_PORT )
+#include <qpe/qpeapplication.h>
+#include "config.h"
+#include "kpacmanwidget.h"
+#endif
+
+#include <qmessagebox.h>
+
+#include "bitfont.h"
+#include "score.h"
+#include "referee.h"
+#include "status.h"
+
+KpacmanWidget::KpacmanWidget( QWidget *parent, const char *name)
+        : QWidget( parent, name )
+{
+    bitfont = NULL;
+    fontName = "";
+
+    scheme = mode = -1;
+    confScheme();
+
+    score = new Score(this, name, scheme, mode, bitfont);
+    referee = new Referee( this, name, scheme, mode, bitfont);
+    status = new Status(this, name, scheme, mode);
+
+#ifndef QWS
+    setFixedSize(referee->width(), bitfont->height()*3 + referee->height() + status->height());
+#else
+    setBackgroundColor( black );
+#endif
+}
+
+KpacmanWidget::~KpacmanWidget()
+{
+}
+
+void KpacmanWidget::confMisc(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    //KStandardDirs *dirs = KGlobal::dirs();
+    QString findPath;
+
+    if (defGroup || cfg->hasKey("Font")) {
+        fontName = cfg->readEntry("Font");
+
+        if (fontName.left(1) != "/" && fontName.left(1) != "~")
+            fontName.insert(0, "fonts/");
+        if (fontName.right(1) == "/")
+            fontName.append("font.xbm");
+
+        //findPath = dirs->findResource("appdata", fontName);
+        findPath = FIND_APP_DATA( fontName );
+        if (!findPath.isEmpty())
+            fontName = findPath;
+
+        bitfontFirstChar = cfg->readNumEntry("FontFirstChar", 0x0e);
+        bitfontLastChar = cfg->readNumEntry("FontLastChar", 0x5f);
+    }
+    APP_CONFIG_END( cfg );
+}
+
+void KpacmanWidget::confScheme()
+{
+    APP_CONFIG_BEGIN( cfg );
+    QString lastFontName = fontName;
+    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 );
+        }
+    }
+
+    confMisc();
+
+    if (mode != -1) {
+        newgroup.sprintf("Mode %d", mode);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+    }
+
+    if (scheme != -1) {
+        newgroup.sprintf("Scheme %d", scheme);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+    }
+
+    if (lastFontName != fontName) {
+
+        if (bitfont != 0)
+            delete bitfont;
+
+        bitfont = new Bitfont(fontName, bitfontFirstChar, bitfontLastChar);
+        if (bitfont->width() == 0 || bitfont->height() == 0) {
+            QString msg = i18n("The bitfont could not be contructed.\n\n"
+                               "The file '@FONTNAME@' does not exist,\n"
+                               "or is of an unknown format.");
+            msg.replace(QRegExp("@FONTNAME@"), fontName);
+            // QMessageBox::critical(this, i18n("Initialization Error"), msg);
+            printf("%s\n", msg.data());
+        }
+    }
+
+    RESTORE_CONFIG_GROUP( cfg, oldgroup );
+    APP_CONFIG_END( cfg );
+}
+
+void KpacmanWidget::setScheme(int Scheme, int Mode)
+{
+    mode = Mode;
+    scheme = Scheme;
+
+    confScheme();
+
+    score->setScheme(Scheme, Mode, bitfont);
+    referee->setScheme(Scheme, Mode, bitfont);
+    status->setScheme(Scheme, Mode);
+
+#ifndef QWS
+    setFixedSize(referee->width(),
+                 bitfont->height()*3 + referee->height() + status->height());
+#endif
+
+    score->repaint(FALSE);
+    referee->repaint(FALSE);
+    status->repaint(FALSE);
+}
+
+void KpacmanWidget::resizeEvent( QResizeEvent * )
+{
+    referee->setGeometry(0, bitfont->height()*3, referee->width(), referee->height());
+    referee->setBackgroundColor(BLACK);
+
+    status->setGeometry(0, bitfont->height()*3+referee->height(), referee->width(),
+                        status->height());
+    status->setBackgroundColor(BLACK);
+
+    score->setGeometry(0, 0, referee->width(), bitfont->height()*3+referee->height()+status->height());
+    score->setBackgroundColor(BLACK);
+}
diff --git a/noncore/games/kpacman/kpacmanwidget.h b/noncore/games/kpacman/kpacmanwidget.h
new file mode 100644
index 0000000..13b4a15
--- a/dev/null
+++ b/noncore/games/kpacman/kpacmanwidget.h
@@ -0,0 +1,50 @@
+#ifndef KPACMANWIDGET_H
+#define KPACMANWIDGET_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#endif
+
+#include <qwidget.h>
+#include <qregexp.h>
+
+#include "score.h"
+#include "referee.h"
+#include "status.h"
+#include "painter.h"
+
+class KpacmanWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    KpacmanWidget ( QWidget *parent = 0, const char *name = 0);
+    virtual ~KpacmanWidget();
+
+    void setScheme(int scheme=-1, int mode=-1);
+    Score *score;
+    Referee *referee;
+    Status *status;
+
+protected:
+    void confScheme();
+    void confMisc(bool defGroup=TRUE);
+    void resizeEvent( QResizeEvent * );
+
+private:
+    Bitfont *bitfont;
+    uchar bitfontFirstChar;
+    uchar bitfontLastChar;
+
+    QString fontName;
+
+    int scheme;
+    int mode;
+};
+
+#endif // KPACMANWIDGET_H
diff --git a/noncore/games/kpacman/main.cpp b/noncore/games/kpacman/main.cpp
new file mode 100644
index 0000000..76afb57
--- a/dev/null
+++ b/noncore/games/kpacman/main.cpp
@@ -0,0 +1,66 @@
+/***************************************************************************
+                          main.cpp  -  description
+                             -------------------
+    begin                : Sam Jan 19 13:37:57 CET 2002
+    copyright            : (C) 2002 by Jörg Thönnissen
+    email                : joe@dsite.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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 "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kcmdlineargs.h>
+#include <kaboutdata.h>
+#include <klocale.h>
+#elif defined( QPE_PORT )
+#include <qpe/qpeapplication.h>
+#endif
+
+#include "kpacman.h"
+
+#ifdef KDE2_PORT
+static const char *description =
+        I18N_NOOP("Kpacman");
+// INSERT A DESCRIPTION FOR YOUR APPLICATION HERE
+
+
+static KCmdLineOptions options[] =
+{
+  { 0, 0, 0 }
+  // INSERT YOUR COMMANDLINE OPTIONS HERE
+};
+#endif
+
+int main(int argc, char *argv[])
+{
+#if defined( KDE2_PORT )
+  KAboutData aboutData( "kpacman", I18N_NOOP("Kpacman"),
+    VERSION, description, KAboutData::License_GPL,
+    "(c) 2002, Jörg Thönnissen", 0, 0, "joe@dsite.de");
+  aboutData.addAuthor("Jörg Thönnissen",0, "joe@dsite.de");
+  KCmdLineArgs::init( argc, argv, &aboutData );
+  KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
+  KApplication a;
+#elif defined( QPE_PORT )
+  QPEApplication a( argc, argv );
+#endif
+  Kpacman *kpacman = new Kpacman( NULL, "Kpacman" );
+  a.setMainWidget(kpacman);
+#if defined( KDE2_PORT )
+  a.setTopWidget(kpacman);
+  kpacman->show();
+#elif defined( QPE_PORT )
+  kpacman->showMaximized();
+#endif
+
+  return a.exec();
+}
diff --git a/noncore/games/kpacman/monster.cpp b/noncore/games/kpacman/monster.cpp
new file mode 100644
index 0000000..2f402b4
--- a/dev/null
+++ b/noncore/games/kpacman/monster.cpp
@@ -0,0 +1,262 @@
+#include "monster.h"
+#include "board.h"
+
+Monster::Monster(Board *b, int mid)
+{
+    board = b;
+    ID = mid;
+
+    setREM(0);
+    setHarmless(0, 0, 0);
+    setArrested(0, 0);
+    setFreedom(board->position(prisonexit));
+    if (mid == 0)
+        setPrison(board->position(prisonentry));
+    else
+        setPrison(board->position(monsterhome, mid));
+   
+    actualPosition = lastPosition = OUT;
+    feetPosition = 0;
+    IQ = 0;
+    maxBodyPixmaps = 0;
+    maxEyesPixmaps = 0;
+}
+
+void Monster::setMaxPixmaps(int maxBody, int maxEyes)
+{
+    if (feetPosition >= (maxBody/10))
+        feetPosition = 0;
+    maxBodyPixmaps = maxBody;
+    maxEyesPixmaps = maxEyes;
+}
+
+void Monster::setArrested(int ticks, int duration)
+{
+    actualState = dangerous;
+    pauseDuration = ticks;
+    pause = 0;
+    arrestDuration = arrestLeft = duration;
+    arrestPause = ticks;
+    harmlessLeft = 0;
+}
+
+void Monster::setDangerous(int ticks, int iq)
+{
+    actualState = dangerous;
+    pauseDuration = ticks;
+    pause = 0;
+    dangerousPause = ticks;
+    harmlessLeft = 0;
+    IQ = iq;
+}
+
+void Monster::setHarmless(int ticks, int hDuration, int wDuration)
+{
+    actualState = harmless;
+    pauseDuration = ticks;
+    pause = 0;
+    harmlessDuration = harmlessLeft = hDuration;
+    warningDuration = wDuration;
+}
+
+void Monster::setREM(int ticks)
+{
+    actualState = rem;
+    pauseDuration = ticks;
+    pause = 0;
+}
+
+void Monster::setPosition(int pos)
+{
+    board->reset(lastPosition, monster, ID);    // reset old position on the board
+    actualPosition = lastPosition = pos;        // set position of monster
+    board->set(actualPosition, monster, ID);
+    feetPosition = 0;
+}
+
+void Monster::setPrison(int pos)
+{
+    prisonPosition = pos;
+}
+
+void Monster::setFreedom(int pos)
+{
+    freedomPosition = pos;
+}
+
+void Monster::setDirection(int dir)
+{
+    if (dir == X)
+        lastDirection = actualDirection;
+    actualDirection = dir;
+}
+
+monsterState Monster::state()
+{
+    return actualState;
+}
+
+int Monster::position()
+{
+    return actualPosition;
+}
+
+int Monster::direction()
+{
+    return actualDirection;
+}
+
+int Monster::id()
+{
+    return ID;
+}
+
+bool Monster::move()
+{
+    if (arrestLeft > 1)
+        arrestLeft--;
+
+    if (harmlessLeft > 0) {
+        harmlessLeft--;
+        if (harmlessLeft == 0 && actualState == harmless) {
+            actualState = dangerous;
+            pauseDuration = dangerousPause; 
+        }
+    }
+
+    if (pause-- > 0)
+        return FALSE;
+    else
+        pause = pauseDuration;
+
+    if (actualPosition == OUT)
+        return FALSE;
+
+    if (actualDirection == X) {
+        if (++feetPosition >= (maxBodyPixmaps/10))
+            feetPosition = 0;
+        return TRUE;
+    }
+
+    lastPosition = actualPosition;
+    int d = actualDirection;
+
+    if (arrestLeft > 1) {               // during the arrest, only up and down
+          if (!board->isWay(actualPosition, d, empty) &&
+              !board->isWay(actualPosition, d, tunnel))
+            d = board->turn(actualDirection);
+    }
+
+    if (arrestLeft == 1) {              // going out of the prison
+        if (((d == W || d == E) &&
+             board->x(actualPosition) == board->x(freedomPosition)) ||
+            ((d == S || d == N) &&
+             board->y(actualPosition) == board->y(freedomPosition)) ||
+             board->isWay(actualPosition, d, brick) ||
+             board->isWay(actualPosition, d, prison)) {
+            d = board->closeup(actualPosition, d, freedomPosition);
+        }
+        while (board->isWay(actualPosition, d, brick) ||
+               board->isWay(actualPosition, d, prison)) {
+            if (d == actualDirection)
+                d = rand() % 4;
+            else
+                d = actualDirection;
+        }
+        if (actualState == dangerous)
+            pauseDuration = dangerousPause;
+        
+    } 
+
+    if (arrestLeft == 0)                        
+        if (actualState == rem) {       // on the way to prison
+
+            d = board->closeup(actualPosition, d, prisonPosition);
+
+            while (board->isWay(actualPosition, d, brick) ||
+                   board->isWay(actualPosition, d, prison)) {
+                if (d != actualDirection)       // if new direction is not possible,
+                    d = actualDirection;        // try current direction first.
+                else
+                    d = rand() % 4;
+            }
+
+        } else {                                // dangerous or harmless movement
+            if (rand() % (int) ((190-IQ)/10) == 0) {
+                d = board->closeup(actualPosition, d, board->position(pacman));
+                if (actualState == harmless)
+                    d = board->turn(d);
+            } else
+                do                              // try new direction, but not the opposite
+                    d = rand() % 4;             // direction, to prevent hectic movement.
+                while (d == board->turn(actualDirection));
+
+            while ((!board->isWay(actualPosition, d, empty) &&
+                    !board->isWay(actualPosition, d, tunnel)) ||
+                   d == board->turn(actualDirection)) {
+                if (d != actualDirection)       // if new direction is not possible,
+                    d = actualDirection;        // try current direction first.
+                else
+                    d = rand() % 4;
+            }
+        }
+
+    actualDirection = d;
+    actualPosition = board->move(actualPosition, actualDirection);
+    
+    if (arrestLeft == 1 && actualPosition == freedomPosition) 
+        arrestLeft = 0;
+
+    if (actualState == rem && actualPosition == prisonPosition) {
+        actualState = dangerous;
+        pauseDuration = arrestPause;
+        arrestLeft = arrestDuration+1;
+        actualDirection = S;
+    }
+
+    if (actualPosition != lastPosition) {
+        board->reset(lastPosition, monster, ID);
+        board->set(actualPosition, monster, ID);
+    }
+
+    if (++feetPosition >= (maxBodyPixmaps/10))
+        feetPosition = 0;
+
+    return TRUE;
+}
+
+int Monster::body()
+{
+    if (actualState == rem || actualPosition == OUT)
+        return -1;
+    else
+        if (actualState == harmless)
+            if (harmlessLeft > warningDuration || 
+                harmlessLeft % (int) (warningDuration/4.5) > (int) (warningDuration/9))
+                return ((maxBodyPixmaps/10)*8)+feetPosition;
+            else
+                return ((maxBodyPixmaps/10)*9)+feetPosition;
+        else
+            return ((maxBodyPixmaps/10)*ID)+feetPosition;
+}
+
+int Monster::eyes()
+{
+    if (actualState == harmless || actualPosition == OUT)
+        return -1;
+    else
+        switch (actualDirection) {
+            case N  : return 0;
+            case E  : return 1;
+            case S  : return 2;
+            case W  : return 3;
+            case X  : switch (lastDirection) {
+                          case N  : return 0;
+                          case E  : return 1;
+                          case S  : return 2;
+                          default : return 3;
+                      }
+            default : return -1;
+        }
+}
+
diff --git a/noncore/games/kpacman/monster.h b/noncore/games/kpacman/monster.h
new file mode 100644
index 0000000..b5d7f36
--- a/dev/null
+++ b/noncore/games/kpacman/monster.h
@@ -0,0 +1,62 @@
+#ifndef MONSTER_H
+#define MONSTER_H
+
+#include <stdlib.h>
+#include <qpixmap.h>
+#include <qwidget.h>
+
+#include "board.h"
+
+enum monsterState { dangerous, harmless, rem, arrested };
+
+class Monster {
+public:
+    Monster(Board *b, int mid = 0);
+    void setMaxPixmaps(int maxBody, int maxEyes);
+    void setArrested(int ticks, int duration);
+    void setDangerous(int ticks, int IQ);
+    void setHarmless(int ticks, int hDuration, int wDuration);
+    void setREM(int ticks);
+    void setPosition(int pos);
+    void setPrison(int pos);
+    void setFreedom(int pos);
+    void setDirection(int dir);
+    monsterState state();
+    int position();
+    int direction();
+    int id();
+    bool move();
+    int body();
+    int eyes();
+private:
+    Board   *board;
+    int  ID;                            // ID of monster (0 = 1st, 1 = 2nd ... 7 = last)
+    int  IQ;                            // Intelligence of movement (0 = dumb..180 = smart)
+
+    monsterState actualState;           // The state of the monster
+
+    int  pauseDuration;                 // Number of ticks before movement
+    int  pause;                         // actual ticks before moevment (0 = move)
+    int  dangerousPause;                // pause in dangerous-state
+
+    int  harmlessDuration;              // Length of harmless-time in ticks
+    int  harmlessLeft;                  // rest of the time in harmless-state
+    int  warningDuration;               // warningtime before monster get dangerous again
+
+    int  arrestDuration;                // Length of arrest in ticks
+    int  arrestLeft;                    // time left of arrest
+    int  arrestPause;                   // pause in arrest-state
+
+    int  actualDirection;               // actual direction of monster
+    int  lastDirection;                 // last direction, before no movement (X)
+    int  actualPosition;                // actual position on board
+    int  lastPosition;                  // the last position of the monster
+    int  feetPosition;                  // left, right, left, right, ...
+    int  maxBodyPixmaps;                
+    int  maxEyesPixmaps;
+    int  prisonPosition;                // where to go, if arrested
+    int  freedomPosition;               // where to go, if released from prison
+};
+
+#endif // MONSTER_H
+
diff --git a/noncore/games/kpacman/opie-kpacman.control b/noncore/games/kpacman/opie-kpacman.control
new file mode 100644
index 0000000..814604e
--- a/dev/null
+++ b/noncore/games/kpacman/opie-kpacman.control
@@ -0,0 +1,11 @@
+Files: bin/kpacman apps/Games/kpacman.desktop pics/kpacman.png share/kpacman
+Package: opie-kpacman
+Version: 0.3.1
+Depends: opie-base ($QPE_VERSION)
+Priority: optional
+Section: opie/games
+Maintainer: Catalin Climov <catalin@climov.com>
+Architecture: arm
+License: GPL
+Description: Kpacman
+ A Pacman clone for Qtopia.
diff --git a/noncore/games/kpacman/opie-kpacman.postinst b/noncore/games/kpacman/opie-kpacman.postinst
new file mode 100755
index 0000000..ead1ef8
--- a/dev/null
+++ b/noncore/games/kpacman/opie-kpacman.postinst
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+if [ ! -f $HOME/Settings/kpacman.conf ]
+then
+    cp $QPEDIR/share/kpacman/kpacman.conf $HOME/Settings/
+fi
diff --git a/noncore/games/kpacman/pacman.cpp b/noncore/games/kpacman/pacman.cpp
new file mode 100644
index 0000000..40f60a8
--- a/dev/null
+++ b/noncore/games/kpacman/pacman.cpp
@@ -0,0 +1,147 @@
+#include "pacman.h"
+#include "board.h"
+
+Pacman::Pacman(Board *b)
+{
+    board = b;
+    setDemo(FALSE);
+    setAlive(0);
+    actualPosition = lastPosition = OUT;
+    mouthPosition = 0;
+    lastPix = 0;
+    maxPixmaps = 0;
+}
+
+void Pacman::setMaxPixmaps(int max)
+{
+    if (actualDirection == X && lastPix >= 0) {
+        actualDirection = lastPix / (maxPixmaps/4);
+        if (max < maxPixmaps)
+            mouthPosition = 0;
+        else
+            mouthPosition = lastPix % (maxPixmaps/4);
+        maxPixmaps = max;       
+
+        lastPix = pix();
+
+        actualDirection = X;
+    } else
+        maxPixmaps = max;
+}
+
+void Pacman::setAlive(int ticks)
+{
+    actualState = alive;
+    pauseDuration = ticks;
+    pause = 0;
+}
+
+void Pacman::setPosition(int pos)
+{
+    board->reset(lastPosition, pacman);
+    actualPosition = lastPosition = pos;
+    board->set(actualPosition, pacman);
+    mouthPosition = 0;
+}
+
+void Pacman::setDirection(int dir, bool forced)
+{
+    if (forced ||
+        board->isWay(actualPosition, dir, empty) ||
+        board->isWay(actualPosition, dir, tunnel)) {
+        if (dir == X)
+            lastPix = pix();
+        actualDirection = dir;
+        nextDirection = X;
+    } else
+        nextDirection = dir;
+}
+
+void Pacman::setDemo(bool yes)
+{
+    demo = yes;
+}
+
+pacmanState Pacman::state()
+{
+    return actualState;
+}
+
+int Pacman::position()
+{
+    return actualPosition;
+}
+
+int Pacman::direction()
+{
+    return actualDirection;
+}
+
+bool Pacman::move()
+{
+    if (pause-- > 0) 
+        return FALSE;
+    else
+        pause = pauseDuration;
+
+    if (actualDirection == X || actualPosition == OUT)
+        return FALSE;
+
+    lastPosition = actualPosition;
+
+    if (demo) {
+        int d = actualDirection;
+
+        do                              // try new direction, but not the opposite
+            d = rand() % 4;             // direction, to prevent hectic movement.
+        while (d == board->turn(actualDirection));
+
+        while (!board->isWay(actualPosition, d, empty) &&
+               !board->isWay(actualPosition, d, tunnel)) {
+            if (d != actualDirection)   // if new actualDirection is not possible,
+                d = actualDirection;    // try current actualDirection first.
+            else
+                d = rand() % 4;
+        }
+
+        actualDirection = d;
+        actualPosition = board->move(actualPosition, actualDirection);
+
+    } else {
+
+        if (nextDirection != X)
+            if (board->isWay(actualPosition, nextDirection, empty) ||
+                board->isWay(actualPosition, nextDirection, tunnel)) {
+                actualDirection = nextDirection;
+                nextDirection = X;      
+            }
+
+        if (board->isWay(actualPosition, actualDirection, empty) ||
+            board->isWay(actualPosition, actualDirection, tunnel))
+            actualPosition = board->move(actualPosition, actualDirection);
+    }
+
+    if (actualPosition != lastPosition) {
+        board->reset(lastPosition, pacman);
+        board->set(actualPosition, pacman);
+
+        if (++mouthPosition >= (maxPixmaps/4))
+            mouthPosition = 0;
+    }
+    return TRUE;
+}
+
+int Pacman::pix()
+{
+    if (actualPosition != OUT && maxPixmaps > 0)
+        switch (actualDirection) {
+            case N : return ((maxPixmaps/4)*0)+mouthPosition;
+            case E : return ((maxPixmaps/4)*1)+mouthPosition;
+            case S : return ((maxPixmaps/4)*2)+mouthPosition;
+            case W : return ((maxPixmaps/4)*3)+mouthPosition;
+            case X : return lastPix;
+        }
+
+    return -1;
+}
+
diff --git a/noncore/games/kpacman/pacman.h b/noncore/games/kpacman/pacman.h
new file mode 100644
index 0000000..e81fdd2
--- a/dev/null
+++ b/noncore/games/kpacman/pacman.h
@@ -0,0 +1,47 @@
+#ifndef PACMAN_H
+#define PACMAN_H
+
+#include <stdlib.h>
+#include <qpixmap.h>
+#include <qwidget.h>
+
+#include "board.h"
+
+enum pacmanState { alive };
+
+class Pacman {
+public:
+    Pacman(Board *b);
+    void init(bool Demo = FALSE);
+    void setMaxPixmaps(int max);
+    void setAlive(int ticks);
+    void setPosition(int pos);
+    void setDirection(int dir, bool forced = FALSE);
+    void setDemo(bool yes);
+    pacmanState state();
+    int position();
+    int direction();
+    bool move();
+    int pix();
+
+private:
+    Board   *board;
+
+    pacmanState actualState;            // the state of pacman
+    bool demo;                          // real life or just demo
+
+    int  pauseDuration;                 // number of ticks before next movement
+    int  pause;                         // actual ticks before movement (0=move)
+
+    int  actualDirection;               // actual direction of pacman
+    int  nextDirection;                 // where he wants to go
+    int  lastPix;                       // last Pixmap-index before no movement
+    int  maxPixmaps;                    // Number of Pixmaps (1..)
+    int  actualPosition;                // actual position on board
+    int  lastPosition;                  // the last position of pacman
+    int  mouthPosition;                 // eating
+
+};
+
+#endif // PACMAN_H
+
diff --git a/noncore/games/kpacman/painter.cpp b/noncore/games/kpacman/painter.cpp
new file mode 100644
index 0000000..16fed55
--- a/dev/null
+++ b/noncore/games/kpacman/painter.cpp
@@ -0,0 +1,972 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kconfig.h>
+#include <kstddirs.h>
+#elif defined( QPE_PORT )
+#include <qpe/qpeapplication.h>
+#include "config.h"
+#endif
+
+#include <qcolor.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qbitmap.h>
+#include <qrect.h>
+#include <qstring.h>
+
+#include <qmessagebox.h>
+#include <qfileinfo.h>
+
+#include "painter.h"
+#include "board.h"
+
+Painter::Painter( Board *b, QWidget *parent, int Scheme, int Mode, Bitfont *font)
+{
+    w = parent;
+    board = b;
+
+    pointPix = NULL;
+    wallPix = NULL;
+    prisonPix = NULL;
+    energizerPix = NULL;
+    fruitPix = NULL;
+    pacmanPix = NULL;
+    dyingPix = NULL;
+    eyesPix = NULL;
+    monsterPix = NULL;
+    fruitScorePix = NULL;
+    monsterScorePix = NULL;
+
+    lastPointPixmapName = "";
+    lastWallPixmapName = "";
+    lastPrisonPixmapName = "";
+    lastEnergizerPixmapName = "";
+    lastFruitPixmapName = "";
+    lastPacmanPixmapName = "";
+    lastDyingPixmapName = "";
+    lastEyesPixmapName = "";
+    lastMonsterPixmapName = "";
+    lastFruitScorePixmapName = "";
+    lastMonsterScorePixmapName = "";
+
+    bitfont = font;
+
+    scheme = Scheme;
+    mode = Mode;
+    level = 0;
+
+    confScheme();
+}
+
+QList<QPixmap> *Painter::loadPixmap(QWidget*, QString pixmapName,
+                                    QList<QPixmap> *pixmaps)
+{
+    if (pixmaps == NULL) {
+        pixmaps = new QList<QPixmap>;
+        pixmaps->setAutoDelete(TRUE);
+    }
+
+    if (!pixmaps->isEmpty())
+        pixmaps->clear();
+
+    QPixmap PIXMAP(pixmapName);
+    if (PIXMAP.isNull() || PIXMAP.mask() == NULL) {
+        QString msg = i18n("The pixmap could not be contructed.\n\n"
+                           "The file '@PIXMAPNAME@' does not exist,\n"
+                           "or is of an unknown format.");
+        msg.replace(QRegExp("@PIXMAPNAME@"), pixmapName);
+        // QMessageBox::critical(parent, i18n("Initialization Error"), msg);
+        printf("%s\n", msg.data());
+        return 0;
+    }
+
+    int height = PIXMAP.height();
+    int width = (height == 0) ? 0 : PIXMAP.width()/(PIXMAP.width()/height);
+
+    QBitmap BITMAP;
+    QBitmap MASK;
+
+    BITMAP = *PIXMAP.mask();
+    MASK.resize(width, height);
+
+    for (int x = 0; x < PIXMAP.width()/width; x++) {
+        QPixmap *pixmap = new QPixmap(width, height);
+        pixmaps->append(pixmap);
+        bitBlt(pixmap, 0, 0, &PIXMAP, x*width, 0, width, height, QPixmap::CopyROP, TRUE);
+        bitBlt(&MASK, 0, 0, &BITMAP, x*width, 0, width, height, QPixmap::CopyROP, TRUE);
+        pixmap->setMask(MASK);
+    }
+
+    return pixmaps;
+}
+
+QList<QPixmap> *Painter::textPixmap(QStrList &str, QList<QPixmap> *pixmaps,
+                                    QColor fg, QColor bg)
+{
+    if (pixmaps == NULL) {
+        pixmaps = new QList<QPixmap>;
+        pixmaps->setAutoDelete(TRUE);
+    }
+
+    if (!pixmaps->isEmpty())
+        pixmaps->clear();
+
+    for (uint s = 0; s < str.count(); s++) {
+        QPixmap *pixmap = new QPixmap(bitfont->text(str.at(s), fg, bg));
+        pixmaps->append(pixmap);
+    }
+
+    return pixmaps;
+}
+
+QList<QPixmap> *Painter::textPixmap(QString str, QList<QPixmap> *pixmaps,
+                                    QColor fg, QColor bg)
+{
+    if (pixmaps == NULL) {
+        pixmaps = new QList<QPixmap>;
+        pixmaps->setAutoDelete(TRUE);
+    }
+
+    if (!pixmaps->isEmpty())
+        pixmaps->clear();
+
+    QPixmap *pixmap = new QPixmap(bitfont->text(str, fg, bg));
+    pixmaps->append(pixmap);
+
+    return pixmaps;
+}
+
+/* Return the point of the upperleft pixel of the block representing that position
+ * on the board.
+ */
+QPoint Painter::point(int pos)
+{
+    return QPoint((board->x(pos)-1)*BlockWidth, (board->y(pos)-1)*BlockHeight);
+}
+
+
+QRect Painter::rect(int pos, PixMap pix, uint i)
+{
+    if (pos == OUT)
+        return QRect();
+
+    QPixmap *PIXMAP = NULL;
+    switch (pix) {
+        case PacmanPix       : PIXMAP = pacmanPix->
+                                        at(checkRange(i, pacmanPix->count()-1));
+                               break;
+        case DyingPix        : PIXMAP = dyingPix->
+                                        at(checkRange(i, dyingPix->count()-1));
+                               break;
+        case MonsterPix      : PIXMAP = monsterPix->
+                                        at(checkRange(i, monsterPix->count()-1));
+                               break;
+        case EyesPix         : PIXMAP = eyesPix->
+                                        at(checkRange(i, eyesPix->count()-1));
+                               break;
+        case FruitPix        : PIXMAP = fruitPix->
+                                        at(checkRange(i, fruitPix->count()-1));
+                               break;
+        case PointPix        : PIXMAP = pointPix->
+                                        at(checkRange(i, pointPix->count()-1));
+                               break;
+        case EnergizerPix    : PIXMAP = energizerPix->
+                                        at(checkRange(i, energizerPix->count()-1));
+                               break;
+        case FruitScorePix   : PIXMAP = fruitScorePix->
+                                        at(checkRange(i, fruitScorePix->count()-1));
+                               break;
+        case MonsterScorePix : PIXMAP = monsterScorePix->
+                                        at(checkRange(i,monsterScorePix->count()-1));
+                               break;
+        default              : PIXMAP = wallPix->
+                                        at(checkRange(i, wallPix->count()-1));
+    }
+    if (PIXMAP == NULL)
+        return QRect();
+
+    QRect rect = PIXMAP->rect();
+    QPoint point = this->point(pos);
+    rect.moveCenter(QPoint(point.x()-1, point.y()-1));
+  
+    return rect;
+}
+
+QRect Painter::rect(int pos, QString str, int align)
+{
+    if (pos == OUT)                     // return an empty rect if the position
+        return QRect();                 // is invalid
+    QPoint point = this->point(pos);
+    QRect rect = bitfont->rect(str);
+
+    rect.moveCenter(QPoint(point.x()-1, point.y()-1));
+
+    int dx = 0;
+    int dy = 0;
+
+    if (align & QLabel::AlignLeft || align & QLabel::AlignRight) {
+        dx = (str.length()-1) * (bitfont->width()/2);
+        if (align & QLabel::AlignRight)
+            dx *= -1;
+    }
+
+    if (align & QLabel::AlignTop || align & QLabel::AlignBottom) {
+        dy = bitfont->height()/2;
+        if (align & QLabel::AlignBottom)
+            dy *= -1;
+    }
+
+    if (dx != 0 || dy != 0)
+        rect.moveBy(dx, dy);
+
+    return rect;
+}
+
+QRect Painter::rect(QRect r1, QRect r2)
+{
+    QRect rect;
+    rect.setLeft(r1.left() < r2.left() ? r1.left() : r2.left());
+    rect.setTop(r1.top() < r2.top() ? r1.top() : r2.top());
+    rect.setRight(r1.right() > r2.right() ? r1.right() : r2.right());
+    rect.setBottom(r1.bottom() > r2.bottom() ? r1.bottom() : r2.bottom());
+
+    return rect;
+}
+
+void Painter::erase(int pos, PixMap pix, uint i)
+{
+    if (pos == OUT)
+        return;
+    QRect rect = this->rect(pos, pix, i);
+    bitBlt(&roomPix, rect.x(), rect.y(), &backPix,
+           rect.x(), rect.y(), rect.width(), rect.height());
+}
+
+int Painter::maxPixmaps(PixMap pix)
+{
+    switch (pix) {
+        case WallPix         : return (int) wallPix->count();
+        case PrisonPix       : return (int) prisonPix->count();
+        case PointPix        : return (int) pointPix->count();
+        case EnergizerPix    : return (int) energizerPix->count();
+        case FruitPix        : return (int) fruitPix->count();
+        case PacmanPix       : return (int) pacmanPix->count();
+        case DyingPix        : return (int) dyingPix->count();
+        case EyesPix         : return (int) eyesPix->count();
+        case MonsterPix      : return (int) monsterPix->count();
+        case FruitScorePix   : return (int) fruitScorePix->count();
+        case MonsterScorePix : return (int) monsterScorePix->count();
+        default              : return 0;
+    }
+}
+        
+void Painter::draw(QPoint point, DrawWidget where, QPixmap pix)
+{
+    switch (where) {
+        case Widget   : bitBlt(w, point.x(), point.y(), &pix);
+                        break;
+        case RoomPix  : bitBlt(&roomPix, point.x(), point.y(), &pix);
+                        break;
+        case BackPix  : bitBlt(&backPix, point.x(), point.y(), &pix);
+                        break;
+    }   
+}
+
+void Painter::draw(QRect rect, DrawWidget where, QPixmap pix)
+{
+    draw(QPoint(rect.x(), rect.y()), where, pix);
+}
+
+void Painter::draw(int pos, DrawWidget where, PixMap pix, uint i)
+{
+    QPixmap *PIXMAP = NULL;
+    switch (pix) {
+        case PacmanPix       : PIXMAP = pacmanPix->
+                                        at(checkRange(i, pacmanPix->count()-1));
+                               break;
+        case DyingPix        : PIXMAP = dyingPix->
+                                        at(checkRange(i, dyingPix->count()-1));
+                               break;
+        case MonsterPix      : PIXMAP = monsterPix->
+                                        at(checkRange(i, monsterPix->count()-1));
+                               break;
+        case EyesPix         : PIXMAP = eyesPix->
+                                        at(checkRange(i, eyesPix->count()-1));
+                               break;
+        case FruitPix        : PIXMAP = fruitPix->
+                                        at(checkRange(i, fruitPix->count()-1));
+                               break;
+        case EnergizerPix    : PIXMAP = energizerPix->
+                                        at(checkRange(i, energizerPix->count()-1));
+                               break;
+        case FruitScorePix   : PIXMAP = fruitScorePix->
+                                        at(checkRange(i, fruitScorePix->count()-1));
+                               break;
+        case MonsterScorePix : PIXMAP = monsterScorePix->
+                                        at(checkRange(i,monsterScorePix->count()-1));
+                               break;
+        default              : ;
+    }
+
+    if (PIXMAP == NULL)
+        return;
+
+    QRect rect = PIXMAP->rect();
+    QPoint point = this->point(pos);
+    rect.moveCenter(QPoint(point.x()-1, point.y()-1));
+
+    switch (where) {
+        case Widget   : bitBlt(w, rect.x(), rect.y(), PIXMAP); 
+                        break;
+        case RoomPix  : bitBlt(&roomPix, rect.x(), rect.y(), PIXMAP);
+                        break;
+        case BackPix  : bitBlt(&backPix, rect.x(), rect.y(), PIXMAP);
+                        break;
+    }   
+}
+
+QPixmap Painter::draw(int pos, DrawWidget where,
+                      QString str, QColor fg, QColor bg, int align)
+{
+    QPixmap TEXT = bitfont->text(str, fg, bg);
+
+    QRect rect = this->rect(pos, str, align);
+    QPixmap SAVE = QPixmap(rect.width(), rect.height());
+
+    switch (where) {
+        case Widget  : bitBlt(&SAVE, 0, 0, w, rect.x(), rect.y());
+                       bitBlt(w, rect.x(), rect.y(), &TEXT);
+                       break;
+        case RoomPix : bitBlt(&SAVE, 0, 0, &roomPix, rect.x(), rect.y());
+                       bitBlt(&roomPix, rect.x(), rect.y(), &TEXT);
+                       break;
+        case BackPix : bitBlt(&SAVE, 0, 0, &backPix, rect.x(), rect.y());
+                       bitBlt(&backPix, rect.x(), rect.y(), &TEXT);
+                       break;
+    }
+
+    return SAVE;
+}
+
+QRect Painter::draw(int col, int row, DrawWidget where,
+                    QString str, QColor fg, QColor bg, int align)
+{
+    QPixmap TEXT = bitfont->text(str, fg, bg);
+
+    QRect rect = this->rect(row*BoardWidth+col, str, align);
+    draw(rect, where, TEXT);
+     
+    return rect;
+}
+
+void Painter::initPixmaps()
+{
+    if (lastPointPixmapName != pointPixmapName.at(level)) {
+        pointPix = loadPixmap(w, pointPixmapName.at(level), pointPix);
+        lastPointPixmapName = pointPixmapName.at(level);
+    }
+    if (lastPrisonPixmapName != prisonPixmapName.at(level)) {
+        prisonPix = loadPixmap(w, prisonPixmapName.at(level), prisonPix);
+        lastPrisonPixmapName = prisonPixmapName.at(level);
+    }
+    if (lastEnergizerPixmapName != energizerPixmapName.at(level)) {
+        energizerPix = loadPixmap(w, energizerPixmapName.at(level), energizerPix);
+        lastEnergizerPixmapName = energizerPixmapName.at(level);
+    }
+    if (lastFruitPixmapName != fruitPixmapName.at(level)) {
+        fruitPix = loadPixmap(w, fruitPixmapName.at(level), fruitPix);
+        lastFruitPixmapName = fruitPixmapName.at(level);
+    }
+    if (lastPacmanPixmapName != pacmanPixmapName.at(level)) {
+        pacmanPix = loadPixmap(w, pacmanPixmapName.at(level), pacmanPix);
+        lastPacmanPixmapName = pacmanPixmapName.at(level);
+    }
+    if (lastDyingPixmapName != dyingPixmapName.at(level)) {
+        dyingPix = loadPixmap(w, dyingPixmapName.at(level), dyingPix);
+        lastDyingPixmapName = dyingPixmapName.at(level);
+    }
+    if (lastEyesPixmapName != eyesPixmapName.at(level)) {
+        eyesPix = loadPixmap(w, eyesPixmapName.at(level), eyesPix);
+        lastEyesPixmapName = eyesPixmapName.at(level);
+    }
+    if (lastMonsterPixmapName != monsterPixmapName.at(level)) {
+        monsterPix = loadPixmap(w, monsterPixmapName.at(level), monsterPix);
+        lastMonsterPixmapName = monsterPixmapName.at(level);
+    }
+
+    if (lastFruitScorePixmapName != fruitScorePixmapName.at(level) ||
+        (const char *) *fruitScorePixmapName.at(level) == '\0') {
+        if ((const char *) *fruitScorePixmapName.at(level) == '\0') {
+            fruitScorePix = textPixmap(fruitScoreString, fruitScorePix, PINK);
+        } else {
+            fruitScorePix = loadPixmap(w, fruitScorePixmapName.at(level),
+                                       fruitScorePix);
+            lastFruitScorePixmapName = fruitScorePixmapName.at(level);
+        }
+    }
+
+    if (lastMonsterScorePixmapName != monsterScorePixmapName.at(level) ||
+        (const char *) *monsterScorePixmapName.at(level) == '\0') {
+        if ((const char *) *monsterScorePixmapName.at(level) == '\0') {
+            monsterScorePix = textPixmap(monsterScoreString, monsterScorePix, CYAN);
+        } else {
+            monsterScorePix = loadPixmap(w, monsterScorePixmapName.at(level),
+                                         monsterScorePix);
+            lastMonsterScorePixmapName = monsterScorePixmapName.at(level);
+        }
+    }
+
+    if (lastWallPixmapName != wallPixmapName.at(level)) {
+        wallPix = loadPixmap(w, wallPixmapName.at(level), wallPix);
+        if (wallPix->isEmpty()) {
+            BlockWidth = 0;
+            BlockHeight = 0;
+        } else {
+            BlockWidth = wallPix->at(0)->width();
+            BlockHeight = wallPix->at(0)->height();
+        }
+        lastWallPixmapName = wallPixmapName.at(level);
+    }
+}
+
+void Painter::initbackPixmaps()
+{
+    backgroundColor = BLACK;
+
+    backPix.resize((BoardWidth-3)*BlockWidth, (BoardHeight-3)*BlockHeight );
+    backPix.fill(backgroundColor);
+}
+
+void Painter::initRoomPixmap()
+{
+    roomPix.resize((BoardWidth-3)*BlockWidth, (BoardHeight-3)*BlockHeight );
+    bitBlt(&roomPix,0,0, &backPix);
+
+    for (unsigned int x = 0; x < board->size(); x++) {
+        if (board->isBrick(x))
+            drawBrick(x);
+        if (board->isPrison(x) || board->isGate(x))
+            drawPrison(x);
+        if (board->isPoint(x))
+            drawPoint(x);
+    }
+}
+
+void Painter::drawBrick(int pos)
+{
+    int border = 0;
+    if (board->isBrick(board->move(pos, N ))) border |= (1 << 0);
+    if (board->isBrick(board->move(pos, NE))) border |= (1 << 1);
+    if (board->isBrick(board->move(pos, E ))) border |= (1 << 2);
+    if (board->isBrick(board->move(pos, SE))) border |= (1 << 3);
+    if (board->isBrick(board->move(pos, S ))) border |= (1 << 4);
+    if (board->isBrick(board->move(pos, SW))) border |= (1 << 5);
+    if (board->isBrick(board->move(pos, W ))) border |= (1 << 6);
+    if (board->isBrick(board->move(pos, NW))) border |= (1 << 7);
+
+    if (board->isOut(board->move(pos, N ))) border |= (1 << 8);
+    if (board->isOut(board->move(pos, NE))) border |= (1 << 9);
+    if (board->isOut(board->move(pos, E ))) border |= (1 << 10);
+    if (board->isOut(board->move(pos, SE))) border |= (1 << 11);
+    if (board->isOut(board->move(pos, S ))) border |= (1 << 12);
+    if (board->isOut(board->move(pos, SW))) border |= (1 << 13);
+    if (board->isOut(board->move(pos, W ))) border |= (1 << 14);
+    if (board->isOut(board->move(pos, NW))) border |= (1 << 15);
+
+    switch (border & 0xFF)  {
+        case  31 : border =  0; break;
+        case 159 : border =  0; break;
+        case  63 : border =  0; break;
+        case 191 : border =  0; break;
+        case 241 : border =  1; break;
+        case 249 : border =  1; break;
+        case 243 : border =  1; break;
+        case 251 : border =  1; break;
+        case 124 : border =  2; break;
+        case 252 : border =  2; break;
+        case 126 : border =  2; break;
+        case 199 : border =  3; break;
+        case 231 : border =  3; break;
+        case 207 : border =  3; break;
+        case  28 : if ((border >> 8) > 0)
+                      border = 24;
+                   else
+                      border =  4;
+                   break;
+        case 112 : if ((border >> 8) > 0)
+                      border = 27;
+                   else
+                      border =  5;
+                   break;
+        case   7 : if ((border >> 8) > 0)
+                      border = 25;
+                   else
+                      border =  6;
+                   break;
+        case 193 : if ((border >> 8) > 0)
+                      border = 26;
+                   else
+                      border =  7;
+                   break;
+        case 247 : if ((border & (1 << 11)) > 0)
+                      border = 23;
+                   else
+                      border =  8;
+                   break;
+        case 119 : if ((border & (1 << 15)) > 0)
+                      border =  8;
+                   if ((border & (1 << 11)) > 0)
+                      border = 11;
+                   break;
+        case 223 : if ((border & (1 << 13)) > 0)
+                      border = 20;
+                   else
+                      border =  9;
+                   break;
+        case 221 : if ((border & (1 << 13)) > 0)
+                      border = 10;
+                   if ((border & (1 << 9)) > 0)
+                      border = 9;
+                   break;
+        case 253 : if ((border & (1 << 9)) > 0)
+                      border = 21;
+                   else
+                      border = 10;
+                   break;
+        case 127 : if ((border & (1 << 15)) > 0)
+                      border = 22;
+                   else
+                      border = 11;
+                   break;
+        case  30 : border = 12; break;
+        case 240 : border = 13; break;
+        case  15 : border = 14; break;
+        case 225 : border = 15; break;
+        case 135 : border = 16; break;
+        case 195 : border = 17; break;
+        case  60 : border = 18; break;
+        case 120 : border = 19; break;
+        case 255 : border = 28; break;
+        default  : border = -1;
+    }
+    if (border != -1 &&  border < (int) wallPix->count()) {
+        QRect rect = this->rect(pos, WallPix);
+        bitBlt(&roomPix, rect.x(), rect.y(), wallPix->at((uint) border));
+    }
+}
+
+void Painter::drawPrison(int pos)
+{
+    int border = 0;
+    if (board->isPrison(board->move(pos, N ))) border |= (1 << 0);
+    if (board->isPrison(board->move(pos, NE))) border |= (1 << 1);
+    if (board->isPrison(board->move(pos, E ))) border |= (1 << 2);
+    if (board->isPrison(board->move(pos, SE))) border |= (1 << 3);
+    if (board->isPrison(board->move(pos, S ))) border |= (1 << 4);
+    if (board->isPrison(board->move(pos, SW))) border |= (1 << 5);
+    if (board->isPrison(board->move(pos, W ))) border |= (1 << 6);
+    if (board->isPrison(board->move(pos, NW))) border |= (1 << 7);
+
+    if (board->isGate(board->move(pos, N ))) border |= (1 << 8);
+    if (board->isGate(board->move(pos, NE))) border |= (1 << 9);
+    if (board->isGate(board->move(pos, E ))) border |= (1 << 10);
+    if (board->isGate(board->move(pos, SE))) border |= (1 << 11);
+    if (board->isGate(board->move(pos, S ))) border |= (1 << 12);
+    if (board->isGate(board->move(pos, SW))) border |= (1 << 13);
+    if (board->isGate(board->move(pos, W ))) border |= (1 << 14);
+    if (board->isGate(board->move(pos, NW))) border |= (1 << 15);
+
+    switch (border & 0xFF)  {
+        case  31 : border =  0; break;
+        case 159 : border =  0; break;
+        case  63 : border =  0; break;
+        case 241 : border =  1; break;
+        case 249 : border =  1; break;
+        case 243 : border =  1; break;
+        case 124 : border =  2; break;
+        case 252 : border =  2; break;
+        case 126 : border =  2; break;
+        case 199 : border =  3; break;
+        case 231 : border =  3; break;
+        case 207 : border =  3; break;
+        case  28 : if ((border >> 8) != 0)
+                      border = 12;
+                   else
+                      border =  4;
+                   break;
+        case 112 : if ((border >> 8) != 0)
+                      border = 13;
+                   else
+                      border =  5;
+                   break;
+        case   7 : if ((border >> 8) != 0)
+                      border = 14;
+                   else
+                      border =  6;
+                   break;
+        case 193 : if ((border >> 8) != 0)
+                      border = 15;
+                   else
+                      border =  7;
+                   break;
+        case 247 : border =  8; break;
+        case 223 : border =  9; break;
+        case 253 : border = 10; break;
+        case 127 : border = 11; break;
+        default  : border = -1;
+    }
+    if (board->isGate(pos)) {
+        if (board->isGate(board->move(pos, N)))
+            border = 17;
+        else
+            border = 16;
+    }
+
+    if (border != -1 &&  border < (int) prisonPix->count()) {
+        QRect rect = this->rect(pos, PrisonPix);
+        bitBlt(&roomPix, rect.x(), rect.y(), prisonPix->at((uint) border));
+    }
+}
+
+void Painter::drawPoint(int pos)
+{
+    if (!pointPix->isEmpty()) {
+        QRect rect = this->rect(pos, PointPix);
+        bitBlt(&roomPix, rect.x(), rect.y(), pointPix->at(0));
+    }
+}
+
+QString Painter::decodeHexOctString(QString s)
+{
+    QString value;
+    QString valids;
+    int pos, xpos = 0, opos = 0;
+    int v, len, leadin;
+    const char *ptr;
+    uchar c;
+
+    while (((xpos = s.find(QRegExp("\\\\x[0-9a-fA-F]+"), xpos)) != -1) ||
+           ((opos = s.find(QRegExp("\\\\[0-7]+"), opos)) != -1)) {
+        if (xpos != -1) {
+            valids = "0123456789abcdef";
+            leadin = 2;
+            pos = xpos;
+        } else {
+            valids = "01234567";
+            leadin = 1;
+            pos = opos;
+        }
+
+        c = '\0';
+        len = 0;
+        value = s.mid(pos+leadin, 3);
+        ptr = (const char *) value;
+
+        while (*ptr != '\0' && (v = valids.find(*ptr++, 0, FALSE)) != -1) {
+            c = (c * valids.length()) + v;
+            len++;
+        }
+
+        value.fill(c, 1);
+        s.replace(pos, len+leadin, value);
+    }
+
+    return s;
+}
+
+void Painter::fillScoreString(QStrList &list, QArray<int> &values)
+{
+    if( !list.isEmpty())
+        list.clear();
+
+    QString s;
+        
+    for (uint i = 0; i < values.size(); i++) {
+
+        if (values[i] < 10 || values[i] > 10000)
+            s = "?";
+        else if (values[i] == 1600)
+            s = "\x1a\x1b";
+        else if (values[i] < 100) {
+            s = "\x0e";
+            s.insert(0, char (values[i] / 10 + 0x10));
+        } else if (values[i] < 1000) {
+            s = "\x0f";
+            s.insert(0, char (values[i] / 100 + 0x10));
+        } else {
+            s = "\x0f\x10";
+            s.insert(0, char (values[i] / 1000 + 0x10));
+        }
+
+        list.append(s.data());
+    }
+}
+
+void Painter::fillArray(QArray<int> &array, QString values, int max)
+{
+    array.resize(max);
+    int last = 0;
+    bool ok;
+    QString 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 Painter::fillStrList(QStrList &list, QString values, int max)
+{
+    if (!list.isEmpty())
+        list.clear();
+
+    QString last = "";
+    QString 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 = decodeHexOctString(value);
+        list.append(last);
+    }
+}
+
+void Painter::fillPixmapName(QStrList &pixmapName)
+{
+    QStrList list = pixmapName;
+
+    if (!pixmapName.isEmpty())
+        pixmapName.clear();
+
+    QString pixmap;
+
+    QFileInfo fileInfo;
+
+    for (uint i = 0; i < list.count(); i++) {
+        pixmap = list.at(i);
+
+        if (pixmap.left(1) != "/" && pixmap.left(1) != "~")
+            pixmap = FIND_APP_DATA( pixmapDirectory+pixmap );
+
+        fileInfo.setFile(pixmap);
+        if (!fileInfo.isReadable() || !fileInfo.isFile())
+            pixmap = "";
+
+        pixmapName.append(pixmap);
+    }
+}
+
+void Painter::confLevels(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("Levels"))
+        maxLevel = cfg->readNumEntry("Levels", 13);
+    APP_CONFIG_END( cfg );
+}
+
+void Painter::confMisc(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("PixmapDirectory")) {
+        pixmapDirectory = cfg->readEntry("PixmapDirectory");
+
+        if (pixmapDirectory.left(1) != "/" && pixmapDirectory.left(1) != "~")
+              pixmapDirectory.insert(0, "pics/");
+        if (pixmapDirectory.right(1) != "/")
+              pixmapDirectory.append("/");
+    }
+
+    if (defGroup || cfg->hasKey("PointPixmapName"))
+        fillStrList(pointPixmapName,
+                    cfg->readEntry("PointPixmapName", "point.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("WallPixmapName"))
+        fillStrList(wallPixmapName,
+                    cfg->readEntry("WallPixmapName", "wall.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("PrisonPixmapName"))
+        fillStrList(prisonPixmapName,
+                    cfg->readEntry("PrisonPixmapName", "prison.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("EnergizerPixmapName"))
+        fillStrList(energizerPixmapName,
+                    cfg->readEntry("EnergizerPixmapName", "switch.xpm"),maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitPixmapName"))
+        fillStrList(fruitPixmapName,
+                    cfg->readEntry("FruitPixmapName", "fruit.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("PacmanPixmapName"))
+        fillStrList(pacmanPixmapName,
+                    cfg->readEntry("PacmanPixmapName", "pacman.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("DyingPixmapName"))
+        fillStrList(dyingPixmapName,
+                    cfg->readEntry("DyingPixmapName", "dying.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("EyesPixmapName"))
+        fillStrList(eyesPixmapName,
+                    cfg->readEntry("EyesPixmapName", "eyes.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("MonsterPixmapName"))
+        fillStrList(monsterPixmapName,
+                    cfg->readEntry("MonsterPixmapName", "monster.xpm"), maxLevel+1);
+
+    if (defGroup || cfg->hasKey("FruitScorePixmapName"))
+        fillStrList(fruitScorePixmapName,
+                    cfg->readEntry("FruitScorePixmapName"), maxLevel+1);
+    if (defGroup || cfg->hasKey("MonsterScorePixmapName"))
+        fillStrList(monsterScorePixmapName,
+                    cfg->readEntry("MonsterScorePixmapName"), maxLevel+1);
+    APP_CONFIG_END( cfg );
+}
+
+void Painter::confScoring(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    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("FruitScoreString"))
+        fillStrList(fruitScoreString,
+                    cfg->readEntry("FruitScoreString"), maxLevel+1);
+    if (defGroup || cfg->hasKey("MonsterScoreString"))
+        fillStrList(monsterScoreString,
+                    cfg->readEntry("MonsterScoreString"), 4);
+    APP_CONFIG_END( cfg );
+}
+
+void Painter::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();
+    confScoring();
+
+    if (mode != -1) {
+        newgroup.sprintf("Mode %d", mode);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+        confScoring(FALSE);
+    }
+
+    if (scheme != -1) {
+        newgroup.sprintf("Scheme %d", scheme);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+        confScoring(FALSE);
+    }
+
+    if ((const char *) *fruitScoreString.at(0) == '\0')
+        fillScoreString(fruitScoreString, fruitScore);
+    if ((const char *) *monsterScoreString.at(0) == '\0')
+        fillScoreString(monsterScoreString, monsterScore);
+
+    fillPixmapName(pointPixmapName);
+    fillPixmapName(wallPixmapName);
+    fillPixmapName(prisonPixmapName);
+    fillPixmapName(energizerPixmapName);
+    fillPixmapName(fruitPixmapName);
+    fillPixmapName(pacmanPixmapName);
+    fillPixmapName(dyingPixmapName);
+    fillPixmapName(eyesPixmapName);
+    fillPixmapName(monsterPixmapName);
+    fillPixmapName(fruitScorePixmapName);
+    fillPixmapName(monsterScorePixmapName);
+
+    initPixmaps();
+    initbackPixmaps();
+    initRoomPixmap();
+
+    RESTORE_CONFIG_GROUP( cfg, oldgroup );
+    APP_CONFIG_END( cfg );
+}
+
+void Painter::setScheme(int Scheme, int Mode, Bitfont *font)
+{
+    bitfont = font;
+
+    mode = Mode;
+    scheme = Scheme;
+
+    confScheme();
+}
+
+void Painter::setLevel(int Level)
+{
+    level = Level;
+
+    initPixmaps();
+    initbackPixmaps();
+    initRoomPixmap();
+}
+
+int Painter::checkRange(int value, int max, int min)
+{
+    if (value < min) {
+        printf("Painter::checkRange (value = %d, max = %d, min = %d)\n",
+               value, max, min);
+        return min;
+    } else if (value > max) {
+        printf("Painter::checkRange (value = %d, max = %d, min = %d)\n",
+               value, max, min);
+        return max;
+    } else
+        return value;
+}
diff --git a/noncore/games/kpacman/painter.h b/noncore/games/kpacman/painter.h
new file mode 100644
index 0000000..3a4eae2
--- a/dev/null
+++ b/noncore/games/kpacman/painter.h
@@ -0,0 +1,148 @@
+#ifndef PAINTER_H
+#define PAINTER_H
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <klocale.h>
+#endif
+
+#include <qpixmap.h>
+#include <qbitmap.h>
+#include <qlabel.h>
+#include <qcolor.h>
+#include <qlist.h>
+#include <qstrlist.h>
+#include <qregexp.h>
+
+#include "board.h"
+#include "bitfont.h"
+#include "colors.h"
+
+enum PixMap { PacmanPix, DyingPix, MonsterPix, EyesPix, FruitPix,
+              PointPix, EnergizerPix, WallPix, PrisonPix,
+              FruitScorePix, MonsterScorePix };
+enum DrawWidget { Widget, RoomPix, BackPix };
+
+class Painter
+{
+public:
+    Painter (Board *, QWidget *parent=0, int scheme=-1, int mode=-1,Bitfont *font=0);
+    QPixmap levelPix() { return roomPix; }
+
+    void setScheme(int scheme=-1, int mode=-1, Bitfont *font=0);
+    void setLevel(int level=0);
+
+    QRect rect(int pos, PixMap pix, uint i = 0);
+    QRect rect(int pos, QString str, int align = QLabel::AlignCenter );
+    QRect rect(QRect r1, QRect r2);
+
+    void draw(QPoint point, DrawWidget where, QPixmap pix);
+    void draw(QRect rect, DrawWidget where, QPixmap pix);
+    void draw(int pos, DrawWidget where, PixMap pix, uint i = 0);
+    QPixmap draw(int pos, DrawWidget where, QString str,
+                 QColor fg, QColor bg = QColor(), int align = QLabel::AlignCenter);
+    QRect draw(int col, int row, DrawWidget where, QString str,
+               QColor fg, QColor bg = QColor(), int align = QLabel::AlignCenter);
+
+    void drawBrick(int pos);
+    void drawPrison(int pos);
+    void drawPoint(int pos);
+
+    void erase(int pos, PixMap pix, uint i = 0);
+
+    int maxPixmaps(PixMap pix);
+
+protected:
+    QString decodeHexOctString(QString str);
+
+    void fillScoreString(QStrList &, QArray<int> &);
+    void fillArray(QArray<int> &, QString, int);
+    void fillStrList(QStrList &, QString, int);
+    void fillPixmapName(QStrList &);
+
+    void confScheme();
+    void confLevels(bool defGroup=TRUE);
+    void confMisc(bool defGroup=TRUE);
+    void confScoring(bool defGroup=TRUE);
+
+    void initPixmaps();
+    void initRoomPixmap();
+    void initbackPixmaps();
+
+private:
+    QWidget *w;
+    Board *board;
+    Bitfont *bitfont;
+
+    int BlockWidth;
+    int BlockHeight;
+
+    QArray<int> fruitScore;
+    QStrList fruitScoreString;
+    QArray<int> monsterScore;
+    QStrList monsterScoreString;
+
+    QString pixmapDirectory;
+
+    QStrList pointPixmapName;
+    QStrList wallPixmapName;
+    QStrList prisonPixmapName;
+    QStrList energizerPixmapName;
+    QStrList fruitPixmapName;
+    QStrList pacmanPixmapName;
+    QStrList dyingPixmapName;
+    QStrList eyesPixmapName;
+    QStrList monsterPixmapName;
+    QStrList fruitScorePixmapName;
+    QStrList monsterScorePixmapName;
+
+    QString lastPointPixmapName;
+    QString lastWallPixmapName;
+    QString lastPrisonPixmapName;
+    QString lastEnergizerPixmapName;
+    QString lastFruitPixmapName;
+    QString lastPacmanPixmapName;
+    QString lastDyingPixmapName;
+    QString lastEyesPixmapName;
+    QString lastMonsterPixmapName;
+    QString lastFruitScorePixmapName;
+    QString lastMonsterScorePixmapName;
+
+    QList<QPixmap> *loadPixmap(QWidget *parent, QString pixmapName,
+                               QList<QPixmap> *pixmaps=0);
+    QList<QPixmap> *textPixmap(QStrList &, QList<QPixmap> *pixmaps=0,
+                               QColor fg = BLACK, QColor bg = QColor());
+    QList<QPixmap> *textPixmap(QString str, QList<QPixmap> *pixmaps=0,
+                               QColor fg = BLACK, QColor bg = QColor());
+
+    QPoint point(int pos);
+    int checkRange(int value, int max, int min=0);
+
+    QList<QPixmap> *wallPix;
+    QList<QPixmap> *prisonPix;
+    QList<QPixmap> *pointPix;
+    QList<QPixmap> *energizerPix;
+    QList<QPixmap> *fruitPix;
+    QList<QPixmap> *pacmanPix;
+    QList<QPixmap> *dyingPix;
+    QList<QPixmap> *eyesPix;
+    QList<QPixmap> *monsterPix;
+    QList<QPixmap> *fruitScorePix;
+    QList<QPixmap> *monsterScorePix;
+
+    QPixmap roomPix;
+    QPixmap backPix;
+
+    bool plainColor;
+    QColor backgroundColor;
+
+    int maxLevel;
+    int level;
+
+    int scheme;
+    int mode;
+};
+
+#endif // PAINTER_H
diff --git a/noncore/games/kpacman/portable.h b/noncore/games/kpacman/portable.h
new file mode 100644
index 0000000..ff0912b
--- a/dev/null
+++ b/noncore/games/kpacman/portable.h
@@ -0,0 +1,63 @@
+/***************************************************************************
+  portable.h  -  various bits that ease porting kpacman to other platforms.
+  Currently KDE2 and Qtopia ports exist.
+                             -------------------
+    begin                : Mon Mar 18 12:35:24 EET 2002
+    copyright            : (C) 2002 by Catalin Climov
+    email                : catalin@climov.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef PORTABLE_H
+#define PORTABLE_H
+
+#ifdef QWS
+#define QPE_PORT
+#else
+#define KDE2_PORT
+#define KDE_PORT
+#endif
+
+#if defined( KDE2_PORT )
+
+#define APP kapp
+
+#define APP_CONFIG_BEGIN( cfgname ) KConfig cfgname = kapp->config()
+#define APP_CONFIG_END( cfgname ) cfgname->sync()
+#define SAVE_CONFIG_GROUP( cfgname, groupname ) QString groupname = configname->group()
+#define RESTORE_CONFIG_GROUP( cfgname, groupname ) configname->setGroup( groupname )
+
+#define FIND_APP_DATA( dataname ) KGlobal::dirs()->findResource( "appdata", dataname )
+
+#elif defined( QPE_PORT )
+
+#define i18n( x ) x
+#define KTMainWindow QMainWindow
+#define KMenuBar QMenuBar
+#define KAccel QAccel
+#define APP qApp
+
+#define APP_CONFIG_BEGIN( cfgname ) Config* cfgname = new Config("kpacman"); cfgname->setGroup("Default");
+#define APP_CONFIG_END( cfgname ) delete cfgname
+#define SAVE_CONFIG_GROUP( cfgname, groupname )
+#define RESTORE_CONFIG_GROUP( cfgname, groupname ) cfgname->setGroup("Default")
+
+#define FIND_APP_DATA( dataname ) (QPEApplication::qpeDir()+"share/kpacman/"+dataname)
+
+#else
+
+#error "Err, I don't know what platform to compile for (KDE2 or Qtopia)"
+
+#endif
+
+#define APP_QUIT() APP->quit()
+
+#endif // PORTABLE_H
diff --git a/noncore/games/kpacman/referee.cpp b/noncore/games/kpacman/referee.cpp
new file mode 100644
index 0000000..567a8ed
--- a/dev/null
+++ b/noncore/games/kpacman/referee.cpp
@@ -0,0 +1,1426 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kconfig.h>
+#include <kstddirs.h>
+#include <kaccel.h>
+#include <referee.h>
+#include <referee.moc>
+#elif defined( QPE_PORT )
+#include <qaccel.h>
+#include <qpe/qpeapplication.h>
+#include "config.h"
+#include "referee.h"
+#endif
+
+#include <qdatetm.h>
+#include <stdlib.h>
+#include <qtimer.h>
+#include <qevent.h>
+#include <qcolor.h>
+#include <qkeycode.h>
+#include <qfileinfo.h>
+
+#include "board.h"
+#include "pacman.h"
+#include "monster.h"
+#include "fruit.h"
+#include "painter.h"
+
+Referee::Referee( QWidget *parent, const char *name, int Scheme, int Mode, Bitfont *font)
+    : QWidget( parent, name )
+{
+    gameState.resize(12);
+    gameTimer = 0;
+    energizerTimer = 0;
+
+    focusedPause = FALSE;
+    setFocusPolicy(QWidget::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 QList<Monster>;
+    monsters->setAutoDelete(TRUE);
+
+    monsterRect = new QList<QRect>;
+    monsterRect->setAutoDelete(TRUE);
+
+    energizers = new QList<Energizer>;
+    energizers->setAutoDelete(TRUE);
+
+    energizerRect = new QList<QRect>;
+    energizerRect->setAutoDelete(TRUE);
+
+    pacmanRect.setRect(0, 0, 0, 0);
+    fruitRect.setRect(0, 0, 0, 0);
+
+    QTime midnight( 0, 0, 0 );
+    srand( midnight.secsTo(QTime::currentTime()) );
+
+    lifes = 0;
+    points = 0;
+
+    emit setLifes(lifes);
+    emit setPoints(points);
+
+    intro();
+}
+
+void Referee::paintEvent( QPaintEvent *e)
+{
+    if (gameState.testBit(HallOfFame))
+        return;
+
+    QRect rect = e->rect();
+
+    if (!rect.isEmpty()) {
+        QPixmap 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( QTimerEvent *e )
+{
+    if (gameState.testBit(HallOfFame))
+        return;
+
+    QRect 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()
+{
+    APP_CONFIG_BEGIN( cfg );
+    QString up("Up");
+    up = cfg->readEntry("upKey", (const char*) up);
+    UpKey    = KAccel::stringToKey(up);
+
+    QString down("Down");
+    down = cfg->readEntry("downKey", (const char*) down);
+    DownKey  = KAccel::stringToKey(down);
+
+    QString left("Left");
+    left = cfg->readEntry("leftKey", (const char*) left);
+    LeftKey  = KAccel::stringToKey(left);
+
+    QString right("Right");
+    right = cfg->readEntry("rightKey", (const char*) right);
+    RightKey = KAccel::stringToKey(right);
+    APP_CONFIG_END( cfg );
+}
+
+void Referee::fillArray(QArray<int> &array, QString values, int max)
+{
+    if (max < 0)
+        max = values.contains(',')+1;
+
+    array.resize(max);
+    int last = 0;
+    bool ok;
+    QString 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(QStrList &list, QString values, int max)
+{
+    if (!list.isEmpty())
+        list.clear();
+
+    QString last = "";
+    QString 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);
+    }
+}
+
+void Referee::fillMapName()
+{
+    QStrList list = mapName;
+
+    if (!mapName.isEmpty())
+                                mapName.clear();
+
+    QString map;
+
+    QFileInfo fileInfo;
+
+    for (uint i = 0; i < list.count(); i++) {
+        map = list.at(i);
+
+        if (map.left(1) != "/" && map.left(1) != "~")
+                  map = FIND_APP_DATA( mapDirectory+map );
+
+        fileInfo.setFile(map);
+        if (!fileInfo.isReadable())
+            map = "";
+        
+        mapName.append(map);
+    }
+}
+
+void Referee::confLevels(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("Levels"))
+        maxLevel = cfg->readNumEntry("Levels", 13);
+    APP_CONFIG_END( cfg );
+}
+
+void Referee::confMisc(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("PixmapDirectory")) {
+        pixmapDirectory = cfg->readEntry("PixmapDirectory");
+
+        if (pixmapDirectory.left(1) != "/" && pixmapDirectory.left(1) != "~")
+                  pixmapDirectory.insert(0, "pics/");
+        if (pixmapDirectory.right(1) != "/")
+                  pixmapDirectory.append("/");
+    }
+
+    if (defGroup || cfg->hasKey("MapDirectory")) {
+        mapDirectory = cfg->readEntry("MapDirectory");
+
+        if (mapDirectory.left(1) != "/" && mapDirectory.left(1) != "~")
+            mapDirectory.insert(0, "maps/");
+        if (mapDirectory.right(1) != "/")
+            mapDirectory.append("/");
+    }
+
+    if (defGroup || cfg->hasKey("MapName"))
+        fillStrList(mapName, cfg->readEntry("MapName", "map"), maxLevel+1);
+
+    if (defGroup || cfg->hasKey("MonsterIQ"))
+        fillArray(monsterIQ, cfg->readEntry("MonsterIQ", "0,170,180,170,180,170,180"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitIQ"))
+        fillArray(fruitIQ, cfg->readEntry("FruitIQ", "0,170,180,170,180,170,180"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitIndex"))
+        fillArray(fruitIndex, cfg->readEntry("FruitIndex", "0"), maxLevel+1);
+    APP_CONFIG_END( cfg );
+}
+
+void Referee::confTiming(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("SpeedMS"))
+        fillArray(speed, cfg->readEntry("SpeedMS", "20"), maxLevel+1);
+    if (defGroup || cfg->hasKey("PacmanTicks"))
+        fillArray(pacmanTicks,cfg->readEntry("PacmanTicks", "3"), maxLevel+1);
+    if (defGroup || cfg->hasKey("RemTicks"))
+        fillArray(remTicks, cfg->readEntry("RemTicks", "1"), maxLevel+1);
+    if (defGroup || cfg->hasKey("DangerousTicks"))
+        fillArray(dangerousTicks, cfg->readEntry("DangerousTicks", "3"), maxLevel+1);
+    if (defGroup || cfg->hasKey("HarmlessTicks"))
+        fillArray(harmlessTicks, cfg->readEntry("HarmlessTicks", "7,6,,5,,4"), maxLevel+1);
+    if (defGroup || cfg->hasKey("HarmlessDurationTicks"))
+        fillArray(harmlessDurTicks, cfg->readEntry("HarmlessDurationTicks", "375,,,300,,250,200,150"), maxLevel+1);
+    if (defGroup || cfg->hasKey("HarmlessWarningTicks"))
+        fillArray(harmlessWarnTicks, cfg->readEntry("HarmlessWarningTicks", "135"), maxLevel+1);
+    if (defGroup || cfg->hasKey("ArrestTicks"))
+        fillArray(arrestTicks, cfg->readEntry("ArrestTicks", "6"), maxLevel+1);
+    if (defGroup || cfg->hasKey("ArrestDurationTicks"))
+        fillArray(arrestDurTicks, cfg->readEntry("ArrestDurationTicks", "200,,,150"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitTicks"))
+        fillArray(fruitTicks, cfg->readEntry("FruitTicks", "7,6,,5,,4"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitAppearsTicks"))
+        fillArray(fruitAppearsTicks, cfg->readEntry("FruitAppearsTicks", "1000,,1500,2000,2500,3000,3500,4000"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitDurationTicks"))
+        fillArray(fruitDurTicks, cfg->readEntry("FruitDurationTicks", "500,,,400,350,300,,250,200,150"), maxLevel+1);
+    if (defGroup || cfg->hasKey("FruitScoreDurationTicks"))
+        fillArray(fruitScoreDurTicks, cfg->readEntry("FruitScoreDurationTicks", "150"), maxLevel+1);
+
+    if (defGroup || cfg->hasKey("MonsterScoreDurationMS"))
+        monsterScoreDurMS = cfg->readNumEntry("MonsterScoreDurationMS", 1000);
+    if (defGroup || cfg->hasKey("PlayerDurationMS"))
+        playerDurMS = cfg->readNumEntry("PlayerDurationMS", 3000);
+    if (defGroup || cfg->hasKey("ReadyDurationMS"))
+        readyDurMS = cfg->readNumEntry("ReadyDurationMS", 2000);
+    if (defGroup || cfg->hasKey("GameOverDurationMS"))
+        gameOverDurMS = cfg->readNumEntry("GameOverDurationMS", 3000);
+    if (defGroup || cfg->hasKey("AfterPauseMS"))
+        afterPauseMS = cfg->readNumEntry("AfterPauseMS", 1000);
+    if (defGroup || cfg->hasKey("DyingPreAnimationMS"))
+        dyingPreAnimationMS = cfg->readNumEntry("DyingPreAnimationMS", 1000);
+    if (defGroup || cfg->hasKey("DyingAnimationMS"))
+        dyingAnimationMS = cfg->readNumEntry("DyingAnimationMS", 100);
+    if (defGroup || cfg->hasKey("DyingPostAnimationMS"))
+        dyingPostAnimationMS = cfg->readNumEntry("DyingPostAnimationMS", 500);
+    if (defGroup || cfg->hasKey("IntroAnimationMS"))
+        introAnimationMS = cfg->readNumEntry("IntroAnimationMS", 800);
+    if (defGroup || cfg->hasKey("IntroPostAnimationMS"))
+        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 )
+        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, i18n("PAUSED")), FALSE);
+    } else {
+        gameState.clearBit(Paused);
+        repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("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, i18n("CHARACTER"), WHITE, QColor(), AlignLeft), FALSE);
+                  repaint(pix->draw(36, 6, RoomPix, i18n("/"), WHITE, QColor(), AlignLeft), FALSE);
+                  repaint(pix->draw(40, 6, RoomPix, i18n("NICKNAME"), WHITE, QColor(), AlignLeft), FALSE);
+                  break;
+        case  1 : introMonster(0);
+                  break;
+        case  2 : repaint(pix->draw(16, 10, RoomPix, i18n("-SHADOW"), RED, QColor(), AlignLeft), FALSE);
+                  break;
+        case  3 : repaint(pix->draw(38, 10, RoomPix, i18n("\"BLINKY\""), RED, QColor(), AlignLeft), FALSE);
+                  break;
+        case  4 : introMonster(1);
+                  break;
+        case  5 : repaint(pix->draw(16, 16, RoomPix, i18n("-SPEEDY"), PINK, QColor(), AlignLeft), FALSE);
+                  break;
+        case  6 : repaint(pix->draw(38, 16, RoomPix, i18n("\"PINKY\""), PINK, QColor(), AlignLeft), FALSE);
+                  break;
+        case  7 : introMonster(2);
+                  break;
+        case  8 : repaint(pix->draw(16, 22, RoomPix, i18n("-BASHFUL"), CYAN, QColor(), AlignLeft), FALSE);
+                  break;
+        case  9 : repaint(pix->draw(38, 22, RoomPix, i18n("\"INKY\""), CYAN, QColor(), AlignLeft), FALSE);
+                  break;
+        case 10 : introMonster(3);
+                  break;
+        case 11 : repaint(pix->draw(16, 28, RoomPix, i18n("-POKEY"), ORANGE, QColor(), AlignLeft), FALSE);
+                  break;
+        case 12 : repaint(pix->draw(38, 28, RoomPix, i18n("\"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);
+#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;
+    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();
+    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;
+    QTimer::singleShot(playerDurMS, this, SLOT(ready()));
+}
+
+void Referee::ready()
+{
+    if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+        QTimer::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();
+        QTimer::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);
+        QTimer::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;
+    QTimer::singleShot(levelUpPreAnimationMS, this, SLOT(levelUpPlay()));
+}
+
+void Referee::levelUpPlay()
+{
+    if (gameState.testBit(Ready))
+        return;
+
+    if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+        QTimer::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) {
+        QTimer::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)) {
+        QTimer::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);
+        QTimer::singleShot(dyingPreAnimationMS, this, SLOT(killed()));
+    } else {
+        stop();
+        if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
+            QTimer::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)) {
+        QTimer::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)
+            QTimer::singleShot(dyingPostAnimationMS, this, SLOT(killedPlay()));
+        else
+            QTimer::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);
+            QTimer::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);
+        QRect *r = new QRect();
+        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);
+        QRect *r = new QRect();
+        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(QFocusEvent *)
+{
+    if (focusInContinue && focusedPause &&
+        gameState.testBit(Paused) && gameState.testBit(Playing)) {
+        pause();
+    }
+}
+
+void Referee::focusOutEvent(QFocusEvent *)
+{
+    if (focusOutPause && !gameState.testBit(Paused) && gameState.testBit(Playing)) {
+        focusedPause = TRUE;
+        pause();
+    }
+}
diff --git a/noncore/games/kpacman/referee.h b/noncore/games/kpacman/referee.h
new file mode 100644
index 0000000..f812de4
--- a/dev/null
+++ b/noncore/games/kpacman/referee.h
@@ -0,0 +1,196 @@
+#ifndef REFEREE_H
+#define REFEREE_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#endif
+
+#include <qwidget.h>
+#include <qlist.h>
+#include <qstrlist.h>
+#include <qarray.h>
+#include <qbitarry.h>
+
+#include "board.h"
+#include "pacman.h"
+#include "monster.h"
+#include "fruit.h"
+#include "energizer.h"
+#include "bitfont.h"
+#include "painter.h"
+
+enum { Init, Introducing, Playing, Demonstration, Paused, Player, Ready, 
+       Scoring, LevelDone, Dying, GameOver, HallOfFame };
+
+
+class Referee : public QWidget
+{
+    Q_OBJECT
+public:
+    Referee (QWidget *parent=0, const char *name=0, int scheme=-1, int mode=-1, Bitfont *font=0);
+
+    void setSkill(int);
+    void setRoom(int);
+
+public slots:
+    void setScheme(int scheme, int mode, Bitfont *font=0);
+
+    void levelUp();
+    void levelUpPlay();
+
+    void pause();
+    void ready();
+    void intro();
+    void introPlay();
+    void hallOfFame();
+    void demo();
+    void play();
+    void killed();
+    void killedPlay();
+    void eaten();
+    void toggleHallOfFame();
+
+    void setFocusOutPause(bool focusOutPause);
+    void setFocusInContinue(bool focusInContinue);
+    void initKeys();
+
+    void repaintFigures();
+
+private slots:
+    void start();
+    void stop();
+    void stopEnergizer();
+
+signals:
+    void setScore(int, int);
+    void setPoints(int);
+    void setLevel(int);
+    void setLifes(int);
+
+    void toggleNew();
+    void togglePaused();
+    void forcedHallOfFame(bool);
+
+protected:
+    void timerEvent(QTimerEvent *);
+    void paintEvent(QPaintEvent *);
+    void keyPressEvent(QKeyEvent *);
+
+    void focusOutEvent(QFocusEvent *);
+    void focusInEvent(QFocusEvent *);
+
+    void fillArray(QArray<int> &, QString, int);
+    void fillStrList(QStrList &, QString, int);
+    void fillMapName();
+
+    void confScheme();
+    void confLevels(bool defGroup=TRUE);
+    void confMisc(bool defGroup=TRUE);
+    void confTiming(bool defGroup=TRUE);
+    void confScoring(bool defGroup=TRUE);
+
+private:
+    QBitArray gameState;
+    int timerCount;
+    int maxLevel;
+
+    int scheme;
+    int mode;
+
+    QString pixmapDirectory;
+    QString mapDirectory;
+    QStrList mapName;
+
+    QArray<int> speed;
+    QArray<int> monsterIQ;
+    QArray<int> fruitIQ;
+    QArray<int> fruitIndex;
+    QArray<int> pacmanTicks;
+    QArray<int> remTicks;
+    QArray<int> dangerousTicks;
+    QArray<int> harmlessTicks;
+    QArray<int> harmlessDurTicks;
+    QArray<int> harmlessWarnTicks;
+    QArray<int> arrestTicks;
+    QArray<int> arrestDurTicks;
+    QArray<int> fruitTicks;
+    QArray<int> fruitAppearsTicks;
+    QArray<int> fruitDurTicks;
+    QArray<int> fruitScoreDurTicks;
+
+    int monsterScoreDurMS;
+    int playerDurMS;
+    int readyDurMS;
+    int gameOverDurMS;
+    int afterPauseMS;
+    int dyingPreAnimationMS;
+    int dyingAnimationMS;
+    int dyingPostAnimationMS;
+    int introAnimationMS;
+    int introPostAnimationMS;
+    int levelUpPreAnimationMS;
+    int levelUpAnimationMS;
+    int energizerAnimationMS;
+
+    int pointScore;
+    int energizerScore;
+    QArray<int> fruitScore;
+    QArray<int> monsterScore;
+    QArray<int> extraLifeScore;
+
+    int extraLifeScoreIndex;
+    int nextExtraLifeScore;
+
+    int monstersEaten;
+    int points;
+    int lifes;
+    int level;
+
+    bool focusedPause;
+    bool focusOutPause;
+    bool focusInContinue;
+
+    Board   *board;
+    Painter *pix;
+    Pacman  *pacman;
+    Fruit   *fruit;
+
+    QList<Monster> *monsters;
+    QList<QRect> *monsterRect;
+
+    QList<Energizer> *energizers;
+    QList<QRect> *energizerRect;
+
+    QRect pacmanRect;
+    QRect fruitRect;
+
+    void introMonster(int id);
+    void introPaint(int t);
+
+    void initMonsters();
+    void initPacman();
+    void initFruit(bool fullInitialization=TRUE);
+    void initEnergizers();
+
+    void setOnEnergizers();
+
+    int  gameTimer;
+    int  energizerTimer;
+    void start(int);
+    void init(bool);
+
+    void score(int);
+
+    uint UpKey;
+    uint DownKey;
+    uint RightKey;
+    uint LeftKey;
+};
+
+#endif // REFEREE_H
diff --git a/noncore/games/kpacman/score.cpp b/noncore/games/kpacman/score.cpp
new file mode 100644
index 0000000..6e660e8
--- a/dev/null
+++ b/noncore/games/kpacman/score.cpp
@@ -0,0 +1,642 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <score.h>
+#include <score.moc>
+
+#include <kaccel.h>
+#include <kapp.h>
+#include <kconfig.h>
+#include <kstddirs.h>
+#include <kmessagebox.h>
+#elif defined( QPE_PORT )
+#include <qaccel.h>
+#include "config.h"
+#include "score.h"
+#endif
+
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <qpixmap.h>
+#include <qstring.h>
+#include <qdstream.h>
+#include <qkeycode.h>
+#include <qtimer.h>
+#include <qfileinfo.h>
+
+#include "bitfont.h"
+
+Score::Score(QWidget *parent, const char *name, int Scheme, int Mode, Bitfont *font) : QWidget(parent, name)
+{
+    setFocusPolicy(QWidget::StrongFocus);
+
+    paused = FALSE;
+
+    lastScore = -1;
+    lastPlayer = -1;
+
+    cursorBlinkTimer = 0;
+    cursorBlinkMS = -1;
+    cursor.x = -1;
+    cursor.y = -1;
+    cursor.on = FALSE;
+    cursor.chr = QChar('?');
+
+    initKeys();
+
+    scheme = Scheme;
+    mode = Mode;
+    confScheme();
+
+    bitfont = font;
+
+    highscoreFile.setName(locateHighscoreFilePath().filePath());
+    read();
+
+    for (int p = 0; p < maxPlayer; p++) {
+        playerScore[p] = 0;
+        playerName[p] = getenv("LOGNAME");
+        if (playerName[p].length() < minPlayerNameLength)
+            playerName[p].setExpand(minPlayerNameLength-1, ' ');
+
+        for (uint i = 0; i < playerName[p].length(); i++)
+            if (playerName[p].at(i) < bitfont->firstChar() ||
+                playerName[p].at(i) > bitfont->lastChar())
+                playerName[p].at(i) = playerName[p].at(i).upper();
+    }
+}
+
+Score::~Score()
+{
+    // write();
+}
+
+void Score::paintEvent( QPaintEvent *e)
+{
+    if (rect(1, 0, i18n("  1UP ")).intersects(e->rect())) {
+        QPixmap pix;
+        QColor fg = BLACK;
+        if (cursor.on || paused || lastPlayer != 0)
+            fg = WHITE;
+        pix = bitfont->text(i18n("  1UP "), fg, BLACK);
+        bitBlt(this, x(1), y(0), &pix);
+    }
+
+    if (rect(8, 0, i18n(" HIGH SCORE ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n(" HIGH SCORE "), WHITE, BLACK);
+        bitBlt(this, x(8), y(0), &pix);
+    }
+
+    if (maxPlayer > 1 && rect(21, 0, i18n("  2UP ")).intersects(e->rect())) {
+        QPixmap pix;
+        QColor fg = BLACK;
+        if (cursor.on || paused || lastPlayer != 1)
+            fg = WHITE;
+        pix = bitfont->text(i18n("  2UP "), fg, BLACK);
+        bitBlt(this, x(21), y(0), &pix);
+    }
+
+    QString s;
+
+    s.sprintf("%6d0", playerScore[0]/10);
+    if (rect(0, 1, s).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(s, WHITE, BLACK);
+            bitBlt(this, x(0), y(1), &pix);
+    }
+
+    s.sprintf("%8d0", HighScore/10);
+    if (rect(8, 1, s).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(s, WHITE, BLACK);
+            bitBlt(this, x(8), y(1), &pix);
+    }
+
+    if (lastScore >= 0) {
+        if (rect(1, 4*1.25, i18n("     CONGRATULATIONS      ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n("     CONGRATULATIONS      "), YELLOW, BLACK);
+            bitBlt(this, x(1), y(4*1.25), &pix);
+        }
+        if (rect(1, 6*1.25, i18n("    YOU HAVE ARCHIEVED    ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n("    YOU HAVE ARCHIEVED    "), CYAN, BLACK);
+            bitBlt(this, x(1), y(6*1.25), &pix);
+        }
+        if (rect(1, 7*1.25, i18n("  A SCORE IN THE TOP 10.  ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n("  A SCORE IN THE TOP 10.  "), CYAN, BLACK);
+            bitBlt(this, x(1), y(7*1.25), &pix);
+        }
+        if (rect(1, 8*1.25, i18n("                          ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n("                          "), CYAN, BLACK);
+            bitBlt(this, x(1), y(8*1.25), &pix);
+        }
+    }
+
+    if (rect(1, 9.5*1.25, i18n("RNK   SCORE  NAME   DATE")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(i18n("RNK   SCORE  NAME   DATE"), WHITE, BLACK);
+        bitBlt(this, x(1), y(9.5*1.25), &pix);
+    }
+
+    for (int i = 0; i < 10; i++) {
+        s.sprintf("%2d%9d  %-3.3s  %-8.8s",
+            i+1, hallOfFame[i].points, hallOfFame[i].name.utf8().data(),
+            formatDate(hallOfFame[i].moment.date()).data());
+        if (rect(1, (11+i)*1.25, s).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(s, (i == lastScore) ? YELLOW : WHITE, BLACK);
+            bitBlt(this, x(1), y((11+i)*1.25), &pix);
+        }
+    }
+
+    if (cursor.x != -1 && cursor.y != -1 && cursor.on) {
+        if (rect(cursor.x, (cursor.y*1.25), cursor.chr).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(cursor.chr, BLACK, YELLOW);
+            bitBlt(this, x(cursor.x), y(cursor.y*1.25), &pix);
+        }
+    }
+
+    if (paused) {
+
+        QPixmap pix = bitfont->text(i18n("PAUSED"), RED, BLACK);
+        QRect r = bitfont->rect(i18n("PAUSED"));
+        r.moveCenter(QPoint(this->width()/2, this->height()/2));
+
+        bitBlt(this, r.x(), r.y(), &pix);
+    }
+}
+
+void Score::timerEvent(QTimerEvent*)
+{
+    cursor.on = !cursor.on;
+
+    if (paused)
+        return;
+
+    if (cursor.x != -1 && cursor.y != -1)
+        repaint(rect(cursor.x, cursor.y*1.25, cursor.chr), FALSE);
+    scrollRepeat = FALSE;
+
+    if (lastPlayer == 0)
+        repaint(rect(1, 0, i18n("  1UP ")), FALSE);
+
+    if (lastPlayer == 1)
+        repaint(rect(21, 0, i18n("  2UP ")), FALSE);
+}
+
+void Score::keyPressEvent(QKeyEvent *k)
+{
+    if (lastScore < 0 || lastPlayer < 0 || lastPlayer >= maxPlayer || paused) {
+        k->ignore();
+        return;
+    }
+
+    int x = cursor.x;
+    int y = cursor.y;
+
+    uint key = k->key();
+
+    if (scrollRepeat && (key == UpKey || key == Key_Up || key == DownKey || key == Key_Down)) {
+        k->ignore();
+        return;
+    }
+
+    if (key != Key_Return) {
+        if (key == RightKey || key == Key_Right)
+            if (++cursor.x > 16)
+                cursor.x = 14;
+        if (key == LeftKey || key == Key_Left)
+            if (--cursor.x < 14)
+                cursor.x = 16;
+        if (key == UpKey || key == Key_Up)
+            if (cursor.chr.unicode() < bitfont->lastChar())
+                cursor.chr = cursor.chr.unicode()+1;
+            else
+                cursor.chr = bitfont->firstChar();
+        if (key == DownKey || key == Key_Down)
+            if (cursor.chr.unicode() > bitfont->firstChar())
+                cursor.chr = cursor.chr.unicode()-1;
+            else
+                cursor.chr = bitfont->lastChar();
+
+        if (cursor.x == x && cursor.y == y &&
+            cursor.chr == hallOfFame[lastScore].name.at(cursor.x-14)) {
+            uint ascii = k->ascii();
+
+            if (ascii < bitfont->firstChar() || ascii > bitfont->lastChar())
+                ascii = toupper(ascii);
+
+            if (ascii >= bitfont->firstChar() && ascii <= bitfont->lastChar()) {
+                cursor.chr = ascii;
+                hallOfFame[lastScore].name.at(cursor.x-14) = cursor.chr;
+                if (++cursor.x > 16)
+                    cursor.x = 14;
+            }
+        }
+    }
+
+    if (key == Key_Return) {
+        playerName[lastPlayer] = hallOfFame[lastScore].name;
+        write();
+        read();
+        lastScore = -1;
+        cursor.x = -1;
+        cursor.y = -1;
+//      killTimers();
+        emit toggleNew();
+        end();
+    }
+
+    if (x != cursor.x || y != cursor.y) {
+        if (cursor.x != -1)
+            cursor.chr = hallOfFame[lastScore].name.at(cursor.x-14);
+        scrollRepeat = FALSE;
+        repaint(rect(x, y*1.25, cursor.chr), FALSE);
+    } else
+        hallOfFame[lastScore].name.at(cursor.x-14) = cursor.chr;
+
+    if (key == UpKey || key == Key_Up || key == DownKey || key == Key_Down)
+       scrollRepeat = TRUE;
+    else
+       repaint(rect(cursor.x, cursor.y*1.25, cursor.chr), FALSE);
+}
+
+void Score::initKeys()
+{
+    APP_CONFIG_BEGIN( cfg );
+    QString up("Up");
+    up = cfg->readEntry("upKey", (const char*) up);
+    UpKey    = KAccel::stringToKey(up);
+
+    QString down("Down");
+    down = cfg->readEntry("downKey", (const char*) down);
+    DownKey  = KAccel::stringToKey(down);
+
+    QString left("Left");
+    left = cfg->readEntry("leftKey", (const char*) left);
+    LeftKey  = KAccel::stringToKey(left);
+
+    QString right("Right");
+    right = cfg->readEntry("rightKey", (const char*) right);
+    RightKey = KAccel::stringToKey(right);
+    APP_CONFIG_END( cfg );
+}
+
+void Score::confTiming(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("CursorBlinkMS"))
+        cursorBlinkMS = cfg->readNumEntry("CursorBlinkMS", 250);
+    if (defGroup || cfg->hasKey("HallOfFameMS"))
+        hallOfFameMS = cfg->readNumEntry("HallOfFameMS", 7000);
+    if (defGroup || cfg->hasKey("AfterPauseMS"))
+        afterPauseMS = cfg->readNumEntry("AfterPauseMS", 1000);
+    APP_CONFIG_END( cfg );
+}
+
+void Score::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 );
+        }
+    }
+
+    int oldCursorBlinkMS = cursorBlinkMS;
+
+    confTiming();
+
+    if (mode != -1) {
+        newgroup.sprintf("Mode %d", mode);
+        cfg->setGroup(newgroup);
+
+        confTiming(FALSE);
+    }
+
+    if (scheme != -1) {
+        newgroup.sprintf("Scheme %d", scheme);
+        cfg->setGroup(newgroup);
+
+        confTiming(FALSE);
+    }
+
+    if (cursorBlinkMS != oldCursorBlinkMS) {
+        if (cursorBlinkTimer)
+            killTimer(cursorBlinkTimer);
+        cursorBlinkTimer = startTimer(cursorBlinkMS);
+    }
+
+    RESTORE_CONFIG_GROUP( cfg, oldgroup );
+    APP_CONFIG_END( cfg );
+}
+
+void Score::setScheme(int Scheme, int Mode, Bitfont *font)
+{
+    mode = Mode;
+    scheme = Scheme;
+
+    confScheme();
+
+    bitfont = font;
+
+    for (int p = 0; p < maxPlayer; p++)
+        for (uint i = 0; i < playerName[p].length(); i++)
+            if (playerName[p].at(i) < bitfont->firstChar() ||
+                playerName[p].at(i) > bitfont->lastChar())
+                playerName[p].at(i) = playerName[p].at(i).upper();
+
+    for (int i = 0; i < 10; i++)
+        for (uint j = 0; j < hallOfFame[i].name.length(); j++)
+            if (hallOfFame[i].name.at(j) < bitfont->firstChar() ||
+                hallOfFame[i].name.at(j) > bitfont->lastChar())
+                hallOfFame[i].name.at(j) = hallOfFame[i].name.at(j).upper();
+
+    if (cursor.chr.unicode() < bitfont->firstChar() ||
+        cursor.chr.unicode() > bitfont->lastChar())
+        cursor.chr = cursor.chr.upper();
+}
+
+void Score::set(int score)
+{
+    set(score, 0);
+}
+
+void Score::set(int score, int player)
+{
+    if (player < 0 || player >= maxPlayer)
+        return;
+
+    lastPlayer = player;
+    playerScore[lastPlayer] = score;
+
+    QString s;
+
+    s.sprintf("%6d0", playerScore[lastPlayer]/10);
+    repaint(rect(0, 1, s), FALSE);
+
+    if (score > HighScore) {
+            HighScore = score;
+            s.sprintf("%8d0", HighScore/10);
+            repaint(rect(8, 1, s), FALSE);
+    }
+}
+
+/*
+ * Set the score for player after the game if over. If the score is in the
+ * high scores then the hall of fame is updated (shifted) and the scoreboard
+ * is shown.
+ */
+
+void Score::setScore(int level, int player)
+{
+    lastScore = -1;
+
+    if (player < 0 || player >= maxPlayer || level == 0) {
+        if (level != 0)
+            emit toggleNew();
+        QTimer::singleShot(hallOfFameMS, this, SLOT(end()));
+        return;
+    }
+
+    lastPlayer = player;
+
+    for (int i = 0; i < 10; i++)
+        if ( playerScore[lastPlayer] > hallOfFame[i].points) {
+            lastScore = i;
+            break;
+        }
+
+    if (lastScore < 0) {
+        emit toggleNew();
+        QTimer::singleShot(hallOfFameMS, this, SLOT(end()));
+        return;
+    }
+
+    for (int i = 9; i > lastScore && i > 0; i--)
+        hallOfFame[i] = hallOfFame[i-1];
+
+    hallOfFame[lastScore].points = playerScore[lastPlayer];
+    hallOfFame[lastScore].levels = level;
+    hallOfFame[lastScore].moment = QDateTime::currentDateTime();
+    hallOfFame[lastScore].name = playerName[lastPlayer];
+
+    cursor.x = 14;
+    cursor.y = 11+lastScore;
+    cursor.chr = hallOfFame[lastScore].name.at(cursor.x-14);
+
+//  startTimer(cursorBlinkMS);
+    setFocus();
+}
+
+/*
+ * Read the highscores, if no file or a file shorter than 4 bytes (versions before 0.2.4 stores only
+ * the points of one highscore) exists - the highscores were initialized with default values.
+ */
+void Score::read()
+{
+    if (highscoreFile.exists() && highscoreFile.size() > 4) {
+        if (highscoreFile.open(IO_ReadOnly)) {
+            QDataStream s(&highscoreFile);
+            char *name;
+            for (int i = 0; i < 10; i++) {
+                s >> hallOfFame[i].points >> hallOfFame[i].levels >> hallOfFame[i].duration >>
+                     hallOfFame[i].moment >> name;
+                hallOfFame[i].name = QString::fromLatin1(name);
+                delete(name);
+            }
+            highscoreFile.close();
+        }
+    } else {
+        for (int i = 0; i < 10; i++) {
+            hallOfFame[i].points = 5000;
+            hallOfFame[i].levels = 0;
+            hallOfFame[i].duration = QTime();
+            hallOfFame[i].moment = QDateTime();
+            hallOfFame[i].name = "???";
+        }
+        // write();
+    }
+
+    for (int i = 0; i < 10; i++)
+        for (uint j = 0; j < hallOfFame[i].name.length(); j++)
+            if (hallOfFame[i].name.at(j) < bitfont->firstChar() ||
+                hallOfFame[i].name.at(j) > bitfont->lastChar())
+                hallOfFame[i].name.at(j) = hallOfFame[i].name.at(j).upper();
+
+    HighScore = hallOfFame[0].points;
+}
+
+void Score::write()
+{
+#ifndef QWS
+    if (!highscoreFile.exists() && highscoreFile.name() == systemHighscoreFileInfo.filePath())
+        KMessageBox::information(0,
+                                 i18n("You're going to create the highscore-file\n"
+                                 "'%1'\n"
+																 "for your maschine, that should be used systemwide.\n"
+																 "\n"
+                                 "To grant access to the other users, set the appropriate rights (a+w)\n"
+                                 "on that file or ask your systemadministator for that favor.\n"
+                                 "\n"
+                                 "To use a different directory or filename for the highscores,"
+                                 "specify them in the configfile (kpacmanrc:highscoreFilePath)."
+                                 ).arg(systemHighscoreFileInfo.filePath()));
+
+    if (highscoreFile.name() == privateHighscoreFileInfo.filePath())
+        KMessageBox::information(0,
+                                 i18n("You're using a private highscore-file, that's mostly because of\n"
+                                 "missing write-access to the systemwide file\n"
+                                 "'%1' .\n"
+                                 "\n"
+                                 "Ask your systemadministrator for granting you access to that file,\n"
+                                 "by setting the appropriate rights (a+w) on it.\n"
+                                 "\n"
+                                 "To use a different directory or filename for the highscores,"
+                                 "specify them in the configfile (kpacmanrc:highscoreFilePath)."
+                                 ).arg(systemHighscoreFileInfo.filePath()),
+                                 QString::null, "PrivateHighscore");
+#endif
+    if (highscoreFile.open(IO_WriteOnly)) {
+        QDataStream s(&highscoreFile);
+        for (int i = 0; i < 10; i++)
+            s << hallOfFame[i].points << hallOfFame[i].levels << hallOfFame[i].duration <<
+                 hallOfFame[i].moment << hallOfFame[i].name.latin1();
+        highscoreFile.close();
+    }
+}
+
+void Score::setPause(bool Paused)
+{
+    paused = Paused;
+
+    QRect r = bitfont->rect(i18n("PAUSED"));
+    r.moveCenter(QPoint(this->width()/2, this->height()/2));
+    repaint(r, TRUE);
+
+    // repaint 1UP or 2UP
+    repaint(FALSE);
+}
+
+void Score::end()
+{
+    if (paused) {
+        QTimer::singleShot(afterPauseMS, this, SLOT(end()));
+        return;
+    }
+
+    // repaint 1UP or 2UP
+    lastPlayer = -1;
+    repaint(FALSE);
+
+    emit forcedHallOfFame(FALSE);
+}
+
+/*
+ * Return the date in a formatted QString. The format can be changed using internationalization
+ * of the string "YY/MM/DD". Invalid QDate's where returned as "00/00/00".
+ */
+QString Score::formatDate(QDate date)
+{
+    QString s = i18n("@YY@/@MM@/@DD@");
+
+    QString dd;
+    dd.sprintf("%02d", date.isValid() ? date.year() % 100 : 0);
+    s.replace(QRegExp("@YY@"), dd);
+    dd.sprintf("%02d", date.isValid() ? date.month() : 0);
+    s.replace(QRegExp("@MM@"), dd);
+    dd.sprintf("%02d", date.isValid() ? date.day() : 0);
+    s.replace(QRegExp("@DD@"), dd);
+
+    return s;
+}
+
+QRect Score::rect(int col, float row, QString str, int align)
+{
+    QRect r = bitfont->rect(str);
+    r.moveBy(x(col), y(row));
+
+    int dx = 0;
+    int dy = 0;
+
+    if (align & AlignLeft || align & AlignRight) {
+        dx = (str.length()-1) * (bitfont->width()/2);
+        if (align & AlignRight)
+            dx *= -1;
+    }
+
+    if (align & AlignTop || align & AlignBottom) {
+        dy = bitfont->height()/2;
+        if (align & AlignBottom)
+            dy *= -1;
+    }
+
+    if (dx != 0 || dy != 0)
+        r.moveBy(dx, dy);
+
+    return r;
+}
+
+int Score::x(int col)
+{
+    return col*bitfont->width();
+}
+
+int Score::y(float row)
+{
+    return (int) (row*(bitfont->height()+bitfont->height()/4));
+}
+
+/**
+ * Ermittelt die zu benutzende "highscore"-Datei, in die auch geschrieben werden kann.
+ * Über den "highscoreFilePath"-KConfig-Eintrag, kann abweichend von der Standardlokation
+ * der Standort der "highscore"-Datei spezifiziert werden.
+ * Wenn die systemweite "highscore"-Datei nicht beschrieben werden kann, wird mit einer
+ * privaten Datei gearbeitet.
+ */
+QFileInfo Score::locateHighscoreFilePath()
+{
+#ifndef QWS
+    QFileInfo systemHighscoreDirPath;
+    QStringList systemHighscoreDirs;
+
+    // Schreibfähige "private" highscore-Datei ermitteln für den fallback.
+    privateHighscoreFileInfo.setFile(KGlobal::dirs()->saveLocation("appdata")+highscoreName);
+
+    // FilePath aus der Konfigurationsdatei benutzen
+    systemHighscoreFileInfo.setFile(cfg->readEntry("HighscoreFilePath"));
+
+    // Kein Wert aus der Konfiguration erhalten, dann die "system"-Datei suchen.
+    if (systemHighscoreFileInfo.filePath().isEmpty())
+        systemHighscoreDirs = KGlobal::dirs()->resourceDirs("appdata");
+    else
+        systemHighscoreDirs = QStringList(systemHighscoreFileInfo.filePath());
+
+    for (QStringList::Iterator i = systemHighscoreDirs.begin(); i != systemHighscoreDirs.end(); ++i) {
+
+         systemHighscoreFileInfo.setFile(*i);
+         if (systemHighscoreFileInfo.fileName().isEmpty())
+             systemHighscoreFileInfo.setFile(systemHighscoreFileInfo.dirPath()+"/"+highscoreName);
+
+         // privateHighscoreFileInfo für die "system" Suche ignorieren
+         if (systemHighscoreFileInfo.filePath() != privateHighscoreFileInfo.filePath())
+         		 if (!systemHighscoreFileInfo.exists()) {
+					       systemHighscoreDirPath.setFile(systemHighscoreFileInfo.dirPath());
+						     if (systemHighscoreDirPath.exists() && systemHighscoreDirPath.isWritable())
+         		         return systemHighscoreFileInfo;
+         		 } else
+         		     if (systemHighscoreFileInfo.isWritable())
+         		         return systemHighscoreFileInfo;
+    }
+#endif
+    return privateHighscoreFileInfo;
+}
diff --git a/noncore/games/kpacman/score.h b/noncore/games/kpacman/score.h
new file mode 100644
index 0000000..87f24b9
--- a/dev/null
+++ b/noncore/games/kpacman/score.h
@@ -0,0 +1,129 @@
+#ifndef SCORE_H
+#define SCORE_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#endif
+
+#include <qwidget.h>
+#include <qstring.h>
+#include <qpoint.h>
+#include <qrect.h>
+#include <qfile.h>
+
+#include <qfileinfo.h>
+#include <qdatetime.h>
+
+#include "painter.h"
+#include "bitfont.h"
+
+#define maxPlayer 1
+#define minPlayerNameLength 3
+#define highscoreName "highscore"
+
+class Score : public QWidget
+{
+    Q_OBJECT
+public:
+    Score (QWidget *parent=0, const char *name=0, int scheme=-1, int mode=-1, Bitfont *font=0);
+    ~Score();
+
+public slots:
+    void setScheme(int scheme, int mode, Bitfont *font=0);
+
+    void set(int score);
+    void set(int score, int player);
+    void setScore(int level, int player);
+    void setPause(bool paused);
+
+    void initKeys();
+
+private slots:
+    void read();
+    void write();
+    void end();
+
+signals:
+    void toggleNew();
+    void forcedHallOfFame(bool);
+
+protected:
+    void timerEvent(QTimerEvent *);
+    void paintEvent(QPaintEvent *);
+    void keyPressEvent(QKeyEvent *);
+
+    void focusInEvent(QFocusEvent *) { ; }
+    void focusOutEvent(QFocusEvent *) { ; }
+
+    void confScheme();
+    void confTiming(bool defGroup=TRUE);
+
+private:
+    Bitfont *bitfont;
+
+    QRect rect(int col, float row, QString str, int align = AlignCenter);
+    int x(int col);
+    int y(float row);
+
+    QString formatDate(QDate date);
+
+		/**
+		 * Ermittelt die zu benutzende "highscore"-Datei, in die auch geschrieben werden kann.
+		 * Über den "highscoreFilePath"-KConfig-Eintrag, kann abweichend von der Standardlokation
+		 * der Standort der "highscore"-Datei spezifiziert werden.
+		 * Wenn die systemweite "globale" Datei nicht beschrieben werden kann, wird mit einer
+		 * privaten Datei gearbeitet.
+		 */
+    QFileInfo locateHighscoreFilePath();
+
+    int cursorBlinkMS;
+    int hallOfFameMS;
+    int afterPauseMS;
+
+    bool paused;
+
+    uint UpKey;
+    uint DownKey;
+    uint RightKey;
+    uint LeftKey;
+
+    int lastScore;
+    int lastPlayer;
+    int HighScore;
+    int playerScore[maxPlayer];
+    QString playerName[maxPlayer];
+
+    struct {
+        int x;
+        int y;
+        QChar chr;
+        bool on;
+    } cursor;
+
+    int cursorBlinkTimer;
+    bool scrollRepeat;
+
+    struct {
+        int points;
+        int levels;
+        QTime duration;
+        QDateTime moment;
+        QString name;
+    } hallOfFame[10];
+
+    QFileInfo systemHighscoreFileInfo;
+    QFileInfo privateHighscoreFileInfo;
+
+    QFile highscoreFile;
+
+    int scheme;
+    int mode;
+};
+
+#endif // SCORE_H
diff --git a/noncore/games/kpacman/status.cpp b/noncore/games/kpacman/status.cpp
new file mode 100644
index 0000000..00d1f22
--- a/dev/null
+++ b/noncore/games/kpacman/status.cpp
@@ -0,0 +1,367 @@
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <klocale.h>
+#include <kstddirs.h>
+#include <status.h>
+#include <status.moc>
+#elif defined( QPE_PORT )
+#include <qpe/qpeapplication.h>
+#include "config.h"
+#include "status.h"
+#endif
+
+#include <qpixmap.h>
+#include <qbitmap.h>
+#include <qstring.h>
+#include <qmsgbox.h>
+#include <qfileinfo.h>
+
+Status::Status( QWidget *parent, const char *name, int Scheme, int Mode ) :
+    QWidget( parent, name )
+{
+    actualLifes = 0;
+    actualLevel = 0;
+
+    lifesPix = NULL;
+    levelPix = NULL;
+
+    scheme = Scheme;
+    mode = Mode;
+    level = 0;
+
+    confScheme();
+}
+
+QList<QPixmap> *Status::loadPixmap(QWidget *parent, QString pixmapName,
+                                   QList<QPixmap> *pixmaps)
+{
+    if (pixmaps == NULL) {
+        pixmaps = new QList<QPixmap>;
+        pixmaps->setAutoDelete(TRUE);
+    }
+
+    if (!pixmaps->isEmpty())
+        pixmaps->clear();
+
+    QPixmap PIXMAP(pixmapName);
+    if (PIXMAP.isNull() || PIXMAP.mask() == NULL) {
+        QString msg = i18n("The pixmap could not be contructed.\n\n"
+                           "The file '@PIXMAPNAME@' does not exist,\n"
+                           "or is of an unknown format.");
+        msg.replace(QRegExp("@PIXMAPNAME@"), pixmapName);
+        QMessageBox::information(parent, i18n("Initialization Error"),
+                                 (const char *) msg);
+        return 0;
+    }
+
+    int height = PIXMAP.height();
+    int width = (height == 0) ? 0 : PIXMAP.width()/(PIXMAP.width()/height);
+
+    QBitmap BITMAP;
+    QBitmap MASK;
+
+    BITMAP = *PIXMAP.mask();
+    MASK.resize(width, height);
+
+    for (int x = 0; x < PIXMAP.width()/width; x++) {
+        QPixmap *pixmap = new QPixmap(width, height);
+        pixmaps->append(pixmap);
+        bitBlt(pixmap, 0, 0, &PIXMAP, x*width, 0, width, height, CopyROP, TRUE);
+        bitBlt(&MASK, 0, 0, &BITMAP, x*width, 0, width, height, CopyROP, TRUE);
+        pixmap->setMask(MASK);
+    }
+
+    return pixmaps;
+}
+
+void Status::paintEvent( QPaintEvent *)
+{
+    for (int x = 0; x < actualLifes && !lifesPix->isEmpty(); x++)
+        bitBlt(this, lifesPix->at(0)->width()+(lifesPix->at(0)->width()*x), 
+               (height()-lifesPix->at(0)->height())/2,
+               lifesPix->at(0), 0, 0,
+               lifesPix->at(0)->width(), lifesPix->at(0)->height());
+
+    for (int x = 0; x < actualLevel && !levelPix->isEmpty(); x++) {
+        erase((width()-levelPix->at(x)->width()*2)-(levelPix->at(x)->width()*levelPos[x]),
+              (height()-levelPix->at(x)->height())/2,
+              levelPix->at(x)->width(), levelPix->at(x)->height());
+        bitBlt(this, (width()-levelPix->at(x)->width()*2)-(levelPix->at(x)->width()*levelPos[x]),
+               (height()-levelPix->at(x)->height())/2,
+               levelPix->at(x), 0, 0,
+               levelPix->at(x)->width(), levelPix->at(x)->height());
+    }
+}
+
+void Status::initPixmaps()
+{
+    if (lastLifesPixmapName != lifesPixmapName.at(level)) {
+        lifesPix = loadPixmap(this, lifesPixmapName.at(level), lifesPix);
+        lastLifesPixmapName = lifesPixmapName.at(level);
+    }
+    if (lastLevelPixmapName != levelPixmapName.at(level)) {
+        levelPix = loadPixmap(this, levelPixmapName.at(level), levelPix);
+        lastLevelPixmapName = levelPixmapName.at(level);
+    }
+}
+
+QString Status::decodeHexOctString(QString s)
+{
+    QString value;
+    QString valids;
+    int pos, xpos = 0, opos = 0;
+    int v, len, leadin;
+    const char *ptr;
+    uchar c;
+
+    while (((xpos = s.find(QRegExp("\\\\x[0-9a-fA-F]+"), xpos)) != -1) ||
+           ((opos = s.find(QRegExp("\\\\[0-7]+"), opos)) != -1)) {
+        if (xpos != -1) {
+            valids = "0123456789abcdef";
+            leadin = 2;
+            pos = xpos;
+        } else {
+            valids = "01234567";
+            leadin = 1;
+            pos = opos;
+        }
+
+        c = '\0';
+        len = 0;
+        value = s.mid(pos+leadin, 3);
+        ptr = (const char *) value;
+
+        while (*ptr != '\0' && (v = valids.find(*ptr++, 0, FALSE)) != -1) {
+            c = (c * valids.length()) + v;
+            len++;
+        }
+
+        value.fill(c, 1);
+        s.replace(pos, len+leadin, value);
+    }
+
+    return s;
+}
+
+void Status::fillArray(QArray<int> &array, QString values, int max)
+{
+    array.resize(max);
+    int last = 0;
+    bool ok;
+    QString 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 Status::fillStrList(QStrList &list, QString values, int max)
+{
+    if (!list.isEmpty())
+        list.clear();
+
+    QString last = "";
+    QString 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 = decodeHexOctString(value);
+        list.append(last);
+    }
+}
+
+void Status::fillPixmapName(QStrList &pixmapName)
+{
+    QStrList list = pixmapName;
+
+    if (!pixmapName.isEmpty())
+        pixmapName.clear();
+
+    QString pixmap;
+
+    QFileInfo fileInfo;
+
+    for (uint i = 0; i < list.count(); i++) {
+            pixmap = list.at(i);
+
+        if (pixmap.left(1) != "/" && pixmap.left(1) != "~")
+              pixmap = FIND_APP_DATA( pixmapDirectory+pixmap );
+
+      fileInfo.setFile(pixmap);
+      if (!fileInfo.isReadable() || !fileInfo.isFile())
+            pixmap = "";
+
+      pixmapName.append(pixmap);
+    }
+}
+
+void Status::confLevels(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("Levels"))
+        maxLevel = cfg->readNumEntry("Levels", 13);
+    APP_CONFIG_END( cfg );
+}
+
+void Status::confMisc(bool defGroup)
+{
+    APP_CONFIG_BEGIN( cfg );
+    if (defGroup || cfg->hasKey("LevelPosition"))
+        fillArray(levelPos, cfg->readEntry("LevelPosition", "0,1,2,3,,4,,5,,6,,7"), maxLevel);
+
+    if (defGroup || cfg->hasKey("PixmapDirectory")) {
+        pixmapDirectory = cfg->readEntry("PixmapDirectory");
+
+        if (pixmapDirectory.left(1) != "/" && pixmapDirectory.left(1) != "~")
+            pixmapDirectory.insert(0, "pics/");
+        if (pixmapDirectory.right(1) != "/")
+            pixmapDirectory.append("/");
+    }
+
+    if (defGroup || cfg->hasKey("LifesPixmapName"))
+        fillStrList(lifesPixmapName,
+                    cfg->readEntry("LifesPixmapName", "lifes.xpm"), maxLevel+1);
+    if (defGroup || cfg->hasKey("LevelPixmapName"))
+        fillStrList(levelPixmapName,
+                    cfg->readEntry("LevelPixmapName", "level.xpm"), maxLevel+1);
+    APP_CONFIG_END( cfg );
+}
+
+void Status::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();
+
+    if (mode != -1) {
+        newgroup.sprintf("Mode %d", mode);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+    }
+
+    if (scheme != -1) {
+        newgroup.sprintf("Scheme %d", scheme);
+        cfg->setGroup(newgroup);
+
+        confMisc(FALSE);
+    }
+
+    fillPixmapName(lifesPixmapName);
+    fillPixmapName(levelPixmapName);
+
+    initPixmaps();
+
+    setFixedHeight(minHeight());
+
+    RESTORE_CONFIG_GROUP( cfg, oldgroup );
+    APP_CONFIG_END( cfg );
+}
+
+void Status::setScheme(int Scheme, int Mode)
+{
+    mode = Mode;
+    scheme = Scheme;
+
+    confScheme();
+
+    repaint();
+}
+
+int Status::minHeight()
+{
+    if (lifesPix->isEmpty() && levelPix->isEmpty())
+        return 0;
+    if (levelPix->isEmpty())
+        return lifesPix->at(0)->height();
+    if (lifesPix->isEmpty())
+        return levelPix->at(0)->height();
+    return (lifesPix->at(0)->height() > levelPix->at(0)->height()) ?
+            lifesPix->at(0)->height() : levelPix->at(0)->height();
+}
+
+int Status::minWidth()
+{
+    if (lifesPix->isEmpty() && levelPix->isEmpty())
+        return 0;
+    if (levelPix->isEmpty())
+        return lifesPix->at(0)->width();
+    if (lifesPix->isEmpty())
+        return levelPix->at(0)->width();
+    return (lifesPix->at(0)->width() > levelPix->at(0)->width()) ?
+            lifesPix->at(0)->width() : levelPix->at(0)->width();
+}
+
+void Status::setLifes(int lifes)
+{
+    actualLifes = lifes;
+    repaint();
+}
+
+void Status::setLevel(int Level)
+{
+    level = Level;
+
+    initPixmaps();
+
+    actualLevel = (level > (int) levelPix->count()) ? (int) levelPix->count() : level;
+    repaint();
+}
diff --git a/noncore/games/kpacman/status.h b/noncore/games/kpacman/status.h
new file mode 100644
index 0000000..4f69b02
--- a/dev/null
+++ b/noncore/games/kpacman/status.h
@@ -0,0 +1,78 @@
+#ifndef STATUS_H
+#define STATUS_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "portable.h"
+
+#if defined( KDE2_PORT )
+#include <kapp.h>
+#include <kconfig.h>
+#endif
+
+#include <qwidget.h>
+#include <qpixmap.h>
+#include <qstring.h>
+#include <qarray.h>
+#include <qlist.h>
+#include <qstrlist.h>
+#include <qregexp.h>
+
+class Status : public QWidget
+{
+    Q_OBJECT
+public:
+    Status(QWidget *parent=0, const char *name=0, int scheme=-1, int mode=-1);
+    ~Status() {};
+
+public slots:
+    void setScheme(int scheme, int mode);
+    void setLevel(int level);
+    void setLifes(int lifes);
+
+protected:
+    void  paintEvent(QPaintEvent *);
+    int minHeight();
+    int minWidth();
+
+    QString decodeHexOctString(QString str);
+
+    void fillArray(QArray<int> &, QString, int);
+    void fillStrList(QStrList &, QString, int);
+    void fillPixmapName(QStrList &);
+
+    void confScheme();
+    void confLevels(bool defGroup=TRUE);
+    void confMisc(bool defGroup=TRUE);
+
+    void initPixmaps();
+
+private:
+    QArray<int> levelPos;
+    int actualLifes;
+    int actualLevel;
+
+    QString pixmapDirectory;
+
+    QStrList lifesPixmapName;
+    QStrList levelPixmapName;
+
+    QString lastLifesPixmapName;
+    QString lastLevelPixmapName;
+
+    QList<QPixmap> *loadPixmap(QWidget *parent, QString pixmapName,
+                               QList<QPixmap> *pixmaps=0);
+
+    QList<QPixmap> *lifesPix;
+    QList<QPixmap> *levelPix;
+
+    int maxLevel;
+    int level;
+
+    int scheme;
+    int mode;
+};
+
+#endif // STATUS_H
diff --git a/pics/kpacman.png b/pics/kpacman.png
new file mode 100644
index 0000000..2c2d2e6
--- a/dev/null
+++ b/pics/kpacman.png
diff --git a/share/kpacman/fonts/font.xbm b/share/kpacman/fonts/font.xbm
new file mode 100644
index 0000000..5c7ffcd
--- a/dev/null
+++ b/share/kpacman/fonts/font.xbm
@@ -0,0 +1,140 @@
+#define font_small_width 128
+#define font_small_height 128
+static char font_small_bits[] = {
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x01,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x02,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x02,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x02,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x02,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x02,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3c,0x06,0x88,0x8e,0x9f,0x88,0x9f,
+ 0x9c,0x9f,0x8e,0x8c,0x39,0x63,0x00,0x00,0x00,0x42,0x09,0x4c,0x51,0x48,0x4c,
+ 0x41,0x42,0x50,0x51,0x52,0x85,0x94,0x00,0x00,0x00,0x99,0x09,0x48,0x51,0x44,
+ 0x4a,0x4f,0x42,0x48,0x51,0x52,0x85,0x94,0xf0,0x7c,0x1e,0x85,0x09,0x48,0x48,
+ 0x48,0x49,0x50,0x5e,0x48,0x4e,0x5e,0xbd,0x94,0x10,0x11,0x01,0x85,0x09,0x48,
+ 0x44,0x50,0x5f,0x50,0x52,0x44,0x51,0x50,0xa5,0x94,0xf0,0x10,0x0e,0x99,0x09,
+ 0x48,0x42,0x51,0x48,0x51,0x52,0x44,0x51,0x50,0xa5,0x94,0x10,0x10,0x10,0x42,
+ 0x06,0x9c,0x9f,0x8e,0x88,0x8e,0x8c,0x84,0x8e,0x8e,0x19,0x63,0x10,0x10,0x0f,
+ 0x3c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x38,0x36,0x14,0x08,0x42,0x04,0x0c,0x18,0x0c,0x08,0x00,0x00,
+ 0x00,0x00,0x40,0x00,0x38,0x36,0x3e,0x1c,0x25,0x0a,0x0c,0x0c,0x18,0x1c,0x08,
+ 0x00,0x00,0x00,0x20,0x00,0x1c,0x24,0x14,0x0a,0x12,0x04,0x08,0x0c,0x18,0x7f,
+ 0x08,0x00,0x00,0x00,0x10,0x00,0x0c,0x12,0x14,0x1c,0x08,0x2a,0x04,0x0c,0x18,
+ 0x3e,0x3e,0x0c,0x1c,0x00,0x08,0x00,0x04,0x00,0x3e,0x28,0x24,0x11,0x00,0x0c,
+ 0x18,0x1c,0x08,0x0c,0x00,0x00,0x04,0x00,0x00,0x00,0x14,0x1e,0x52,0x11,0x00,
+ 0x0c,0x18,0x3e,0x08,0x08,0x00,0x0c,0x02,0x00,0x02,0x00,0x14,0x08,0x21,0x2e,
+ 0x00,0x18,0x0c,0x22,0x00,0x04,0x00,0x0c,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1c,0x18,0x3e,0x7e,0x38,
+ 0x3f,0x3c,0x7f,0x1e,0x3e,0x00,0x00,0x30,0x00,0x06,0x1e,0x32,0x1c,0x63,0x30,
+ 0x3c,0x03,0x06,0x63,0x23,0x63,0x0c,0x0c,0x18,0x00,0x0c,0x33,0x63,0x18,0x70,
+ 0x18,0x36,0x3f,0x03,0x30,0x27,0x63,0x0c,0x0c,0x0c,0x3e,0x18,0x33,0x63,0x18,
+ 0x3c,0x3c,0x33,0x60,0x3f,0x18,0x1e,0x7e,0x00,0x00,0x06,0x00,0x30,0x18,0x63,
+ 0x18,0x1e,0x60,0x7f,0x60,0x63,0x0c,0x79,0x60,0x0c,0x0c,0x0c,0x3e,0x18,0x0c,
+ 0x26,0x18,0x07,0x63,0x30,0x63,0x63,0x0c,0x61,0x30,0x0c,0x08,0x18,0x00,0x0c,
+ 0x00,0x1c,0x7e,0x7f,0x3e,0x30,0x3e,0x3e,0x0c,0x3e,0x1e,0x00,0x04,0x30,0x00,
+ 0x06,0x0c,0x3c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x42,0x38,0x7e,0x78,0x3e,0xfc,0xfe,0xf8,0xc6,0xfc,0xf8,0xc6,
+ 0x0c,0xc6,0xc6,0x7c,0xa9,0x6c,0xc6,0xcc,0x66,0x0c,0x06,0x0c,0xc6,0x30,0x60,
+ 0x66,0x0c,0xee,0xce,0xc6,0x95,0xc6,0xc6,0x06,0xc6,0x0c,0x06,0x06,0xc6,0x30,
+ 0x60,0x36,0x0c,0xfe,0xde,0xc6,0x95,0xc6,0x7e,0x06,0xc6,0x7c,0x7e,0xe6,0xfe,
+ 0x30,0x60,0x1e,0x0c,0xfe,0xfe,0xc6,0x69,0xfe,0xc6,0x06,0xc6,0x0c,0x06,0xc6,
+ 0xc6,0x30,0x66,0x3e,0x0c,0xd6,0xf6,0xc6,0x02,0xc6,0xc6,0xcc,0x66,0x0c,0x06,
+ 0xcc,0xc6,0x30,0x66,0x76,0x0c,0xc6,0xe6,0xc6,0x3c,0xc6,0x7e,0x78,0x3e,0xfc,
+ 0x06,0xf8,0xc6,0xfc,0x3c,0xe6,0xfc,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7e,0x7c,0x7e,0x3c,
+ 0xfc,0xc6,0xc6,0xc6,0xc6,0xcc,0xfe,0x3c,0x02,0x3c,0x10,0x00,0xc6,0xc6,0xc6,
+ 0x66,0x30,0xc6,0xc6,0xc6,0xee,0xcc,0xe0,0x0c,0x04,0x30,0x38,0x00,0xc6,0xc6,
+ 0xc6,0x06,0x30,0xc6,0xc6,0xd6,0x78,0xcc,0x70,0x0c,0x08,0x30,0x6c,0x00,0xc6,
+ 0xc6,0xe6,0x7c,0x30,0xc6,0xee,0xfe,0x38,0x78,0x38,0x0c,0x10,0x30,0x00,0x00,
+ 0x7e,0xd6,0x3e,0xc0,0x30,0xc6,0x7c,0xfe,0x7c,0x30,0x1c,0x0c,0x20,0x30,0x00,
+ 0x00,0x06,0x66,0x76,0xc6,0x30,0xc6,0x38,0xee,0xee,0x30,0x0e,0x0c,0x40,0x30,
+ 0x00,0x00,0x06,0xdc,0xe6,0x7c,0x30,0x7c,0x10,0xc6,0xc6,0x30,0xfe,0x3c,0x80,
+ 0x3c,0x00,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x10,0x38,0x7e,0x78,0x3e,0xfc,0xfe,0xf8,0xc6,0xfc,0xf8,
+ 0xc6,0x0c,0xc6,0xc6,0x7c,0x18,0x6c,0xc6,0xcc,0x66,0x0c,0x06,0x0c,0xc6,0x30,
+ 0x60,0x66,0x0c,0xee,0xce,0xc6,0x18,0xc6,0xc6,0x06,0xc6,0x0c,0x06,0x06,0xc6,
+ 0x30,0x60,0x36,0x0c,0xfe,0xde,0xc6,0x00,0xc6,0x7e,0x06,0xc6,0x7c,0x7e,0xe6,
+ 0xfe,0x30,0x60,0x1e,0x0c,0xfe,0xfe,0xc6,0x00,0xfe,0xc6,0x06,0xc6,0x0c,0x06,
+ 0xc6,0xc6,0x30,0x66,0x3e,0x0c,0xd6,0xf6,0xc6,0x00,0xc6,0xc6,0xcc,0x66,0x0c,
+ 0x06,0xcc,0xc6,0x30,0x66,0x76,0x0c,0xc6,0xe6,0xc6,0x00,0xc6,0x7e,0x78,0x3e,
+ 0xfc,0x06,0xf8,0xc6,0xfc,0x3c,0xe6,0xfc,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7e,0x7c,0x7e,
+ 0x3c,0xfc,0xc6,0xc6,0xc6,0xc6,0xcc,0xfe,0x38,0x18,0x1c,0x4c,0x00,0xc6,0xc6,
+ 0xc6,0x66,0x30,0xc6,0xc6,0xc6,0xee,0xcc,0xe0,0x18,0x18,0x18,0x7e,0x00,0xc6,
+ 0xc6,0xc6,0x06,0x30,0xc6,0xc6,0xd6,0x78,0xcc,0x70,0x18,0x18,0x18,0x32,0x00,
+ 0xc6,0xc6,0xe6,0x7c,0x30,0xc6,0xee,0xfe,0x38,0x78,0x38,0x0c,0x18,0x30,0x00,
+ 0x00,0x7e,0xd6,0x3e,0xc0,0x30,0xc6,0x7c,0xfe,0x7c,0x30,0x1c,0x18,0x18,0x18,
+ 0x00,0x00,0x06,0x66,0x76,0xc6,0x30,0xc6,0x38,0xee,0xee,0x30,0x0e,0x18,0x18,
+ 0x18,0x00,0x00,0x06,0xdc,0xe6,0x7c,0x30,0x7c,0x10,0xc6,0xc6,0x30,0xfe,0x38,
+ 0x18,0x1c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3c,
+ 0x00,0x00,0x00,0x00,0x3c,0x00,0x00,0x0c,0x20,0x3c,0x00,0xcc,0x18,0x38,0x14,
+ 0x42,0x1c,0x00,0x00,0x00,0x42,0x3c,0x00,0x08,0x38,0x04,0x24,0xcc,0x18,0x08,
+ 0x00,0x99,0x20,0x00,0x00,0x00,0x99,0x00,0x00,0x00,0x54,0x1e,0x18,0x78,0x18,
+ 0x34,0x00,0x85,0x3c,0x48,0x00,0x00,0xa9,0x00,0x00,0x08,0x14,0x04,0x24,0xfc,
+ 0x00,0x44,0x00,0x85,0x24,0x24,0x7c,0x7c,0x99,0x00,0x00,0x0c,0x54,0x04,0x18,
+ 0x30,0x18,0x38,0x00,0x99,0x38,0x48,0x60,0x00,0xa9,0x00,0x00,0x0c,0x38,0x2e,
+ 0x24,0xfc,0x18,0x24,0x00,0x42,0x00,0x00,0x60,0x00,0x42,0x00,0x00,0x0c,0x08,
+ 0x3a,0x00,0x30,0x18,0x18,0x00,0x3c,0x7c,0x00,0x00,0x00,0x3c,0x00,0x00,0x00,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,
+ 0x10,0x18,0x38,0x10,0x00,0x7e,0x00,0x00,0x10,0x30,0x00,0x44,0x24,0x46,0x30,
+ 0x24,0x10,0x20,0x10,0x18,0x66,0x6e,0x00,0x00,0x18,0x48,0x00,0xa6,0x26,0xa4,
+ 0x00,0x18,0x7c,0x10,0x20,0x08,0x66,0x6e,0x10,0x00,0x10,0x30,0x24,0xe4,0x74,
+ 0xe8,0x30,0x00,0x10,0x38,0x38,0x00,0x66,0x68,0x38,0x00,0x10,0x00,0x48,0xd4,
+ 0x94,0xde,0x18,0x00,0x10,0x00,0x00,0x00,0x7e,0x68,0x10,0x00,0x00,0x78,0x24,
+ 0xf0,0x88,0xf0,0xcc,0x00,0x00,0x00,0x00,0x00,0x06,0x68,0x00,0x30,0x00,0x00,
+ 0x00,0x88,0x48,0x88,0xcc,0x00,0x7c,0x00,0x00,0x00,0x06,0x68,0x00,0x00,0x00,
+ 0x00,0x00,0x88,0xe4,0x88,0x78,0x1c,0x70,0x10,0x58,0x28,0x10,0x00,0x00,0x38,
+ 0x70,0x10,0x28,0x18,0x60,0x10,0x28,0x00,0x00,0x00,0x24,0x00,0x28,0x00,0x3c,
+ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x38,0x38,0x38,0x38,0x38,0xfc,
+ 0x66,0xfc,0xfc,0xfc,0xfc,0x78,0x78,0x78,0x78,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,
+ 0x36,0x03,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,0xc6,0xc6,0xc6,0xc6,
+ 0xc6,0x7e,0x03,0x7c,0x7c,0x7c,0x7c,0x30,0x30,0x30,0x30,0xfe,0xfe,0xfe,0xfe,
+ 0xfe,0xfe,0x36,0x66,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,0xc6,0xc6,
+ 0xc6,0xc6,0xc6,0x36,0x3c,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,0xc6,
+ 0xc6,0xc6,0xc6,0xc6,0xf6,0x10,0xfc,0xfc,0xfc,0xfc,0x78,0x78,0x78,0x78,0x00,
+ 0x58,0x1c,0x70,0x10,0x58,0x28,0x00,0x00,0x1c,0x70,0x10,0x28,0xe0,0x00,0x00,
+ 0x3c,0x24,0x00,0x00,0x00,0x24,0x00,0x00,0x7c,0x00,0x00,0x00,0x00,0x00,0x04,
+ 0x18,0x6c,0xce,0x7c,0x7c,0x7c,0x7c,0x7c,0x00,0xe6,0xc6,0xc6,0xc6,0xc6,0xcc,
+ 0x3c,0x2c,0xcc,0xde,0xc6,0xc6,0xc6,0xc6,0xc6,0x24,0xf6,0xc6,0xc6,0xc6,0xc6,
+ 0xcc,0x24,0x3c,0xde,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x18,0xde,0xc6,0xc6,0xc6,
+ 0xc6,0x78,0x24,0x6c,0xcc,0xf6,0xc6,0xc6,0xc6,0xc6,0xc6,0x24,0xce,0xc6,0xc6,
+ 0xc6,0xc6,0x30,0x3c,0x6c,0x6c,0xe6,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0xc6,0xc6,
+ 0xc6,0xc6,0xc6,0x30,0x04,0x3c,0x3c,0xc6,0x7c,0x7c,0x7c,0x7c,0x7c,0x00,0x7c,
+ 0x7c,0x7c,0x7c,0x7c,0x30,0x00,0x0c,0x1c,0x70,0x10,0x58,0x28,0x10,0x00,0x00,
+ 0x38,0x70,0x10,0x28,0x18,0x60,0x10,0x28,0x00,0x00,0x00,0x24,0x00,0x28,0x00,
+ 0x3c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x38,0x38,0x38,0x38,0x38,
+ 0xfc,0x66,0xfc,0xfc,0xfc,0xfc,0x78,0x78,0x78,0x78,0x6c,0x6c,0x6c,0x6c,0x6c,
+ 0x6c,0x36,0x03,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,0xc6,0xc6,0xc6,
+ 0xc6,0xc6,0x7e,0x03,0x7c,0x7c,0x7c,0x7c,0x30,0x30,0x30,0x30,0xfe,0xfe,0xfe,
+ 0xfe,0xfe,0xfe,0x36,0x66,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,0xc6,
+ 0xc6,0xc6,0xc6,0xc6,0x36,0x3c,0x0c,0x0c,0x0c,0x0c,0x30,0x30,0x30,0x30,0xc6,
+ 0xc6,0xc6,0xc6,0xc6,0xc6,0xf6,0x10,0xfc,0xfc,0xfc,0xfc,0x78,0x78,0x78,0x78,
+ 0x00,0x58,0x1c,0x70,0x10,0x58,0x28,0x00,0x00,0x1c,0x70,0x10,0x28,0xe0,0x00,
+ 0x14,0x3c,0x24,0x00,0x00,0x00,0x24,0x00,0x00,0x7c,0x00,0x00,0x00,0x00,0x00,
+ 0x04,0x00,0x6c,0xce,0x7c,0x7c,0x7c,0x7c,0x7c,0x10,0xe6,0xc6,0xc6,0xc6,0xc6,
+ 0xcc,0x1c,0x66,0xcc,0xde,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0xf6,0xc6,0xc6,0xc6,
+ 0xc6,0xcc,0x24,0x66,0xde,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0xde,0xc6,0xc6,
+ 0xc6,0xc6,0x78,0x24,0x3c,0xcc,0xf6,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0xce,0xc6,
+ 0xc6,0xc6,0xc6,0x30,0x1c,0x18,0x6c,0xe6,0xc6,0xc6,0xc6,0xc6,0xc6,0x10,0xc6,
+ 0xc6,0xc6,0xc6,0xc6,0x30,0x04,0x18,0x3c,0xc6,0x7c,0x7c,0x7c,0x7c,0x7c,0x00,
+ 0x7c,0x7c,0x7c,0x7c,0x7c,0x30,0x04,0x18};
diff --git a/share/kpacman/kpacman.conf b/share/kpacman/kpacman.conf
new file mode 100644
index 0000000..baa767d
--- a/dev/null
+++ b/share/kpacman/kpacman.conf
@@ -0,0 +1,71 @@
+[Default]
+FocusInContinue=true
+FocusOutPause=true
+HideMouseCursor=false
+LevelPixmapName=fruit.xpm
+Mode=0
+ModeCount=2
+Scheme=1
+SchemeCount=5
+downKey=Down
+leftKey=Left
+rightKey=Right
+upKey=Up
+
+[Mode 0]
+Description=&Pacman
+
+[Mode 1]
+Description=&Ms.Pacman
+DyingAnimationMS=150
+EnergizerPixmapName=switch.xpm,,,switch02.xpm,,,switch03.xpm,,,,switch.xpm,,,,,,,,,,,,switch03.xpm,,,,switch.xpm
+ExtraLifeScore=-10000,-30000,-50000,30000
+FruitScore=100,200,500,700,1000,2000,5000
+FruitScorePixmapName=fruitscore.xpm
+LevelPosition=0,1,2,3,4,5,6
+Levels=29
+MapDirectory=mspacman
+MapName=map01,,,map02,,,map03,,,,map04,,,,map03,,,,map04,,,,map03,,,,map04
+PointPixmapName=point.xpm,,,point02.xpm,,,point03.xpm,,,,point.xpm,,,,,,,,,,,,point03.xpm,,,,point.xpm
+PrisonPixmapName=prison.xpm,,,prison02.xpm,,,prison03.xpm,,,,prison04.xpm,,,,prison05.xpm,,,,prison06.xpm,,,,prison03.xpm,,,,prison04.xpm
+WallPixmapName=wall.xpm,,,wall02.xpm,,,wall03.xpm,,,,wall04.xpm,,,,wall05.xpm,,,,wall06.xpm,,,,wall03.xpm,,,,wall04.xpm
+
+[Scheme 0]
+Description=&MIDWAY MFG.CO.
+Description[de]=&MIDWAY MFG.CO.
+Font=font-smooth.xbm
+Mode=0
+PixmapDirectory=
+
+[Scheme 1]
+Description=MIDWAY MFG.CO. (&tiny)
+Description[de]=MIDWAY MFG.CO. (&klein)
+Font=font-small.xbm
+Mode=0
+PixmapDirectory=tiny
+
+[Scheme 2]
+Description=K&Zacman (incomplete)
+Description[de]=K&Zacman (unvollständig)
+Font=font-smooth.xbm
+FruitPixmapName=../fruit.xpm
+LevelPixmapName=../fruit.xpm
+PixmapDirectory=zacman
+PrisonPixmapName=../prison.xpm
+
+[Scheme 3]
+Description=&MIDWAY MFG.CO.
+EyesPixmapName=../eyes.xpm
+Font=font-smooth.xbm
+Mode=1
+MonsterPixmapName=../monster.xpm
+PixmapDirectory=mspacman
+
+[Scheme 4]
+Description=MIDWAY MFG.CO. (&tiny)
+Description[de]=MIDWAY MFG.CO. (&klein)
+EyesPixmapName=../tiny/eyes.xpm
+Font=font-small.xbm
+Mode=1
+MonsterPixmapName=../tiny/monster.xpm
+PixmapDirectory=mspacman-tiny
diff --git a/share/kpacman/pics/down.xpm b/share/kpacman/pics/down.xpm
new file mode 100644
index 0000000..66d169d
--- a/dev/null
+++ b/share/kpacman/pics/down.xpm
@@ -0,0 +1,29 @@
+/* XPM */
+static char * d_xpm[] = {
+/* width height num_colors chars_per_pixel */
+"20 20 3 1",
+/* colors */
+" 	s None	c None",
+".	c #000000",
+"X	c #008080",
+/* pixels */
+"                    ",
+"                    ",
+"                    ",
+"   ..............   ",
+"   .XXXXXXXXXXXX.   ",
+"    .XXXXXXXXXX.    ",
+"    .XXXXXXXXXX.    ",
+"     .XXXXXXXX.     ",
+"     .XXXXXXXX.     ",
+"      .XXXXXX.      ",
+"      .XXXXXX.      ",
+"       .XXXX.       ",
+"       .XXXX.       ",
+"        .XX.        ",
+"        .XX.        ",
+"         ..         ",
+"         ..         ",
+"                    ",
+"                    ",
+"                    "};
diff --git a/share/kpacman/pics/dying.xpm b/share/kpacman/pics/dying.xpm
new file mode 100644
index 0000000..5d33fa9
--- a/dev/null
+++ b/share/kpacman/pics/dying.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char *dying[]={
+"176 16 2 1",
+". c None",
+"# c #ffff00",
+"................................................................................................................................................................................",
+"................................................................................................................................................................................",
+"................................................................................................................................................................................",
+"..##.........##.................................................................................................................................................................",
+"..###.......###...#...........#.................................................................................................................................................",
+"..####.....####..####.......####................................................................................................................................................",
+"..#####...#####..#####.....#####.###.........###......................................................................................................................#...#.....",
+"..######.######..#######.#######.######...######.####.......####....................................................................................................#..#.#......",
+"...###########....#############..###############.###############.....#######...........###..............#...............#...............#...............#............#......#...",
+"...###########....#############...#############..###############.###############.....#######...........###.............###..............#...............#..................#....",
+"....#########......###########.....###########....#############..###############..#############......#######..........#####............###..............#..........##...........",
+"......#####..........###.###.........###.###........####.####.....#############..###############....#########.........#####............###..............#...................##..",
+"....................................................................####.####.....######.######...#############......#######...........###..............#............#..........",
+"....................................................................................###...###.....######.######.....#########.........#####.............#...........#......#....",
+"...................................................................................................####...####.......###.###...........#.#.............................#.#..#...",
+"......................................................................................................................................................................#...#....."};
diff --git a/share/kpacman/pics/eyes.xpm b/share/kpacman/pics/eyes.xpm
new file mode 100644
index 0000000..9e7cfc3
--- a/dev/null
+++ b/share/kpacman/pics/eyes.xpm
@@ -0,0 +1,22 @@
+/* XPM */
+static char * eyes_xpm[] = {
+"64 16 3 1",
+" 	c None",
+"b	c #2020d8",
+"w	c #dedede",
+"                                                                ",
+"                                                                ",
+"    bb    bb                                                    ",
+"   wbbw  wbbw                                                   ",
+"   wwww  wwww        ww    ww                      ww    ww     ",
+"   wwww  wwww       wwww  wwww      ww    ww      wwww  wwww    ",
+"    ww    ww        wwbb  wwbb     wwww  wwww     bbww  bbww    ",
+"                    wwbb  wwbb     wwww  wwww     bbww  bbww    ",
+"                     ww    ww      wbbw  wbbw      ww    ww     ",
+"                                    bb    bb                    ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                "};
diff --git a/share/kpacman/pics/fruit.xpm b/share/kpacman/pics/fruit.xpm
new file mode 100644
index 0000000..4d0ea1f
--- a/dev/null
+++ b/share/kpacman/pics/fruit.xpm
@@ -0,0 +1,32 @@
+/* XPM */
+static char * fruit_small_xpm[] = {
+/* width height num_colors chars_per_pixel */
+"208 16 10 1",
+/* colors */
+" 	s None	c None",
+"x	c #000000",
+"r	c #ff0000",
+"n      c #de9541",
+"u      c #41bade",
+"o      c #ffba41",
+"y	c #ffff00",
+"b	c #2020de",
+"g      c #00ff00",
+"w      c #dedede",
+/* pixels */
+"                                                                                                                                                                                                                ",
+"                                                                                                     e               e                                                                                          ",
+"            nn         w                 gg              gg             n               n             eeeee           eeeee                                            yy              yy              bbb      ",
+"          nnnn      gggwggg            nggggg          nggggg      rrr n rrr       rrr n rrr            e               e               r               r            yyxxyy          yyxxyy          bb   bb    ",
+"        nn n       rrgggggrr           n ggg           n ggg      rrrrrnrrrrr     rrrrrnrrrrr          gbg             gbg         b   rrr   b     b   rrr   b      yyyyyyyy        yyyyyyyy         bbbbbbb    ",
+"       n   n      rrrrrgrrrwr       oonnnooo        oonnnooo      rrrrrrrrrrrr    rrrrrrrrrrrr       gggyggg         gggyggg       b  rrrrr  b     b  rrrrr  b      yyxyyyyy        yyxyyyyy         bbbbbbb    ",
+"   rrrn   n       rwrrrrrwrrr      oooonooooo      oooonooooo     rrrrrrrrrrrr    rrrrrrrrrrrr      gybygggyg       gybygggyg      byrryryrryb     byrryryrryb      yxyyyyyy        yxyyyyyy         bbbbbbb    ",
+"  rrrnrr n        rrrwrwrrrrr     oooooooooooo    oooooooooooo    rrrrrrrrrrrr    rrrrrrrrrrrr      ggyggbygg       ggyggbygg      byyyyryyyyb     byyyyryyyyb     yyxyyyyyyy      yyxyyyyyyy          y y      ",
+"  rrrrr rnrr      rrrrrrrrwrr     oooooooooooo    oooooooooooo    rrrrrrrrrwrr    rrrrrrrrrwrr     gbygggygygg     gbygggygygg     bbyyyyyyybb     bbyyyyyyybb     yyxyyyyyyy      yyxyyyyyyy          y yy     ",
+"  rwrr rrnrrr      rwrrwrrrr      oooooooooooo    oooooooooooo    rrrrrrrrrwrr    rrrrrrrrrwrr     gyggbyggbyg     gyggbyggbyg      bby y ybb       bby y ybb      yyyyyyyyyy      yyyyyyyyyy          y y      ",
+"  rrwr rrrrrr      rrrrrrrrr      oooooooooooo    oooooooooooo     rrrrrrrwrr      rrrrrrrwrr      gbygggygggg     gbygggygggg       bb y bb         bb y bb      yyxyyyyyyyyy    yyxyyyyyyyyy         y        ",
+"   rrr rwrrrr       rrwrrw         oooooooooo      oooooooooo      rrrrrrrrrr      rrrrrrrrrr       ggybybygg       ggybybygg         b y b           b y b       yyxyyyyyyyyy    yyxyyyyyyyyy         y y      ",
+"       rrwrrr        rrrrr         oooooooooo      oooooooooo       rrrrrrrr        rrrrrrrr        gggygggyg       gggygggyg           y               y         yyyyyyyyyyyy    yyyyyyyyyyyy         y yy     ",
+"        rrrr           r             oooooo          oooooo          rr rrr          rr rrr          gygggyg         gygggyg            y               y         yeeeeewweeey    yeeeeewweeey         y y      ",
+"                                                                                                       ggy             ggy                                         eeeeewweee      eeeeewweee           y       ",
+"                                                                                                                                                                                                                "};
diff --git a/share/kpacman/pics/left.xpm b/share/kpacman/pics/left.xpm
new file mode 100644
index 0000000..8d39ed6
--- a/dev/null
+++ b/share/kpacman/pics/left.xpm
@@ -0,0 +1,29 @@
+/* XPM */
+static char * l_xpm[] = {
+/* width height num_colors chars_per_pixel */
+"20 20 3 1",
+/* colors */
+" 	s None	c None",
+".	c #000000",
+"X	c #008080",
+/* pixels */
+"                    ",
+"                    ",
+"                    ",
+"               ..   ",
+"             ..X.   ",
+"           ..XXX.   ",
+"         ..XXXXX.   ",
+"       ..XXXXXXX.   ",
+"     ..XXXXXXXXX.   ",
+"   ..XXXXXXXXXXX.   ",
+"   ..XXXXXXXXXXX.   ",
+"     ..XXXXXXXXX.   ",
+"       ..XXXXXXX.   ",
+"         ..XXXXX.   ",
+"           ..XXX.   ",
+"             ..X.   ",
+"               ..   ",
+"                    ",
+"                    ",
+"                    "};
diff --git a/share/kpacman/pics/lifes.xpm b/share/kpacman/pics/lifes.xpm
new file mode 100644
index 0000000..0248284
--- a/dev/null
+++ b/share/kpacman/pics/lifes.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * lifes_xpm[] = {
+"16 16 2 1",
+" 	s None  c None",
+"y	c #ffff00",
+"                ",
+"                ",
+"     yyyyy      ",
+"    yyyyyyy     ",
+"   yyyyyyyyy    ",
+"     yyyyyyyy   ",
+"       yyyyyy   ",
+"         yyyy   ",
+"       yyyyyy   ",
+"     yyyyyyyy   ",
+"   yyyyyyyyy    ",
+"    yyyyyyy     ",
+"     yyyyy      ",
+"                ",
+"                ",
+"                "};
diff --git a/share/kpacman/pics/monster.xpm b/share/kpacman/pics/monster.xpm
new file mode 100644
index 0000000..911a950
--- a/dev/null
+++ b/share/kpacman/pics/monster.xpm
@@ -0,0 +1,28 @@
+/* XPM */
+static char * monster_xpm[] = {
+"320 16 8 1",
+/* colors */
+" 	s None	c None",
+"r	c #ff0000",
+"p      c #ffbade",
+"c      c #00ffde",
+"o      c #ffba41",
+"b	c #2020de",
+"f      c #ffba94",
+"w      c #dedede",
+"                                                                                                                                                                                                                                                                                                                                ",
+"      rrrr            rrrr            pppp            pppp            cccc            cccc            oooo            oooo            rrrr            rrrr            rrrr            rrrr            rrrr            rrrr            rrrr            rrrr            bbbb            bbbb            wwww            wwww      ",
+"    rrrrrrrr        rrrrrrrr        pppppppp        pppppppp        cccccccc        cccccccc        oooooooo        oooooooo        rrrrrrrr        rrrrrrrr        rrrrrrrr        rrrrrrrr        rrrrrrrr        rrrrrrrr        rrrrrrrr        rrrrrrrr        bbbbbbbb        bbbbbbbb        wwwwwwww        wwwwwwww    ",
+"   rrrrrrrrrr      rrrrrrrrrr      pppppppppp      pppppppppp      cccccccccc      cccccccccc      oooooooooo      oooooooooo      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      rrrrrrrrrr      bbbbbbbbbb      bbbbbbbbbb      wwwwwwwwww      wwwwwwwwww   ",
+"  rrrrrrrrrrrr    rrrrrrrrrrrr    pppppppppppp    pppppppppppp    cccccccccccc    cccccccccccc    oooooooooooo    oooooooooooo    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    bbbbbbbbbbbb    bbbbbbbbbbbb    wwwwwwwwwwww    wwwwwwwwwwww  ",
+"  rrrrrrrrrrrr    rrrrrrrrrrrr    pppppppppppp    pppppppppppp    cccccccccccc    cccccccccccc    oooooooooooo    oooooooooooo    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    bbbbbbbbbbbb    bbbbbbbbbbbb    wwwwwwwwwwww    wwwwwwwwwwww  ",
+"  rrrrrrrrrrrr    rrrrrrrrrrrr    pppppppppppp    pppppppppppp    cccccccccccc    cccccccccccc    oooooooooooo    oooooooooooo    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    rrrrrrrrrrrr    bbbffbbffbbb    bbbffbbffbbb    wwwrrwwrrwww    wwwrrwwrrwww  ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bbbbffbbffbbbb  bbbbffbbffbbbb  wwwwrrwwrrwwww  wwwwrrwwrrwwww ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bbbbbbbbbbbbbb  bbbbbbbbbbbbbb  wwwwwwwwwwwwww  wwwwwwwwwwwwww ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bbbbbbbbbbbbbb  bbbbbbbbbbbbbb  wwwwwwwwwwwwww  wwwwwwwwwwwwww ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bbffbbffbbffbb  bbffbbffbbffbb  wwrrwwrrwwrrww  wwrrwwrrwwrrww ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bfbbffbbffbbfb  bfbbffbbffbbfb  wrwwrrwwrrwwrw  wrwwrrwwrrwwrw ",
+" rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  pppppppppppppp  pppppppppppppp  cccccccccccccc  cccccccccccccc  oooooooooooooo  oooooooooooooo  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  rrrrrrrrrrrrrr  bbbbbbbbbbbbbb  bbbbbbbbbbbbbb  wwwwwwwwwwwwww  wwwwwwwwwwwwww ",
+" rr rrr  rrr rr  rrrr rrrr rrrr  pp ppp  ppp pp  pppp pppp pppp  cc ccc  ccc cc  cccc cccc cccc  oo ooo  ooo oo  oooo oooo oooo  rr rrr  rrr rr  rrrr rrrr rrrr  rr rrr  rrr rr  rrrr rrrr rrrr  rr rrr  rrr rr  rrrr rrrr rrrr  rr rrr  rrr rr  rrrr rrrr rrrr  bb bbb  bbb bb  bbbb bbbb bbbb  ww www  www ww  wwww wwww wwww ",
+" r   rr  rr   r   rr   rr   rr   p   pp  pp   p   pp   pp   pp   c   cc  cc   c   cc   cc   cc   o   oo  oo   o   oo   oo   oo   r   rr  rr   r   rr   rr   rr   r   rr  rr   r   rr   rr   rr   r   rr  rr   r   rr   rr   rr   r   rr  rr   r   rr   rr   rr   b   bb  bb   b   bb   bb   bb   w   ww  ww   w   ww   ww   ww  ",
+"                                                                                                                                                                                                                                                                                                                                "};
diff --git a/share/kpacman/pics/pacman.xpm b/share/kpacman/pics/pacman.xpm
new file mode 100644
index 0000000..2aa037b
--- a/dev/null
+++ b/share/kpacman/pics/pacman.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static char * pacman_xpm[] = {
+"192 16 2 1",
+" 	s None  c None",
+"y	c #ffff00",
+"                                                                                                                                                                                                ",
+"     yyyyy                                            yyyyy           yyyyy           yyyyy                                                          yyyyy           yyyyy           yyyyy      ",
+"   yyyyyyyyy       yy     yy                        yyyyyyyyy       yyyyyyyyy       yyyyyyy          yyyyy           yyyyy           yyyyy         yyyyyyyyy       yyyyyyyyy         yyyyyyy    ",
+"  yyyyyyyyyyy     yyy     yyy                      yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyy         yyyyyyyyy       yyyyyyyyy       yyyyyyyyy      yyyyyyyyyyy     yyyyyyyyyyy         yyyyyyy   ",
+"  yyyyyyyyyyy     yyyy   yyyy                      yyyyyyyyyyy     yyyyyyyyyyy     yyyyyy         yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy          yyyyyy   ",
+" yyyyyyyyyyyyy   yyyyy   yyyyy   yy         yy    yyyyyyyyyyyyy   yyyyyyyyyy      yyyyyy          yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy    yyyyyyyyyyyyy      yyyyyyyyyy          yyyyyy  ",
+" yyyyyyyyyyyyy   yyyyy   yyyyy   yyy       yyy    yyyyyyyyyyyyy   yyyyyyy         yyyyy          yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyyyy yyyyyy   yyyyyyyyyyyyy         yyyyyyy           yyyyy  ",
+" yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyy     yyyy    yyyyyyyyyyyyy   yyyy            yyyy           yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyyy   yyyyy   yyyyyyyyyyyyy            yyyy            yyyy  ",
+" yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyyy   yyyyy    yyyyyyyyyyyyy   yyyyyyy         yyyyy          yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyy     yyyy   yyyyyyyyyyyyy         yyyyyyy           yyyyy  ",
+" yyyyyyyyyyyyy   yyyyyy yyyyyy   yyyyyy yyyyyy    yyyyyyyyyyyyy   yyyyyyyyyy      yyyyyy         yyyyyyyyyyyyy   yyyyy   yyyyy   yyy       yyy   yyyyyyyyyyyyy      yyyyyyyyyy          yyyyyy  ",
+"  yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy      yyyyyyyyyyy     yyyyyyyyyyy     yyyyyy        yyyyyyyyyyyyy   yyyyy   yyyyy   yy         yy    yyyyyyyyyyy     yyyyyyyyyyy          yyyyyy   ",
+"  yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyyyyyy      yyyyyyyyyyy     yyyyyyyyyyy     yyyyyyy        yyyyyyyyyyy     yyyy   yyyy                     yyyyyyyyyyy     yyyyyyyyyyy         yyyyyyy   ",
+"   yyyyyyyyy       yyyyyyyyy       yyyyyyyyy        yyyyyyyyy       yyyyyyyyy       yyyyyyy       yyyyyyyyyyy     yyy     yyy                      yyyyyyyyy       yyyyyyyyy         yyyyyyy    ",
+"     yyyyy           yyyyy           yyyyy            yyyyy           yyyyy           yyyyy        yyyyyyyyy       yy     yy                         yyyyy           yyyyy           yyyyy      ",
+"                                                                                                     yyyyy                                                                                      ",
+"                                                                                                                                                                                                "};
diff --git a/share/kpacman/pics/point.xpm b/share/kpacman/pics/point.xpm
new file mode 100644
index 0000000..36c3c9e
--- a/dev/null
+++ b/share/kpacman/pics/point.xpm
@@ -0,0 +1,9 @@
+/* XPM */
+static char * point_xpm[] = {
+"4 4 2 1",
+" 	c None",
+"f	c #ffba94",
+"    ",
+" ff ",
+" ff ",
+"    "};
diff --git a/share/kpacman/pics/prison.xpm b/share/kpacman/pics/prison.xpm
new file mode 100644
index 0000000..38cbb58
--- a/dev/null
+++ b/share/kpacman/pics/prison.xpm
@@ -0,0 +1,10 @@
+/* XPM */
+static char * prison_xpm[] = {
+"72 4 3 1",
+" 	s None	c None",
+"p	c #ffbade",
+"b	c #2020de",
+"  b  b                    b  b           b    b         ppb  bpp    pppp",
+"  b  b      bbbb          bbbb   bbbbbb  b    b           bbbb          ",
+"  b  b  bbbb      bbbb           b    b  bbbbbb   bbbb                  ",
+"  b  b            b  b           b    b         ppb  bpp        pppp    "};
diff --git a/share/kpacman/pics/right.xpm b/share/kpacman/pics/right.xpm
new file mode 100644
index 0000000..d36e84a
--- a/dev/null
+++ b/share/kpacman/pics/right.xpm
@@ -0,0 +1,29 @@
+/* XPM */
+static char * r_xpm[] = {
+/* width height num_colors chars_per_pixel */
+"20 20 3 1",
+/* colors */
+" 	s None	c None",
+".	c #000000",
+"X	c #008080",
+/* pixels */
+"                    ",
+"                    ",
+"                    ",
+"   ..               ",
+"   .X..             ",
+"   .XXX..           ",
+"   .XXXXX..         ",
+"   .XXXXXXX..       ",
+"   .XXXXXXXXX..     ",
+"   .XXXXXXXXXXX..   ",
+"   .XXXXXXXXXXX..   ",
+"   .XXXXXXXXX..     ",
+"   .XXXXXXX..       ",
+"   .XXXXX..         ",
+"   .XXX..           ",
+"   .X..             ",
+"   ..               ",
+"                    ",
+"                    ",
+"                    "};
diff --git a/share/kpacman/pics/switch.xpm b/share/kpacman/pics/switch.xpm
new file mode 100644
index 0000000..fbc7a69
--- a/dev/null
+++ b/share/kpacman/pics/switch.xpm
@@ -0,0 +1,13 @@
+/* XPM */
+static char * switch_xpm[] = {
+"16 8 2 1",
+" 	s None	c None",
+"f	c #ffba94",
+"  ffff          ",
+" ffffff         ",
+"ffffffff        ",
+"ffffffff        ",
+"ffffffff        ",
+"ffffffff        ",
+" ffffff         ",
+"  ffff          "};
diff --git a/share/kpacman/pics/up.xpm b/share/kpacman/pics/up.xpm
new file mode 100644
index 0000000..28974c3
--- a/dev/null
+++ b/share/kpacman/pics/up.xpm
@@ -0,0 +1,29 @@
+/* XPM */
+static char * u_xpm[] = {
+/* width height num_colors chars_per_pixel */
+"20 20 3 1",
+/* colors */
+" 	s None	c None",
+".	c #000000",
+"X	c #008080",
+/* pixels */
+"                    ",
+"                    ",
+"                    ",
+"         ..         ",
+"         ..         ",
+"        .XX.        ",
+"        .XX.        ",
+"       .XXXX.       ",
+"       .XXXX.       ",
+"      .XXXXXX.      ",
+"      .XXXXXX.      ",
+"     .XXXXXXXX.     ",
+"     .XXXXXXXX.     ",
+"    .XXXXXXXXXX.    ",
+"    .XXXXXXXXXX.    ",
+"   .XXXXXXXXXXXX.   ",
+"   ..............   ",
+"                    ",
+"                    ",
+"                    "};
diff --git a/share/kpacman/pics/wall.xpm b/share/kpacman/pics/wall.xpm
new file mode 100644
index 0000000..7cd0ffb
--- a/dev/null
+++ b/share/kpacman/pics/wall.xpm
@@ -0,0 +1,9 @@
+/* XPM */
+static char * wall_xpm[] = {
+"112 4 2 1",
+" 	s None	c None",
+"b	c #2020de",
+"  b  b                     bb            b    b    bb     b  b  bb    bb             b    b                     ",
+"  b  b      bbbb                   bb     b  b     bb     b  b    bbbb          bb   b    b   bb      bbbb      ",
+"  b  b  bbbb                      b  b     bb     b  b     bb             bbbb    b   bbbb   b    bb        bb  ",
+"  b  b             bb            b    b           b  b     bb           bb    bb  b          b                  "};