Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegames@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

30 files changed, 3860 insertions, 0 deletions

diff --git a/kjumpingcube/AUTHORS b/kjumpingcube/AUTHORS
new file mode 100644
index 00000000..2dc6d21a
--- /dev/null
+++ b/kjumpingcube/AUTHORS
@@ -0,0 +1,2 @@
+Matthias Kiefer <matthias.kiefer@gmx.de>
+Benjamin Meyer <ben at meyerhome dot net>
diff --git a/kjumpingcube/ChangeLog b/kjumpingcube/ChangeLog
new file mode 100644
index 00000000..f6b6f5cc
--- /dev/null
+++ b/kjumpingcube/ChangeLog
@@ -0,0 +1,27 @@
+chagnes 1.1:
+- Added Settings dialog
+- finetuned the code
+- removed a lot of unessessary code with newer qt3 code.
+
+changes 0.7.3:
+- finetuning and some bugfixes
+
+changes 0.7.2:
+- rewritten everything (just to learn better c++ ;-)
+- implemented better and faster algorithm for the computerplayer
+- added possibility to save/load games in/from any file.
+- KJumpingCube is now fully KDE-compliant 
+
+changes 0.7.0.1:
+- rewrote parts of CubeBox and Cube, move is now managed from CubeBox
+- added computerplayer
+- added undo-function
+
+changes 0.6.1:
+- after reseting cubes are drawn in the global configured backgroundcolor
+
+changes 0.6:
+- added sessionmanagment
+- added standardaccelerators
+- added possibility to save and restore a game
+
diff --git a/kjumpingcube/Makefile.am b/kjumpingcube/Makefile.am
new file mode 100644
index 00000000..fdb5a185
--- /dev/null
+++ b/kjumpingcube/Makefile.am
@@ -0,0 +1,23 @@
+
+INCLUDES = -I$(top_srcdir)/libkdegames $(all_includes)
+METASOURCES = AUTO
+KDE_ICON = kjumpingcube
+
+bin_PROGRAMS = kjumpingcube
+kjumpingcube_SOURCES = kjumpingcube.cpp kcubeboxwidget.cpp main.cpp \
+                       kcubewidget.cpp cube.cpp brain.cpp cubebox.cpp \
+                       settings.ui prefs.kcfgc
+
+kjumpingcube_LDFLAGS = $(all_libraries) $(KDE_RPATH)
+kjumpingcube_LDADD = $(LIB_KDEGAMES) $(LIB_KFILE)
+kjumpingcube_DEPENDENCIES = $(LIB_KDEGAMES_DEP)
+
+xdg_apps_DATA = kjumpingcube.desktop
+kde_kcfg_DATA = kjumpingcube.kcfg
+
+rcdir = $(kde_datadir)/kjumpingcube
+rc_DATA = kjumpingcubeui.rc
+
+messages: rc.cpp
+	$(XGETTEXT) *.cpp -o $(podir)/kjumpingcube.pot
+
diff --git a/kjumpingcube/README b/kjumpingcube/README
new file mode 100644
index 00000000..52c9040f
--- /dev/null
+++ b/kjumpingcube/README
@@ -0,0 +1,39 @@
+KJumpingCube
+Matthias Kiefer <matthias.kiefer@gmx.de>
+----------------------------------------------------------------------
+
+KJumpingCube is a tactical one- or two-player game. 
+For further information read the online help-documentation.
+
+For installing instructions read INSTALL.
+
+I hope you will enjoy it. Have a lot of fun :-)
+
+
+Don't hesitate to contact me if you find bugs or if you have 
+questions/suggestions on the implementation.
+
+
+Thanks to Krzysztof P. Jasiutowicz for suggestions and moral support.
+
+
+
+  Copyright (C) 1998,1999 by Matthias Kiefer <matthias.kiefer@gmx.de>
+
+  KJumpingCube 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.
+  
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+--
+Matthias Kiefer <matthias.kiefer@gmx.de>
+5.Apr 1999
diff --git a/kjumpingcube/brain.cpp b/kjumpingcube/brain.cpp
new file mode 100644
index 00000000..e2d63815
--- /dev/null
+++ b/kjumpingcube/brain.cpp
@@ -0,0 +1,621 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+
+#include "brain.h"
+#include "cube.h"
+
+#include <math.h>
+
+#include <kapplication.h>
+
+#undef DEBUG // uncomment this to get useful messages
+#include <assert.h>
+
+#ifdef DEBUG
+#include <iostream.h>
+#endif
+
+#include "prefs.h"
+
+Brain::Brain(int initValue)
+{
+   setSkill(Prefs::EnumSkill::Beginner);
+   stopped=false;
+   active=false;
+   currentLevel=0;
+
+   // initialize the random number generator
+   random.setSeed(initValue);
+}
+
+void Brain::setSkill(int newSkill)
+{
+   _skill=newSkill;
+
+   switch(_skill)
+   {
+      case Prefs::EnumSkill::Beginner:
+         maxLevel=1;
+	 break;
+      case Prefs::EnumSkill::Average:
+         maxLevel=3;
+         break;
+      case Prefs::EnumSkill::Expert:
+         maxLevel=5;
+         break;
+      default:
+         break;
+   }
+}
+
+int Brain::skill() const
+{
+   return _skill;
+}
+
+void Brain::stop()
+{
+   stopped=true;
+}
+
+
+bool Brain::isActive()  const
+{
+   return active;
+}
+
+
+
+bool Brain::getHint(int& row, int& column,CubeBox::Player player ,CubeBox box)
+{
+   if(isActive())
+      return false;
+
+   active=true;
+   stopped=false;
+   currentPlayer=player;
+
+   int i=0,j=0;
+   int moves=0; // how many moves are the favourable ones
+   CubeBox::Player opponent=(player==CubeBox::One)?CubeBox::Two : CubeBox::One;
+
+   // if more than one cube has the same rating this array is used to select
+   // one
+   coordinate* c2m=new coordinate[box.dim()*box.dim()];
+
+   // Array, which holds the assessment of the separate moves
+   double **worth=new double*[box.dim()];
+   for(i=0;i<box.dim();i++)
+      worth[i]=new double[box.dim()];
+
+   // alle Werte auf kleinstm�glichen Wert setzen
+   double min=-pow(2.0,sizeof(long int)*8-1);  // Maximum auf kleinst m�glichen Wert setzen
+
+   for(i=0;i<box.dim();i++)
+     for(j=0;j<box.dim();j++)
+     {
+        worth[i][j]=min;
+     }
+
+
+   // find the favourable cubes to increase
+   moves=findCubes2Move(c2m,player,box);
+
+
+   // if only one cube is found, then don't check recursively the move
+   if(moves==1)
+   {
+#ifdef DEBUG
+      cerr << "found only one favourable cube" << endl;
+#endif
+      row=c2m[0].row;
+      column=c2m[0].column;
+   }
+   else
+   {
+#ifdef DEBUG
+      cerr << "found more than one favourable cube: " << moves << endl;
+#endif
+      for(i=0;i<moves;i++)
+      {
+	 // if Thinking process stopped
+	 if(stopped)
+	 {
+#ifdef DEBUG
+	     cerr << "brain stopped" << endl;
+#endif
+	     active=false;
+             for(i=0;i<box.dim();i++)
+                delete[] worth[i];
+             delete [] worth;
+
+             delete [] c2m;
+
+	     return false;
+	 }
+
+#ifdef DEBUG
+	 cerr << "checking cube " << c2m[i].row << "," << c2m[i].column << endl;
+#endif
+         // for every found possible move, simulate this move and store the assessment
+	 worth[c2m[i].row][c2m[i].column]=doMove(c2m[i].row,c2m[i].column,player,box);
+
+#ifdef DEBUG
+	 cerr << "cube "  << c2m[i].row << "," << c2m[i].column << " : " << worth[c2m[i].row][c2m[i].column] << endl;
+#endif
+      }
+
+
+      // find the maximum
+      double max=-1E99;  // set max to minimum value
+
+#ifdef DEBUG
+      cerr << "searching for the maximum" << endl;
+#endif
+
+      for(i=0;i<moves;i++)
+      {
+         if(box[c2m[i].row][c2m[i].column]->owner()!=(Cube::Owner)opponent)
+         {
+            if(worth[c2m[i].row][c2m[i].column]>max )
+            {
+               max=worth[c2m[i].row][c2m[i].column];
+            }
+         }
+      }
+
+#ifdef DEBUG
+      cerr << "found Maximum : " << max << endl;
+#endif
+
+      // found maximum more than one time ?
+      int counter=0;
+      for(i=0;i<moves;i++)
+      {
+#ifdef DEBUG
+         cerr << c2m[i].row << "," << c2m[i].column << " : " << worth[c2m[i].row][c2m[i].column] << endl;
+#endif
+         if(worth[c2m[i].row][c2m[i].column]==max)
+            if(box[c2m[i].row][c2m[i].column]->owner() != (Cube::Owner)opponent)
+	    {
+	       c2m[counter].row=c2m[i].row;
+	       c2m[counter].column=c2m[i].column;
+	       counter++;
+	    }
+      }
+
+      assert(counter>0);
+
+
+      // if some moves are equal, choose a random one
+      if(counter>1)
+      {
+
+#ifdef DEBUG
+         cerr << "choosing a random cube: " << endl ;
+#endif
+         counter=random.getLong(counter);
+      }
+
+      row=c2m[counter].row;
+      column=c2m[counter].column;
+#ifdef DEBUG
+      cerr << "cube: " << row << "," << column << endl;
+#endif
+   }
+
+   // clean up
+   for(i=0;i<box.dim();i++)
+      delete[] worth[i];
+   delete [] worth;
+
+   delete [] c2m;
+
+   active=false;
+
+   return true;
+}
+
+
+
+double Brain::doMove(int row, int column, CubeBox::Player player , CubeBox box)
+{
+   double worth=0;
+   currentLevel++; // increase the current depth of recurse calls
+
+
+   // if the maximum depth isn't reached
+   if(currentLevel < maxLevel)
+   {
+       // test, if possible to increase this cube
+      if(!box.simulateMove(player,row,column))
+      {
+         currentLevel--;
+         return 0;
+      }
+
+      // if the player has won after simulating this move, return the assessment of the field
+      if(box.playerWon(player))
+      {
+         currentLevel--;
+
+	 return (long int)pow((float)box.dim()*box.dim(),(maxLevel-currentLevel))*box.assessField(currentPlayer);
+      }
+
+
+      int i;
+      int moves=0;
+      // if more than one cube has the same rating this array is used to select
+      // one
+      coordinate* c2m=new coordinate[box.dim()*box.dim()];
+
+      // the next move has does the other player
+      player=(player==CubeBox::One)? CubeBox::Two : CubeBox::One;
+
+      // find the favourable cubes to increase
+      moves=findCubes2Move(c2m,player,box);
+
+      // if only one cube is found, then don't check recursively the move
+      if(moves==1)
+      {
+         box.simulateMove(player,c2m[0].row,c2m[0].column);
+         worth=(long int)pow((float)box.dim()*box.dim(),(maxLevel-currentLevel-1))*box.assessField(currentPlayer);
+      }
+      else
+      {
+         for(i=0;i<moves;i++)
+         {
+            kapp->processEvents();
+
+	    // if thinking process stopped
+	    if(stopped)
+	    {
+	       currentLevel--;
+	       return 0;
+	    }
+
+	    // simulate every possible move
+	    worth+=doMove(c2m[i].row,c2m[i].column,player,box);
+         }
+      }
+      delete [] c2m;
+      currentLevel--;
+      return worth;
+
+   }
+   else
+   {
+      // if maximum depth of recursive calls are reached, return the assessment
+      currentLevel--;
+      box.simulateMove(player,row,column);
+
+      return box.assessField(currentPlayer);
+   }
+
+}
+
+int Brain::findCubes2Move(coordinate *c2m,CubeBox::Player player,CubeBox& box)
+{
+   int i,j;
+   int opponent=(player==CubeBox::One)? CubeBox::Two : CubeBox::One;
+   int moves=0;
+   int min=9999;
+
+   if(_skill==Prefs::EnumSkill::Beginner)
+   {
+      int max=0;
+      for(i=0;i<box.dim();i++)
+        for(j=0;j<box.dim();j++)
+        {
+           if(box[i][j]->owner() != opponent)
+           {
+              c2m[moves].row=i;
+              c2m[moves].column=j;
+              c2m[moves].val=box[i][j]->value();
+
+              if(c2m[moves].val>max)
+                 max=c2m[moves].val;
+
+              moves++;
+
+	   }
+        }
+
+    // find all moves with maximum value
+    int counter=0;
+    for(i=0;i<moves;i++)
+    {
+       if(c2m[i].val==max)
+       {
+	  c2m[counter].row=c2m[i].row;
+	  c2m[counter].column=c2m[i].column;
+	  c2m[counter].val=c2m[i].val;
+
+          counter++;
+        }
+     }
+
+     if(counter!=0)
+     {
+        moves=counter;
+     }
+   }
+   else // if skill is not Beginner
+   {
+      int secondMin=min;
+      // put values on the cubes
+      for(i=0;i<box.dim();i++)
+        for(j=0;j<box.dim();j++)
+        {
+	   // use only cubes, who don't belong to the opponent
+	   if(box[i][j]->owner() != opponent)
+	   {
+	      int val;
+
+	      // check neighbours of every cube
+	      val=assessCube(i,j,player,box);
+
+
+#ifdef DEBUG
+	      if(currentLevel==0)
+	         cerr << i << "," << j << " : " << val << endl;
+#endif
+	      // only if val >= 0 its a favourable move
+              if( val > 0 )
+              {
+	         if(val<min)
+	         {
+	            secondMin=min;
+		    min=val;
+	         }
+
+	         // store coordinates
+	         c2m[moves].row=i;
+	         c2m[moves].column=j;
+	         c2m[moves].val=val;
+                 moves++;
+	      }
+	   }
+        }
+
+
+	// If all cubes are bad, check all cubes for the next move
+	if(moves==0)
+	{
+	   min=4;
+	   for(i=0;i<box.dim();i++)
+	      for(j=0;j<box.dim();j++)
+	      {
+	         if(box[i][j]->owner() != opponent)
+		 {
+                    c2m[moves].row=i;
+                    c2m[moves].column=j;
+                    c2m[moves].val=( box[i][j]->max() - box[i][j]->value() );
+                    if(c2m[moves].val<min)
+                       min=c2m[moves].val;
+                    moves++;
+		 }
+	      }
+        }
+
+	int counter=0;
+	// find all moves with minimum assessment
+	for(i=0;i<moves;i++)
+	{
+	   if(c2m[i].val==min)
+	   {
+              c2m[counter].row=c2m[i].row;
+              c2m[counter].column=c2m[i].column;
+              c2m[counter].val=c2m[i].val;
+
+              counter++;
+           }
+	   else if(_skill == Prefs::EnumSkill::Average)
+	   {
+	      if(c2m[i].val == secondMin)
+	      {
+                 c2m[counter].row=c2m[i].row;
+                 c2m[counter].column=c2m[i].column;
+                 c2m[counter].val=c2m[i].val;
+
+		 counter++;
+	      }
+	   }
+	}
+
+	if(counter!=0)
+	{
+	   moves=counter;
+	}
+   }
+
+   int maxMoves=10;
+	// if more than maxMoves moves are favourable, take maxMoves random moves
+	// because it will take to much time if you check all
+	if(moves > maxMoves)
+	{
+	   // find maxMoves random cubes to move with
+	   coordinate* tempC2M=new coordinate[maxMoves];
+
+	   coordinate tmp={-1,-1,0};
+	   for(i=0;i<maxMoves;i++)
+              tempC2M[i]=tmp;
+
+	   // this array takes the random chosen numbers, so that no
+	   // number will be taken two times
+	   int *results=new int[moves];
+	   for(i=0;i<moves;i++)
+	      results[i]=0;
+
+	   for(i=0;i<maxMoves;i++)
+	   {
+	      int temp;
+	      do
+	      {
+	         temp=random.getLong(moves);
+	      }
+	      while(results[temp]!=0);
+
+	      results[temp]=1;
+
+	      tempC2M[i].row=c2m[temp].row;
+	      tempC2M[i].column=c2m[temp].column;
+	      tempC2M[i].val=c2m[temp].val;
+	   }
+	   delete [] results;
+
+	   for(i=0;i<maxMoves;i++)
+	   {
+	      c2m[i].row=tempC2M[i].row;
+	      c2m[i].column=tempC2M[i].column;
+	      c2m[i].val=tempC2M[i].val;
+	   }
+	   delete [] tempC2M;
+
+	   moves=maxMoves;
+	}
+
+
+   return moves;
+
+}
+
+
+int Brain::assessCube(int row,int column,CubeBox::Player player,CubeBox& box) const
+{
+   int diff;
+
+   if(row==0)  // first row
+   {
+      if(column == 0)  // upper left corner
+      {
+         diff=getDiff(0,1,player,box) ;
+         int temp=getDiff(1,0,player,box);
+         if(temp < diff)
+            diff=temp;
+      }
+      else if(column == box.dim()-1) // upper right corner
+      {
+         diff=getDiff(0,column-1,player,box);
+         int temp=getDiff(1,column,player,box);
+         if(temp < diff)
+	    diff=temp;
+      }
+      else
+      {
+         diff=getDiff(row,column-1,player,box);
+         int temp=getDiff(row,column+1,player,box);
+         if(temp < diff)
+            diff = temp;
+         temp=getDiff(row+1,column,player,box);
+         if(temp < diff)
+            diff = temp;
+      }
+   }
+   else if(row==box.dim()-1) // last row
+   {
+      if(column == 0) // lower left corner
+      {
+         diff=getDiff(row,1,player,box);
+         int temp=getDiff(row-1,0,player,box);
+         if(temp < diff)
+            diff=temp;
+      }
+      else if(column == box.dim()-1) // lower right corner
+      {
+         diff=getDiff(row,column-1,player,box);
+         int temp=getDiff(row-1,column,player,box);
+         if(temp < diff)
+            diff=temp;
+      }
+      else
+      {
+         diff=getDiff(row,column-1,player,box);
+         int temp=getDiff(row,column+1,player,box);
+         if(temp < diff)
+            diff = temp;
+         temp=getDiff(row-1,column,player,box);
+         if(temp < diff)
+            diff = temp;
+      }
+   }
+   else if(column == 0) // first column
+   {
+       diff = getDiff(row,1,player,box);
+       int temp = getDiff(row-1,0,player,box);
+       if(temp < diff)
+          diff = temp;
+       temp = getDiff(row+1,0,player,box);
+       if(temp < diff)
+          diff = temp;
+   }
+   else if(column == box.dim()-1) // last column
+   {
+      diff = getDiff(row,column-1,player,box);
+      int temp = getDiff(row-1,column,player,box);
+      if(temp < diff)
+         diff = temp;
+      temp = getDiff(row+1,column,player,box);
+      if(temp < diff)
+         diff = temp;
+   }
+   else
+   {
+      diff=getDiff(row-1,column,player,box);
+      int temp=getDiff(row+1,column,player,box);
+      if(temp < diff)
+         diff = temp;
+      temp=getDiff(row,column-1,player,box);
+      if(temp < diff)
+         diff = temp;
+      temp=getDiff(row,column+1,player,box);
+      if(temp < diff)
+         diff = temp;
+   }
+
+   int temp;
+   temp=( box[row][column]->max()-box[row][column]->value() );
+
+   int val;
+   val=diff-temp+1;
+   val=val*(temp+1);
+
+   return val;
+}
+
+
+int Brain::getDiff(int row,int column, CubeBox::Player player, CubeBox& box) const
+{
+	int diff;
+
+	if(box[row][column]->owner() != (Cube::Owner)player)
+	{
+           diff=( box[row][column]->max() - box[row][column]->value() );
+	}
+	else
+	{
+           diff=( box[row][column]->max() - box[row][column]->value()+1 );
+	}
+
+	return diff;
+}
+
diff --git a/kjumpingcube/brain.h b/kjumpingcube/brain.h
new file mode 100644
index 00000000..8f270705
--- /dev/null
+++ b/kjumpingcube/brain.h
@@ -0,0 +1,135 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef BRAIN_H
+#define BRAIN_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <krandomsequence.h>
+
+#include "cubebox.h"
+
+/** @internal */
+struct coordinate
+{
+   int row;
+   int column;
+   
+   int val;
+};
+
+
+/**
+* Class Brain computes a (good) possibility to move
+* for a given playingfield.
+* 
+* It puts a value on every cube by looking at its neighbours
+* and searches the best cubes to move. It then simulates what would 
+* happen, if you would click on these cubes. This is done recursively 
+* to a certain depth and the playingfield will be valued. 
+* 
+* @short The games brain
+*/
+class Brain
+{
+public:
+   /** 
+   * @param initValue value to initialize the random number generator with
+   *        if no value is given a truly random value is used
+   */
+   Brain(int initValue=0);
+
+   /**
+   * Computes a good possible move at the given field.
+   * The index of this Cube is stored in given 'row' and 'column' 
+   * 
+   * @return false if computing was stopped
+   * @see Brain#stop;  
+   */
+   bool getHint(int& row, int& column, CubeBox::Player player, CubeBox field);
+   
+   /** stops thinking */
+   void stop();
+   /** @return true if the Brain is thinking at the moment */
+   bool isActive() const;
+
+   /** skill according to Prefs::EnumSkill **/
+   void setSkill(int);
+   int skill() const;
+   
+private:
+   /**
+   * checks if a move is possible at cube row,column from player 'player' and
+   * simulates this move. Then it checks the new playingfield for possible moves
+   * and calls itself for every possible move until the maximum depth 'maxLevel'
+   * is reached.
+   *
+   * If the maximum depth is reached, it puts a value on the playingfield and returns this.
+   * @see CubeBox#simulateMove
+   * @see CubeBox#assessField
+   * @see Brain#findCubes2Move
+   *
+   * @param row,column coordinates of cube to increase
+   * @param player for which player the cube has to be increased
+   * @param box playingfield to do the moves on
+   * @return the value put on the field
+   */
+    double doMove(int row,int column,CubeBox::Player player, CubeBox box);
+   /**
+   * Checks the given playingfield, which cubes are favourable to do a move
+   * by checking every cubes neighbours. And looking for the difference to overflow.
+   *
+   * @param c2m Array in which the coordinates of the best cubes to move will be stored
+   * @param player for which player to check
+   * @param box playingfield to check
+   * @param debug if debugmessages should be printed
+   * @return number of found cubes to move
+   */
+   int findCubes2Move(coordinate* c2m,CubeBox::Player player,CubeBox& box);
+   /**
+   *
+   */
+   int assessCube(int row,int column,CubeBox::Player,CubeBox& box) const;
+   int getDiff(int row,int column, CubeBox::Player player, CubeBox& box) const;
+
+   /** current depth of recursive simulating of the moves */
+   int currentLevel;
+   /** maximum depth of recursive thinking */
+   int maxLevel;
+   /** the player for which to check the moves */
+   CubeBox::Player currentPlayer;
+	
+	
+   /** flag, if the engine has to be stopped */
+   bool stopped;
+   /** flag, if the engine is active */
+   bool active;
+   /** skill of the Brain, see Prefs::EnumSkill */
+   int _skill;
+
+   /** Sequence generator */
+   KRandomSequence random;    
+};
+
+#endif //BRAIN_H
diff --git a/kjumpingcube/cube.cpp b/kjumpingcube/cube.cpp
new file mode 100644
index 00000000..59e2dc58
--- /dev/null
+++ b/kjumpingcube/cube.cpp
@@ -0,0 +1,99 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include "cube.h"
+#include <assert.h>
+
+/* ****************************************************** **
+**                      Class Cube                        **  
+** ****************************************************** */
+
+Cube::Cube(Owner owner,int value,int maximum)
+{
+   _owner = owner;
+   _value = value;
+   _max = maximum;
+}
+
+
+Cube::Owner Cube::setOwner(Owner owner)
+{
+   Owner old=_owner;
+   _owner=owner;
+   
+   return old;
+}
+
+void Cube::setValue(int value)
+{
+#ifdef DEBUG
+   assert(value>0);
+#endif
+         
+   _value = (value<1)? 1 : value;
+}
+
+
+void Cube::setMax(int max)
+{
+#ifdef DEBUG
+   assert(max>1);
+#endif
+   
+   _max = (max<2)? 2 : max;
+}
+
+
+void Cube::decrease()
+{
+   setValue(_value-_max);
+}
+
+Cube::Owner Cube::owner() const
+{
+   return _owner;
+}
+
+
+int Cube::value() const
+{
+   return _value;
+}
+
+bool Cube::increase(Owner newOwner)
+{
+   setValue(value()+1);
+   setOwner(newOwner);
+   
+   return (_value > _max);
+}
+
+int Cube::max() const
+{
+   return _max;
+}
+
+
+bool Cube::overMax() const
+{
+   return (_value > _max);   
+}
+
diff --git a/kjumpingcube/cube.h b/kjumpingcube/cube.h
new file mode 100644
index 00000000..9a58c02f
--- /dev/null
+++ b/kjumpingcube/cube.h
@@ -0,0 +1,99 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef CUBE_H
+#define CUBE_H
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+* This Class is the internal representation of a cube.
+*/
+class Cube
+{
+public:   
+   enum Owner{Nobody=0,One=1,Two=2};
+
+   /**
+   * constructs a Cube
+   */
+   Cube(Owner owner=Nobody,int value=1,int max=4);   
+   
+   
+   /**
+   * changes owner of the Cube
+   * @return old Owner
+   */
+   virtual Owner setOwner(Owner owner);
+   
+   /**
+   * changes value of the Cube 
+   */
+   virtual void setValue(int value);
+   
+   /**
+   * sets maximum value of the Cube
+   */
+   virtual void setMax(int max);
+   
+   /**
+   * increase the value of the Cube and set the owner of the Cube
+   * to 'newOwner'.
+   * @return true if the Cube's new value is over maximum
+   */
+   virtual bool increase(Owner newOwner);
+   
+   /**
+   * substracts the maximum from the Cube's value  
+   */
+   virtual void decrease();
+   
+   /**
+   * returns current owner
+   */
+   Owner owner() const;
+   /**
+   * returns current value
+   */
+   int value() const;
+   /**
+   * returns the maximum value of the cube
+   */
+   int max() const;   
+   
+   /**
+   * checks if the Cube's value is over maximum
+   */
+   bool overMax() const;
+   
+private:
+
+   Owner _owner;
+   int _value;
+   int _max;
+   
+};
+
+
+#endif
diff --git a/kjumpingcube/cubebox.cpp b/kjumpingcube/cubebox.cpp
new file mode 100644
index 00000000..91a90cc6
--- /dev/null
+++ b/kjumpingcube/cubebox.cpp
@@ -0,0 +1,292 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include <assert.h>
+#include <math.h>
+#include "cubebox.h"
+#include "kcubeboxwidget.h"
+
+
+CubeBox::CubeBox(const int d)
+    :CubeBoxBase<Cube>(d)
+{
+   initCubes();
+}
+
+CubeBox::CubeBox(const CubeBox& box)
+      :CubeBoxBase<Cube>(box.dim())
+{
+   initCubes();
+
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         *cubes[i][j]=*box.cubes[i][j];
+      }
+
+   currentPlayer=box.currentPlayer;
+}
+
+CubeBox::CubeBox(KCubeBoxWidget& box)
+      :CubeBoxBase<Cube>(box.dim())
+{
+   initCubes();
+
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+        *cubes[i][j]=*box[i][j];
+      }
+
+   currentPlayer=(CubeBox::Player)box.player();
+
+}
+
+
+CubeBox::~CubeBox()
+{
+}
+
+
+CubeBox& CubeBox::operator=(const CubeBox& box)
+{
+   if(this!=&box)
+   {
+      if(dim()!=box.dim())
+      {
+         setDim(box.dim());
+      }
+
+
+      for(int i=0;i<dim();i++)
+         for(int j=0;j<dim();j++)
+         {
+            *cubes[i][j]=*box.cubes[i][j];
+         }
+   }
+
+   currentPlayer=box.currentPlayer;
+
+   return *this;
+}
+
+
+CubeBox& CubeBox::operator=(KCubeBoxWidget& box)
+{
+   if(dim()!=box.dim())
+   {
+      setDim(box.dim());
+   }
+
+   for(int i=0;i<dim();i++)
+      for(int j=0;j<dim();j++)
+      {
+         *cubes[i][j]=*box[i][j];
+      }
+
+   currentPlayer=(CubeBox::Player)box.player();
+
+   return *this;
+}
+
+
+
+
+bool CubeBox::simulateMove(Player fromWhom,int row, int column)
+{
+   bool finished;
+   bool playerWon=false;
+
+   if(cubes[row][column]->owner()!=(Cube::Owner)fromWhom && cubes[row][column]->owner()!=Cube::Nobody)
+      return false;
+
+   cubes[row][column]->increase((Cube::Owner)fromWhom);
+
+   do
+   {
+      int i,j;
+      finished=true;
+      playerWon=true;
+
+      // check all Cubes
+      for(i=0;i<dim();i++)
+      {
+	      for(j=0;j<dim();j++)
+         {
+	         if(cubes[i][j]->overMax())
+	         {
+	            increaseNeighbours(fromWhom,i,j);
+	            cubes[i][j]->decrease();
+	            finished=false;
+	         }
+
+	         if(cubes[i][j]->owner()!=(Cube::Owner)fromWhom)
+	         playerWon=false;
+         }
+      }
+
+      if(playerWon)
+	      return true;
+   }
+   while(!finished);
+
+
+   return true;
+}
+
+double CubeBox::assessField(Player player) const
+{
+   int cubesOne=0;
+   int cubesTwo=0;
+   int pointsOne=0;
+   int pointsTwo=0;
+   Player otherPlayer = ((player==One)? Two : One);
+   bool playerWon=true;
+   bool otherPlayerWon=true;
+
+   int i,j;
+
+   for(i=0;i<dim();i++)
+   {
+      for(j=0;j<dim();j++)
+      {
+	      if(cubes[i][j]->owner()==(Cube::Owner)One)
+	      {
+	         cubesOne++;
+	         pointsOne+=(int)pow((float)cubes[i][j]->value(),2);
+	      }
+	      else if(cubes[i][j]->owner()==(Cube::Owner)Two)
+	      {
+	         cubesTwo++;
+	         pointsTwo+=(int)pow((float)cubes[i][j]->value(),2);
+	      }
+
+	      if(cubes[i][j]->owner()!=(Cube::Owner)player)
+	         playerWon=false;
+
+	      if(cubes[i][j]->owner()!=(Cube::Owner)otherPlayer)
+	         otherPlayerWon=false;
+      }
+
+   }
+
+
+
+   if(player==One)
+   {
+      return (int)pow((float)cubesOne,2)+pointsOne-(int)pow(cubesTwo,2)-pointsTwo;
+   }
+   else
+      return (int)pow((float)cubesTwo,2)+pointsTwo-(int)pow(cubesOne,2)-pointsOne;
+
+}
+
+bool CubeBox::playerWon(Player who) const
+{
+   int i,j;
+
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         if(cubes[i][j]->owner()!=(Cube::Owner)who)
+	         return false;
+      }
+
+   return true;
+}
+
+
+void CubeBox::increaseNeighbours(CubeBox::Player forWhom,int row,int column)
+{
+   Cube::Owner _player = (Cube::Owner)(forWhom);
+
+   if(row==0)
+   {
+    	if(column==0)  // top left corner
+	{
+	   cubes[0][1]->increase(_player);
+	   cubes[1][0]->increase(_player);
+	   return;
+	}
+	else if(column==dim()-1)  // top right corner
+	{
+	   cubes[0][dim()-2]->increase(_player);
+	   cubes[1][dim()-1]->increase(_player);
+	   return;
+	}
+	else  // top edge
+	{
+	   cubes[0][column-1]->increase(_player);
+	   cubes[0][column+1]->increase(_player);
+	   cubes[1][column]->increase(_player);
+	   return;
+	}
+   }
+   else if(row==dim()-1)
+   {
+      if(column==0)  // left bottom corner
+      {
+         cubes[dim()-2][0]->increase(_player);
+         cubes[dim()-1][1]->increase(_player);
+         return;
+      }
+
+      else if(column==dim()-1) // right bottom corner
+      {
+         cubes[dim()-2][dim()-1]->increase(_player);
+         cubes[dim()-1][dim()-2]->increase(_player);
+	      return;
+      }
+      else  // bottom edge
+      {
+ 	      cubes[dim()-1][column-1]->increase(_player);
+	      cubes[dim()-1][column+1]->increase(_player);
+	      cubes[dim()-2][column]->increase(_player);
+	      return;
+      }
+   }
+   else if(column==0) // left edge
+   {
+      cubes[row-1][0]->increase(_player);
+      cubes[row+1][0]->increase(_player);
+      cubes[row][1]->increase(_player);
+      return;
+   }
+   else if(column==dim()-1)  // right edge
+   {
+      cubes[row-1][dim()-1]->increase(_player);
+      cubes[row+1][dim()-1]->increase(_player);
+      cubes[row][dim()-2]->increase(_player);
+      return;
+   }
+   else
+   {
+      cubes[row][column-1]->increase(_player);
+      cubes[row][column+1]->increase(_player);
+      cubes[row-1][column]->increase(_player);
+      cubes[row+1][column]->increase(_player);
+      return;
+   }
+
+
+}
diff --git a/kjumpingcube/cubebox.h b/kjumpingcube/cubebox.h
new file mode 100644
index 00000000..d1236410
--- /dev/null
+++ b/kjumpingcube/cubebox.h
@@ -0,0 +1,62 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef CUBEBOX_H
+#define CUBEBOX_H
+
+#include "cubeboxbase.h"
+
+class Cube;
+class KCubeBoxWidget;
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+* Class for storing information about the playingfield, e.g.
+* to undo a move or computing the next move
+*/
+class CubeBox : public CubeBoxBase<Cube>
+{
+public:
+   /**
+   * constructs a CubeBox with 'dim' x 'dim' Cubes
+   */
+   CubeBox(const int dim=1);
+   CubeBox(const CubeBox&);
+   CubeBox(KCubeBoxWidget&);
+   virtual ~CubeBox();
+   
+   CubeBox& operator= (const CubeBox& box);
+   CubeBox& operator= (KCubeBoxWidget& box);
+   
+   bool simulateMove(Player fromWhom,int row, int column);
+   double assessField(Player forWhom) const;
+   bool playerWon(Player who) const;
+
+private:
+   void increaseNeighbours(CubeBox::Player forWhom,int row,int column);
+
+};
+
+#endif // CUBEBOX_H
+
diff --git a/kjumpingcube/cubeboxbase.h b/kjumpingcube/cubeboxbase.h
new file mode 100644
index 00000000..63bc0529
--- /dev/null
+++ b/kjumpingcube/cubeboxbase.h
@@ -0,0 +1,246 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef CUBEBOXBASE_H
+#define CUBEBOXBASE_H
+
+#ifdef DEBUG
+#include <assert.h>
+#endif
+
+template<class T> 
+class CubeBoxBase
+{
+public:
+   enum Player{One=1,Two=2};
+  
+   CubeBoxBase(const int dim=1);
+   virtual ~CubeBoxBase();
+   
+   T** operator[](const int index);
+   /**
+   * sets number of Cubes in a row/column to 'size'.
+   */
+   virtual void setDim(int dim);
+   
+   /**
+   * returns number of Cubes in a row/column
+   */
+   inline int dim() const { return _dim; }
+   
+   inline Player player() const { return currentPlayer; } 
+   
+protected:
+   virtual void deleteCubes();
+   virtual void initCubes();
+   
+   /** increases the neighbours of cube at ['row','column'] */
+   //void increaseNeighbours(int forWhom,int row,int column);
+  
+   T*** cubes;
+   Player currentPlayer;
+   
+private:
+   int _dim;
+         
+};
+
+template<class T>
+CubeBoxBase<T>::CubeBoxBase(const int dim)
+{
+#ifdef DEBUG
+   assert(dim>0);
+#endif
+   
+   _dim=dim;
+   currentPlayer=One;
+}
+
+template<class T>
+CubeBoxBase<T>::~CubeBoxBase()
+{
+   if(cubes)
+      deleteCubes();
+}
+
+template<class T>
+T** CubeBoxBase<T>::operator[](const int index)
+{
+#ifdef DEBUG
+   assert(index >= 0);
+#endif
+
+    return cubes[index];
+}
+   
+template<class T>
+void CubeBoxBase<T>::setDim(int d)
+{
+   if(d != _dim)
+   {
+      deleteCubes();
+    
+      _dim=d;     
+      
+      initCubes();
+   }
+}
+
+
+template<class T>
+void CubeBoxBase<T>::initCubes()
+{
+   const int s=dim();
+   
+   int i,j;
+   // create new cubes
+   cubes = new T**[s];
+   for(i=0;i<s;i++)
+   {
+      cubes[i]=new T*[s];
+   }
+   for(i=0;i<s;i++)
+      for(j=0;j<s;j++)
+      {
+         cubes[i][j]=new T();
+      }
+   
+   // initialize cubes  
+   int max=dim()-1;
+      
+   cubes[0][0]->setMax(2);
+   cubes[0][max]->setMax(2);
+   cubes[max][0]->setMax(2);
+   cubes[max][max]->setMax(2);
+   
+   for(i=0;i<=max;i++)
+   {
+      cubes[i][0]->setMax(3);
+      cubes[i][max]->setMax(3);
+      cubes[0][i]->setMax(3);
+      cubes[max][i]->setMax(3);
+   }
+   
+   for(i=1;i<max;i++)
+     for(j=1;j<max;j++)
+      {
+         cubes[i][j]->setMax(4);
+      }
+}
+
+template<class T>
+void CubeBoxBase<T>::deleteCubes()
+{  
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         delete cubes[i][j];
+      }
+   for(i=0;i<dim();i++)
+   {
+      delete [] cubes[i];
+   }
+      
+   delete [] cubes;
+      
+   cubes=0;
+}
+/*
+template<class T>
+void CubeBoxBase<T>::increaseNeighbours(int forWhom,int row,int column)
+{  
+   int _player = (T::Owner)(forWhom);
+   
+   if(row==0)
+   {
+    	if(column==0)  // linke obere Ecke
+	{
+	   cubes[0][1]->increase(_player);
+	   cubes[1][0]->increase(_player);
+	   return;
+	}  
+	else if(column==dim()-1)  // rechte obere Ecke
+	{
+	   cubes[0][dim()-2]->increase(_player);
+	   cubes[1][dim()-1]->increase(_player);
+	   return;
+	}
+	else  // oberer Rand
+	{
+	   cubes[0][column-1]->increase(_player);
+	   cubes[0][column+1]->increase(_player);
+	   cubes[1][column]->increase(_player);
+	   return;
+	}
+   }
+   else if(row==dim()-1) 
+   {  
+      if(column==0)  // linke untere Ecke
+      {
+         cubes[dim()-2][0]->increase(_player);
+         cubes[dim()-1][1]->increase(_player);
+         return;
+      }
+   
+      else if(column==dim()-1) // rechte untere Ecke
+      {
+         cubes[dim()-2][dim()-1]->increase(_player);
+         cubes[dim()-1][dim()-2]->increase(_player);
+	      return;
+      }
+      else  // unterer Rand
+      {
+ 	      cubes[dim()-1][column-1]->increase(_player);
+	      cubes[dim()-1][column+1]->increase(_player);
+	      cubes[dim()-2][column]->increase(_player);
+	      return; 
+      }
+   }
+   else if(column==0) // linker Rand
+   {
+      cubes[row-1][0]->increase(_player);
+      cubes[row+1][0]->increase(_player);
+      cubes[row][1]->increase(_player);
+      return;
+   }
+   else if(column==dim()-1)  // rechter Rand
+   {
+      cubes[row-1][dim()-1]->increase(_player);
+      cubes[row+1][dim()-1]->increase(_player);
+      cubes[row][dim()-2]->increase(_player);
+      return;
+   }
+   else
+   {
+      cubes[row][column-1]->increase(_player);
+      cubes[row][column+1]->increase(_player);
+      cubes[row-1][column]->increase(_player);
+      cubes[row+1][column]->increase(_player);
+      return;
+   }
+   
+      
+}
+*/
+
+#endif // CUBEBOXBASE_H
+
diff --git a/kjumpingcube/hi128-app-kjumpingcube.png b/kjumpingcube/hi128-app-kjumpingcube.png
new file mode 100644
index 00000000..30bf2fa2
--- /dev/null
+++ b/kjumpingcube/hi128-app-kjumpingcube.png
diff --git a/kjumpingcube/hi16-app-kjumpingcube.png b/kjumpingcube/hi16-app-kjumpingcube.png
new file mode 100644
index 00000000..1ff05f55
--- /dev/null
+++ b/kjumpingcube/hi16-app-kjumpingcube.png
diff --git a/kjumpingcube/hi22-app-kjumpingcube.png b/kjumpingcube/hi22-app-kjumpingcube.png
new file mode 100644
index 00000000..d2d86082
--- /dev/null
+++ b/kjumpingcube/hi22-app-kjumpingcube.png
diff --git a/kjumpingcube/hi32-app-kjumpingcube.png b/kjumpingcube/hi32-app-kjumpingcube.png
new file mode 100644
index 00000000..aeff307e
--- /dev/null
+++ b/kjumpingcube/hi32-app-kjumpingcube.png
diff --git a/kjumpingcube/hi48-app-kjumpingcube.png b/kjumpingcube/hi48-app-kjumpingcube.png
new file mode 100644
index 00000000..7bcd613d
--- /dev/null
+++ b/kjumpingcube/hi48-app-kjumpingcube.png
diff --git a/kjumpingcube/hi64-app-kjumpingcube.png b/kjumpingcube/hi64-app-kjumpingcube.png
new file mode 100644
index 00000000..22ef300a
--- /dev/null
+++ b/kjumpingcube/hi64-app-kjumpingcube.png
diff --git a/kjumpingcube/kcubeboxwidget.cpp b/kjumpingcube/kcubeboxwidget.cpp
new file mode 100644
index 00000000..98f305d9
--- /dev/null
+++ b/kjumpingcube/kcubeboxwidget.cpp
@@ -0,0 +1,711 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include "kcubeboxwidget.h"
+
+#include <kapplication.h>
+#include <kconfig.h>
+#include <qlayout.h>
+#include <qtimer.h>
+#include <assert.h>
+#include <kcursor.h>
+
+#include "prefs.h"
+
+KCubeBoxWidget::KCubeBoxWidget(const int d,QWidget *parent,const char *name)
+        : QWidget(parent,name),
+          CubeBoxBase<KCubeWidget>(d)
+{
+   init();
+}
+
+
+
+KCubeBoxWidget::KCubeBoxWidget(CubeBox& box,QWidget *parent,const char *name)
+      :QWidget(parent,name),
+       CubeBoxBase<KCubeWidget>(box.dim())
+{  
+   init();
+   
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         *cubes[i][j]=*box[i][j];
+      }
+      
+   currentPlayer=(KCubeBoxWidget::Player)box.player();
+}
+
+
+
+KCubeBoxWidget::KCubeBoxWidget(const KCubeBoxWidget& box,QWidget *parent,const char *name)
+      :QWidget(parent,name),
+       CubeBoxBase<KCubeWidget>(box.dim())
+{  
+   init();
+   
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         *cubes[i][j]=*box.cubes[i][j];
+      }
+   
+      
+   currentPlayer=box.currentPlayer;
+}
+
+
+
+KCubeBoxWidget::~KCubeBoxWidget()
+{
+   if(isActive())
+    stopActivities();
+   if(cubes)
+      deleteCubes();
+   if(undoBox)
+      delete undoBox;
+}
+
+void KCubeBoxWidget::loadSettings(){
+  setColor(KCubeBoxWidget::One, Prefs::color1());
+  setColor(KCubeBoxWidget::Two, Prefs::color2());
+
+  setDim(Prefs::cubeDim());
+  brain.setSkill( Prefs::skill() );
+
+  setComputerplayer(KCubeBoxWidget::One, Prefs::computerPlayer1());
+  setComputerplayer(KCubeBoxWidget::Two, Prefs::computerPlayer2());
+  checkComputerplayer(currentPlayer);
+}
+
+KCubeBoxWidget& KCubeBoxWidget::operator=(const KCubeBoxWidget& box)
+{
+   if(this!=&box)
+   {
+      if(dim()!=box.dim())
+      {
+         setDim(box.dim());
+      }
+      
+      
+      for(int i=0;i<dim();i++)
+         for(int j=0;j<dim();j++)
+         {
+            *cubes[i][j]=*box.cubes[i][j];
+         }
+         
+      currentPlayer=box.currentPlayer;
+   }
+   return *this;
+}
+
+KCubeBoxWidget& KCubeBoxWidget::operator=(CubeBox& box)
+{
+   if(dim()!=box.dim())
+   {
+      setDim(box.dim());
+   }
+   
+   for(int i=0;i<dim();i++)
+      for(int j=0;j<dim();j++)
+      {
+         *cubes[i][j]=*box[i][j];
+      }
+      
+   currentPlayer=(KCubeBoxWidget::Player)box.player();
+      
+   return *this;
+}
+
+void KCubeBoxWidget::reset()
+{
+   stopActivities();
+   
+   int i,j;
+   for(i=0;i<dim();i++)
+      for(j=0;j<dim();j++)
+      {
+         cubes[i][j]->reset();
+      }
+      
+   KCubeWidget::enableClicks(true);
+
+   currentPlayer=One;
+   
+   emit playerChanged(One);
+   checkComputerplayer(One);
+}
+
+void KCubeBoxWidget::undo()
+{
+   if(isActive())
+      return;
+   
+   Player oldPlayer=currentPlayer;
+   
+   *this=*undoBox;
+   
+   if(oldPlayer!=currentPlayer)
+      emit playerChanged(currentPlayer);
+
+   checkComputerplayer(currentPlayer);
+  
+}
+      
+void KCubeBoxWidget::getHint()
+{
+   if(isActive())
+      return;
+
+   int d=dim();
+   for(int i=0;i<d;i++)
+      for(int j=0;j<d;j++)
+      {
+         cubes[i][j]->stopHint();
+      }
+
+   int row=0,column=0;
+   CubeBox field=*this;
+
+   emit startedThinking();
+   bool canceled=!brain.getHint(row,column,(CubeBox::Player)currentPlayer,field);
+   emit stoppedThinking();
+
+   if(canceled)
+   {
+      return;  // return if thinking was stopped
+   }
+   cubes[row][column]->showHint();
+}
+
+void KCubeBoxWidget::setColor(Player player,QPalette color)
+{
+   KCubeWidget::setColor((Cube::Owner)player,color);
+
+   for(int row=0;row<dim();row++)
+      for(int col=0;col<dim();col++)
+      {
+         cubes[row][col]->updateColors();
+      }
+}
+
+void KCubeBoxWidget::setDim(int d)
+{
+   if(d != dim())
+   {
+      undoBox->setDim(d);
+      CubeBoxBase<KCubeWidget>::setDim(d);
+   }
+}
+
+void KCubeBoxWidget::setComputerplayer(Player player,bool flag)
+{
+   if(player==One)
+      computerPlOne=flag;
+   else if(player==Two)
+      computerPlTwo=flag;
+}
+
+  
+void KCubeBoxWidget::stopActivities()
+{
+   if(moveTimer->isActive())
+   {
+      stopLoop();
+      emit stoppedMoving();
+   }
+   if(brain.isActive())
+   {
+      brain.stop();
+      emit stoppedThinking();
+   }
+
+}
+
+void KCubeBoxWidget::saveProperties(KConfigBase* config)
+{
+   if(isMoving())
+   {
+      stopActivities();
+      undo();
+   }
+   else if(brain.isActive())
+      stopActivities();
+
+   // save current player
+   config->writeEntry("onTurn",(int)currentPlayer);
+
+   QStrList list;
+   list.setAutoDelete(true);
+   QString owner, value, key;
+   int cubeDim=dim();
+
+   for(int row=0; row < cubeDim ; row++)
+     for(int column=0; column < cubeDim ; column++)
+     {
+	key.sprintf("%u,%u",row,column);
+	owner.sprintf("%u",cubes[row][column]->owner());
+	value.sprintf("%u",cubes[row][column]->value());
+	list.append(owner.ascii());
+	list.append(value.ascii());
+	config->writeEntry(key , list);
+
+	list.clear();
+      }
+  config->writeEntry("CubeDim",dim());
+}
+
+void KCubeBoxWidget::readProperties(KConfigBase* config)
+{
+  QStrList list;
+  list.setAutoDelete(true);
+  QString owner, value, key;
+  setDim(config->readNumEntry("CubeDim",5));
+  int cubeDim=dim();
+
+  for(int row=0; row < cubeDim ; row++)
+    for(int column=0; column < cubeDim ; column++)
+      {
+	key.sprintf("%u,%u",row,column);
+	config->readListEntry(key, list);
+	owner=list.first();
+	value=list.next();
+	cubes[row][column]->setOwner((KCubeWidget::Owner)owner.toInt());
+	cubes[row][column]->setValue(value.toInt());
+	
+	list.clear();
+      }
+
+
+   // set current player
+   int onTurn=config->readNumEntry("onTurn",1);
+   currentPlayer=(Player)onTurn;
+   emit playerChanged(onTurn);
+   checkComputerplayer((Player)onTurn);
+}
+
+/* ***************************************************************** **
+**                               slots                               **
+** ***************************************************************** */ 
+void KCubeBoxWidget::setWaitCursor()
+{
+   setCursor(KCursor::waitCursor());
+}
+
+
+  
+void KCubeBoxWidget::setNormalCursor()
+{
+   setCursor(KCursor::handCursor());
+}
+
+void KCubeBoxWidget::stopHint()
+{
+
+   int d=dim();
+   for(int i=0;i<d;i++)
+      for(int j=0;j<d;j++)
+      {
+         cubes[i][j]->stopHint();
+      }
+
+}
+
+bool KCubeBoxWidget::checkClick(int row,int column, bool isClick)
+{
+   if(isActive())
+      return false;
+
+   // make the game start when computer player is player one and user clicks
+   if(isClick && currentPlayer == One && computerPlOne)
+   {
+      checkComputerplayer(currentPlayer);
+      return false;
+   }
+   else if((Cube::Owner)currentPlayer==cubes[row][column]->owner() ||
+		   cubes[row][column]->owner()==Cube::Nobody)
+   {
+      doMove(row,column);
+      return true;
+   }
+   else
+      return false;
+}
+
+void KCubeBoxWidget::checkComputerplayer(Player player)
+{
+   // checking if a process is running or the Widget isn't shown yet
+   if(isActive() || !isVisibleToTLW())  
+      return;
+   if((player==One && computerPlOne && currentPlayer==One)
+         || (player==Two && computerPlTwo && currentPlayer==Two))
+   {
+      KCubeWidget::enableClicks(false);
+
+      CubeBox field(*this);
+      int row=0,column=0;
+      emit startedThinking();
+      bool canceled=!brain.getHint(row,column,(CubeBoxBase<Cube>::Player)player,field);
+      emit stoppedThinking();
+
+      if(!canceled)
+      {
+         cubes[row][column]->showHint(500,2);
+
+         bool result=checkClick(row,column,false);
+		 assert(result);
+      }
+   }
+      
+}
+
+/* ***************************************************************** **
+**                         status functions                          **
+** ***************************************************************** */
+ 
+bool KCubeBoxWidget::isActive() const
+{
+   bool flag=false;
+   if(moveTimer->isActive())
+      flag=true;
+   else if(brain.isActive())
+      flag=true;
+   
+   return flag;
+}  
+
+bool KCubeBoxWidget::isMoving() const
+{
+   return moveTimer->isActive();
+}
+
+bool KCubeBoxWidget::isComputer(Player player) const
+{
+   if(player==One)
+      return computerPlOne;
+   else 
+      return computerPlTwo;
+}
+  
+
+int KCubeBoxWidget::skill() const
+{
+   return brain.skill();
+}
+   
+QPalette KCubeBoxWidget::color(Player forWhom)
+{
+   return KCubeWidget::color((KCubeWidget::Owner)forWhom); 
+}
+
+/* ***************************************************************** **
+**                   initializing functions                          **
+** ***************************************************************** */
+void KCubeBoxWidget::init()
+{
+   initCubes();
+
+   undoBox=new CubeBox(dim());
+   
+   currentPlayer=One;
+   moveDelay=100;
+   moveTimer=new QTimer(this);
+   computerPlOne=false;
+   computerPlTwo=false;
+   KCubeWidget::enableClicks(true);
+   loadSettings();
+   
+   connect(moveTimer,SIGNAL(timeout()),SLOT(nextLoopStep()));
+   connect(this,SIGNAL(startedThinking()),SLOT(setWaitCursor()));
+   connect(this,SIGNAL(stoppedThinking()),SLOT(setNormalCursor()));
+   connect(this,SIGNAL(startedMoving()),SLOT(setWaitCursor()));
+   connect(this,SIGNAL(stoppedMoving()),SLOT(setNormalCursor()));
+   connect(this,SIGNAL(playerWon(int)),SLOT(stopActivities()));
+
+   setNormalCursor();
+
+   emit playerChanged(One);
+}
+   
+void KCubeBoxWidget::initCubes()
+{
+   const int s=dim();
+   int i,j;
+   
+   // create Layout
+   layout=new QGridLayout(this,s,s);
+   
+
+   for(i=0;i<s;i++)
+   {
+      layout->setRowStretch(i,1);
+      layout->setColStretch(i,1);
+   }         
+   
+   
+   // create new cubes
+   cubes = new KCubeWidget**[s];
+   for(i=0;i<s;i++)
+   {
+      cubes[i]=new KCubeWidget*[s];
+   }
+   for(i=0;i<s;i++)
+      for(j=0;j<s;j++)
+      {
+         cubes[i][j]=new KCubeWidget(this);
+         cubes[i][j]->setCoordinates(i,j);
+         layout->addWidget(cubes[i][j],i,j);
+         cubes[i][j]->show();
+         connect(cubes[i][j],SIGNAL(clicked(int,int,bool)),SLOT(stopHint()));
+         connect(cubes[i][j],SIGNAL(clicked(int,int,bool)),SLOT(checkClick(int,int,bool)));
+      }
+   
+   // initialize cubes  
+   int max=dim()-1;
+      
+   cubes[0][0]->setMax(2);
+   cubes[0][max]->setMax(2);
+   cubes[max][0]->setMax(2);
+   cubes[max][max]->setMax(2);
+   
+   for(i=1;i<max;i++)
+   {
+      cubes[i][0]->setMax(3);
+      cubes[i][max]->setMax(3);
+      cubes[0][i]->setMax(3);
+      cubes[max][i]->setMax(3);
+   }
+   
+   for(i=1;i<max;i++)
+     for(j=1;j<max;j++)
+      {
+         cubes[i][j]->setMax(4);
+      }
+      
+}
+
+QSize  KCubeBoxWidget::sizeHint() const
+{
+   return QSize(400,400);
+}
+
+void  KCubeBoxWidget::deleteCubes()
+{
+   if(layout)
+      delete layout;
+     
+   CubeBoxBase<KCubeWidget>::deleteCubes();
+}
+ 
+
+/* ***************************************************************** **
+**                   other private functions                         **
+** ***************************************************************** */
+
+void KCubeBoxWidget::doMove(int row,int column)
+{
+   // if a move hasn't finished yet don't do another move
+   if(isActive())
+      return;
+
+   // for undo-function copy field
+   *undoBox=*this;
+
+   cubes[row][column]->increase((Cube::Owner)currentPlayer);
+
+   if(cubes[row][column]->overMax())
+   {
+      KCubeWidget::enableClicks(false);
+      startLoop();
+   }
+   else
+      changePlayer();      
+}
+
+void KCubeBoxWidget::startLoop()
+{
+   emit startedMoving();
+   
+   KCubeWidget::enableClicks(false);
+   
+   loop.row=0;
+   loop.column=0;
+   loop.finished=true;
+   
+   moveTimer->start(moveDelay);
+}
+
+void KCubeBoxWidget::stopLoop()
+{
+   moveTimer->stop();
+   emit stoppedMoving();
+   KCubeWidget::enableClicks(true);
+}
+
+void KCubeBoxWidget::nextLoopStep()
+{
+   // search cube with to many points
+   while(!cubes[loop.row][loop.column]->overMax())
+   {
+      loop.column++;
+      if(loop.column==dim())
+      {
+         if(loop.row==dim()-1)
+	 {
+	    if(!loop.finished)
+	    {
+               loop.row=0;
+               loop.column=0;
+               loop.finished=true;
+               return;
+	    }
+	    else   // loop finished
+	    {
+	       stopLoop();
+	       changePlayer();
+		         
+	       return;
+            }
+         }
+         else
+         {
+            loop.row++;
+            loop.column=0;
+         }
+      }
+   }
+    
+ 
+   increaseNeighbours(currentPlayer,loop.row,loop.column);
+   cubes[loop.row][loop.column]->decrease();
+   loop.finished=false;
+    
+   if(hasPlayerWon(currentPlayer))
+   {
+      emit playerWon((int)currentPlayer);
+      stopLoop();
+      return;
+   }
+}
+
+bool KCubeBoxWidget::hasPlayerWon(Player player)
+{
+   for(int i=0;i<dim();i++)
+      for(int j=0;j<dim();j++)
+      {
+         if(cubes[i][j]->owner()!=(Cube::Owner)player)
+         {
+            return false;
+         }
+      }
+   return true;
+}
+
+KCubeBoxWidget::Player KCubeBoxWidget::changePlayer()
+{
+   currentPlayer=(currentPlayer==One)? Two : One;
+
+   emit playerChanged(currentPlayer);
+   checkComputerplayer(currentPlayer);
+   KCubeWidget::enableClicks(true);
+   return currentPlayer;
+}
+
+
+void KCubeBoxWidget::increaseNeighbours(KCubeBoxWidget::Player forWhom,int row,int column)
+{
+   KCubeWidget::Owner _player = (KCubeWidget::Owner)(forWhom);
+
+   if(row==0)
+   {
+    	if(column==0)  // top left corner
+	{
+	   cubes[0][1]->increase(_player);
+	   cubes[1][0]->increase(_player);
+	   return;
+	}
+	else if(column==dim()-1)  // top right corner
+	{
+	   cubes[0][dim()-2]->increase(_player);
+	   cubes[1][dim()-1]->increase(_player);
+	   return;
+	}
+	else  // top edge
+	{
+	   cubes[0][column-1]->increase(_player);
+	   cubes[0][column+1]->increase(_player);
+	   cubes[1][column]->increase(_player);
+	   return;
+	}
+   }
+   else if(row==dim()-1)
+   {
+      if(column==0)  // left bottom corner
+      {
+         cubes[dim()-2][0]->increase(_player);
+         cubes[dim()-1][1]->increase(_player);
+         return;
+      }
+
+      else if(column==dim()-1) // right bottom corner
+      {
+         cubes[dim()-2][dim()-1]->increase(_player);
+         cubes[dim()-1][dim()-2]->increase(_player);
+	      return;
+      }
+      else  // bottom edge
+      {
+ 	      cubes[dim()-1][column-1]->increase(_player);
+	      cubes[dim()-1][column+1]->increase(_player);
+	      cubes[dim()-2][column]->increase(_player);
+	      return;
+      }
+   }
+   else if(column==0) // left edge
+   {
+      cubes[row-1][0]->increase(_player);
+      cubes[row+1][0]->increase(_player);
+      cubes[row][1]->increase(_player);
+      return;
+   }
+   else if(column==dim()-1)  // right edge
+   {
+      cubes[row-1][dim()-1]->increase(_player);
+      cubes[row+1][dim()-1]->increase(_player);
+      cubes[row][dim()-2]->increase(_player);
+      return;
+   }
+   else
+   {
+      cubes[row][column-1]->increase(_player);
+      cubes[row][column+1]->increase(_player);
+      cubes[row-1][column]->increase(_player);
+      cubes[row+1][column]->increase(_player);
+      return;
+   }
+
+
+}
+
+#include "kcubeboxwidget.moc"
+
diff --git a/kjumpingcube/kcubeboxwidget.h b/kjumpingcube/kcubeboxwidget.h
new file mode 100644
index 00000000..ff2f4ac0
--- /dev/null
+++ b/kjumpingcube/kcubeboxwidget.h
@@ -0,0 +1,188 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef KCUBEBOXWIDGET_H
+#define KCUBEBOXWIDGET_H
+
+#include "cubeboxbase.h"
+#include "kcubewidget.h"
+#include "brain.h"
+#include <qwidget.h>
+
+class QGridLayout;
+class CubeBox;
+class QPalette;
+class QTimer;
+class KConfigBase;
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+*@internal
+*/
+struct Loop
+{
+   int row;
+   int column;
+   bool finished;
+};
+
+
+class KCubeBoxWidget : public QWidget , public CubeBoxBase<KCubeWidget>
+{
+   Q_OBJECT
+public:
+   KCubeBoxWidget(const int dim=1,QWidget *parent=0,const char *name=0);
+      
+   KCubeBoxWidget(CubeBox& box, QWidget *parent=0,const char *name=0);
+   KCubeBoxWidget(const KCubeBoxWidget& box,QWidget *parent=0,const char *name=0);
+   virtual ~KCubeBoxWidget();
+   
+   KCubeBoxWidget& operator= (CubeBox& box);
+   KCubeBoxWidget& operator= ( const KCubeBoxWidget& box);
+   
+   /**
+   * reset cubebox for a new game
+   */
+   void reset();
+  
+   /** undo last move */
+   void undo();
+   
+   /**
+   * set colors that are used to show owners of the cubes
+   *
+   * @param forWhom for which player the color should be set
+   * @param color  color for player one
+   */
+   void setColor(Player forWhom,QPalette color);
+   /**
+   * sets number of Cubes in a row/column to 'size'.
+   */
+   virtual void setDim(int dim);
+  
+   /**
+   * sets player 'player' as computer or human
+   *
+   * @param player 
+   * @param flag: true for computer, false for human
+   */
+   void setComputerplayer(Player player,bool flag);
+    
+   /** returns current skill, according to Prefs::EnumSkill */
+   int skill() const;
+
+   /** returns true if player 'player' is a computerPlayer */
+   bool isComputer(Player player) const;
+  
+   /** returns true if CubeBox is doing a move or getting a hint */
+   bool isActive() const;
+   bool isMoving() const;
+
+   /** returns current Color for Player �forWhom� */
+   QPalette color(Player forWhom);
+
+   /**
+   * checks if 'player' is a computerplayer an computes next move if TRUE
+   */
+   void checkComputerplayer(Player player);
+ 
+   inline void saveGame(KConfigBase *c) { saveProperties(c); }
+   inline void restoreGame(KConfigBase *c) { readProperties(c); } 
+  
+public slots:
+   /** stops all activities like getting a hint or doing a move */
+   void stopActivities();
+   /**
+    * computes a possibility to move and shows it by highlightning
+    * this cube
+    */
+   void getHint();
+  
+  void loadSettings();
+  
+signals:
+   void playerChanged(int newPlayer);
+   void playerWon(int player);
+   void startedMoving();
+   void startedThinking();
+   void stoppedMoving();
+   void stoppedThinking();
+
+protected:
+   virtual QSize sizeHint() const;
+   virtual void deleteCubes();
+   virtual void initCubes(); 
+
+   void saveProperties(KConfigBase *);
+   void readProperties(KConfigBase *);
+
+protected slots:
+   /** sets the cursor to an waitcursor */
+   void setWaitCursor();
+   /** restores the original cursor */
+   void setNormalCursor();
+  
+private:
+   void init();
+ 
+   QGridLayout *layout;
+   CubeBox *undoBox;
+   Brain brain;
+   
+   QTimer *moveTimer;
+   int moveDelay;
+   Loop loop;
+   /** */
+   void startLoop();
+   /** */
+   void stopLoop();
+  
+   Player changePlayer();
+   bool hasPlayerWon(Player player); 
+   bool computerPlOne;
+   bool computerPlTwo;
+  
+   /**
+   * increases the cube at row 'row' and column 'column' ,
+   * and starts the Loop for checking the playingfield 
+   */
+   void doMove(int row,int column);
+
+   void increaseNeighbours(KCubeBoxWidget::Player forWhom,int row,int column);
+
+private slots:   
+   void nextLoopStep();
+   /**
+   * checks if cube at ['row','column'] is clickable by the current player.
+   * if true, it increases this cube and checks the playingfield  
+   */
+   bool checkClick(int row,int column,bool isClick);
+
+   /** turns off blinking, if an other cube is clicked */
+   void stopHint();
+
+};
+
+#endif // KCUBEBOXWIDGET_H
+
diff --git a/kjumpingcube/kcubewidget.cpp b/kjumpingcube/kcubewidget.cpp
new file mode 100644
index 00000000..f23e3cce
--- /dev/null
+++ b/kjumpingcube/kcubewidget.cpp
@@ -0,0 +1,348 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include "kcubewidget.h"
+
+#include <qpainter.h>
+#include <qtimer.h>
+
+#include <kapplication.h>
+#include <kdebug.h>
+
+/* ****************************************************** **
+**                 static elements                        **
+** ****************************************************** */
+bool KCubeWidget::_clicksAllowed=true;
+QPalette KCubeWidget::color1;
+QPalette KCubeWidget::color2;
+
+ 
+void KCubeWidget::enableClicks(bool flag)
+{
+   _clicksAllowed=flag;
+}
+
+
+void KCubeWidget::setColor(Owner forWhom, QPalette newPalette)
+{
+   if(forWhom==One)
+   {   
+      color1=newPalette;
+   }
+   else if(forWhom==Two)
+   {
+      color2=newPalette;
+   }
+} 
+
+QPalette KCubeWidget::color(Owner forWhom)
+{
+   QPalette color;
+   if(forWhom==One)
+   {
+      color=color1;
+   }
+   else if(forWhom==Two)
+   {
+      color=color2;
+   }
+   
+   return color;
+}
+
+
+/* ****************************************************** **
+**                 public functions                       **
+** ****************************************************** */
+
+KCubeWidget::KCubeWidget(QWidget* parent,const char* name
+                  ,Owner owner,int value,int max)
+              : QFrame(parent,name),
+                Cube(owner,value,max)
+{
+  setFrameStyle(Panel|Raised);
+  //setLineWidth(2);
+  setMinimumSize(20,20); 
+
+  setCoordinates(0,0);
+  
+  //initialize hintTimer
+  // will be automatically destroyed by the parent
+  hintTimer = new QTimer(this);
+  hintCounter=0;
+  connect(hintTimer,SIGNAL(timeout()),SLOT(hint()));
+  
+  setPalette(kapp->palette());
+
+  // show values
+  repaint(false);
+}
+
+KCubeWidget::~KCubeWidget()
+{
+}
+
+
+KCubeWidget& KCubeWidget::operator=(const Cube& cube)
+{
+   if(this!=&cube)
+   {
+      setOwner(cube.owner());
+      setValue(cube.value());
+      setMax(cube.max());
+   }
+   
+   return *this;
+}
+
+KCubeWidget& KCubeWidget::operator=(const KCubeWidget& cube)
+{
+   if(this!=&cube)
+   {
+      setOwner(cube.owner());
+      setValue(cube.value());
+      setMax(cube.max());
+   }
+
+   return *this;
+}
+KCubeWidget::Owner KCubeWidget::setOwner(Owner newOwner)
+{
+   Owner old=Cube::setOwner(newOwner);
+   
+   updateColors();
+
+   return old;
+}
+
+void KCubeWidget::setValue(int newValue)
+{
+   Cube::setValue(newValue);
+   update();
+}
+
+
+void KCubeWidget::showHint(int interval,int number)
+{
+   if(hintTimer->isActive())
+      return;
+   
+   hintCounter=2*number;
+   hintTimer->start(interval);
+}
+
+
+void KCubeWidget::animate(bool )
+{
+}
+
+
+void KCubeWidget::setCoordinates(int row,int column)
+{
+   _row=row;
+   _column=column;
+}
+
+int KCubeWidget::row() const
+{
+   return _row;
+}
+
+int KCubeWidget::column() const
+{
+   return _column;
+}
+
+
+
+
+/* ****************************************************** **
+**                   public slots                         **
+** ****************************************************** */
+
+void KCubeWidget::reset()
+{
+  setValue(1);
+  setOwner(Nobody);
+}
+
+
+void KCubeWidget::updateColors()
+{
+  if(owner()==One)
+    setPalette(color1);
+  else if(owner()==Two)
+    setPalette(color2);
+  else if(owner()==Nobody)
+     setPalette(kapp->palette());
+}
+
+void KCubeWidget::stopHint()
+{
+   if(hintTimer->isActive())
+   {
+      hintTimer->stop();
+      setBackgroundMode(PaletteBackground);
+   }
+
+}
+
+
+
+/* ****************************************************** **
+**                   protected slots                      **
+** ****************************************************** */
+
+void KCubeWidget::hint()
+{   
+   hintCounter--;
+   if(hintCounter%2==1)
+   {
+      setBackgroundMode(PaletteLight);
+   }
+   else
+   {
+      setBackgroundMode(PaletteBackground);
+   }
+   if(hintCounter==0)
+   {
+      stopHint();
+   }
+}
+
+
+
+/* ****************************************************** **
+**                   Event handler                        **
+** ****************************************************** */
+
+void KCubeWidget::mouseReleaseEvent(QMouseEvent *e)
+{
+  // only accept click if it was inside this cube
+  if(e->x()< 0 || e->x() > width() || e->y() < 0 || e->y() > height())
+    return;
+
+  if(e->button() == LeftButton && _clicksAllowed)
+  {
+    stopHint();
+    emit clicked(row(),column(),true);
+  }
+}
+
+
+
+void KCubeWidget::drawContents(QPainter *painter)
+{
+  QRect contents=contentsRect();
+  QPixmap buffer(contents.size());
+  buffer.fill(this,contents.topLeft());
+  QPainter *p=new QPainter;
+  p->begin(&buffer);
+  int  h=contents.height();
+  int  w=contents.width();
+  int circleSize=(h<w?h:w)/7;
+  int points=value();
+  QBrush brush("black");
+  QPen pen("black");
+  p->setBrush(brush);
+  p->setPen(pen);
+  switch(points)
+    {
+    case 1:
+      p->drawEllipse(w/2-circleSize/2,h/2-circleSize/2,circleSize,circleSize);
+      break;
+
+    case 3:
+      p->drawEllipse(w/2-circleSize/2,h/2-circleSize/2,circleSize,circleSize);
+    case 2:
+      p->drawEllipse(w/4-circleSize/2,h/4-circleSize/2,circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,3*h/4-circleSize/2,
+		     circleSize,circleSize);
+      break;
+      
+    case 5:
+      p->drawEllipse(w/2-circleSize/2,h/2-circleSize/2,circleSize,circleSize);
+    case 4:
+      p->drawEllipse(w/4-circleSize/2,h/4-circleSize/2,circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,h/4-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/4-circleSize/2,3*h/4-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,3*h/4-circleSize/2,
+		     circleSize,circleSize);
+      break;
+
+    case 8:
+      p->drawEllipse(w/2-circleSize/2,2*h/3-circleSize/2,
+		     circleSize,circleSize);
+    case 7:
+      p->drawEllipse(w/2-circleSize/2,h/3-circleSize/2,
+		     circleSize,circleSize);
+    case 6:
+      p->drawEllipse(w/4-circleSize/2,h/6-circleSize/2,circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/4-circleSize/2,3*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,3*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/4-circleSize/2,5*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,5*h/6-circleSize/2,
+		     circleSize,circleSize);
+      break;
+     
+   
+    case 9:
+      p->drawEllipse(w/4-circleSize/2,h/6-circleSize/2,circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/4-circleSize/2,3*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,3*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/4-circleSize/2,5*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(3*w/4-circleSize/2,5*h/6-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/2-circleSize/2,2*h/7-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/2-circleSize/2,5*h/7-circleSize/2,
+		     circleSize,circleSize);
+      p->drawEllipse(w/2-circleSize/2,h/2-circleSize/2,
+		     circleSize,circleSize);
+      break; 
+
+    default:
+      kdDebug() << "cube had value " << points << endl;
+      QString s;
+      s.sprintf("%d",points);
+      p->drawText(w/2,h/2,s);
+      break;
+    }
+   p->end();
+   delete p;	
+   
+   painter->drawPixmap(contents.topLeft(),buffer);
+
+}
+
+#include "kcubewidget.moc"
diff --git a/kjumpingcube/kcubewidget.h b/kjumpingcube/kcubewidget.h
new file mode 100644
index 00000000..f0d8d8cd
--- /dev/null
+++ b/kjumpingcube/kcubewidget.h
@@ -0,0 +1,119 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef KCUBEWIDGET_H
+#define KCUBEWIDGET_H
+
+#include <qframe.h>
+#include "cube.h"
+
+class QPalette;
+class QTimer;
+
+
+/**
+* 
+*/
+class KCubeWidget : public QFrame , public Cube 
+{
+   Q_OBJECT
+         
+public:
+   /** constructs a new KCubeWidget*/
+   KCubeWidget(QWidget* parent=0,const char* name=0
+                    ,Owner owner=Cube::Nobody,int value=1,int max=0);  
+   virtual ~KCubeWidget();   
+   
+   virtual Owner setOwner(Owner newOwner); 
+   virtual void setValue(int newValue);
+   
+   
+   /** takes the information from a Cube */
+   KCubeWidget& operator=(const Cube&);
+   KCubeWidget& operator=(const KCubeWidget&);
+   
+   /** shows a tip e.g. blinks with the interval 500 and number times */
+   void showHint(int interval=500,int number=5);
+   /** stops showing a hint */
+   void stopHint();
+   
+   /** 
+   * animates the cube if possible (if feature is enabled)
+   * In KCubeWidget this function does nothing, it's just for having
+   * a public interface for all classes that inherits KCubeWidget 
+   */
+   virtual void animate(bool flag);
+   
+   /** 
+   * sets the coordinates of the Cube in a Cubebox;
+   * needed for identification when clicked.
+   */ 
+   void setCoordinates(int row,int column);
+   /** returns the row */
+   int row() const;
+   /** returns the column */
+   int column() const;
+   
+   /** enables or disables possibility to click a cube*/
+   static void enableClicks(bool flag);
+   static void setColor(Owner forWhom, QPalette newPalette); 
+   static QPalette color(Owner forWhom);
+   
+public slots:
+   /** resets the Cube to default values */
+   virtual void reset();
+   /** shows changed colors*/
+   virtual void updateColors();
+      
+signals:
+   void clicked(int row,int column,bool isClick);
+   
+protected:
+   /** checks, if mouseclick was inside this cube*/
+   virtual void mouseReleaseEvent(QMouseEvent*);
+   
+   /** refreshs the contents of the Cube */
+   virtual void drawContents(QPainter*);
+ 
+   
+  
+   int hintCounter;
+   
+protected slots:
+   /** 
+   * To this function the hintTimer is connected. 
+   * It manage a periodical way of showing a hint.
+   */
+   virtual void hint(); 
+
+private:
+   int _row;
+   int _column;
+   
+   QTimer *hintTimer;
+   
+   static bool _clicksAllowed;
+   static QPalette color1;
+   static QPalette color2;
+};
+
+
+#endif // KCUBEWIDGET_H
diff --git a/kjumpingcube/kjumpingcube.cpp b/kjumpingcube/kjumpingcube.cpp
new file mode 100644
index 00000000..13619d99
--- /dev/null
+++ b/kjumpingcube/kjumpingcube.cpp
@@ -0,0 +1,278 @@
+/*****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include "kjumpingcube.h"
+#include "kcubeboxwidget.h"
+#include "version.h"
+
+// Settings
+#include "settings.h"
+#include <kconfigdialog.h>
+
+#include "prefs.h"
+
+#include <qregexp.h>
+
+#include <klocale.h>
+#include <kfiledialog.h>
+#include <kmessagebox.h>
+#include <ktempfile.h>
+#include <kstdgameaction.h>
+#include <kaction.h>
+#include <kio/netaccess.h>
+#include <kstatusbar.h>
+
+#define ID_STATUS_TURN_TEXT 1000
+#define ID_STATUS_TURN      2000
+
+#define MESSAGE_TIME 2000
+
+
+KJumpingCube::KJumpingCube()
+  : view(new KCubeBoxWidget(5, this, "KCubeBoxWidget"))
+{
+   connect(view,SIGNAL(playerChanged(int)),SLOT(changePlayer(int)));
+   connect(view,SIGNAL(stoppedMoving()),SLOT(disableStop()));
+   connect(view,SIGNAL(stoppedThinking()),SLOT(disableStop()));
+   connect(view,SIGNAL(startedMoving()),SLOT(enableStop_Moving()));
+   connect(view,SIGNAL(startedThinking()),SLOT(enableStop_Thinking()));
+   connect(view,SIGNAL(playerWon(int)),SLOT(showWinner(int)));
+
+   // tell the KMainWindow that this is indeed the main widget
+   setCentralWidget(view);
+
+   // init statusbar
+   QString s = i18n("Current player:");
+   statusBar()->insertItem(s,ID_STATUS_TURN_TEXT, false);
+   statusBar()->changeItem(s,ID_STATUS_TURN_TEXT);
+   statusBar()->setItemAlignment (ID_STATUS_TURN_TEXT, AlignLeft | AlignVCenter);
+   statusBar()->setFixedHeight( statusBar()->sizeHint().height() );
+ 
+   currentPlayer = new QWidget(this, "currentPlayer");
+   currentPlayer->setFixedWidth(40);
+   statusBar()->addWidget(currentPlayer, ID_STATUS_TURN, false);
+   statusBar()->setItemAlignment(ID_STATUS_TURN, AlignLeft | AlignVCenter);
+
+   initKAction();
+   changePlayer(1);
+}
+
+void KJumpingCube::initKAction() {
+  KStdGameAction::gameNew(this, SLOT(newGame()), actionCollection());
+  KStdGameAction::load(this, SLOT(openGame()), actionCollection());
+  KStdGameAction::save(this, SLOT(save()), actionCollection());
+  KStdGameAction::saveAs(this, SLOT(saveAs()), actionCollection());
+  KStdGameAction::quit(this, SLOT(close()), actionCollection());
+
+  hintAction = KStdGameAction::hint(view, SLOT(getHint()), actionCollection());
+  stopAction = new KAction(i18n("Stop &Thinking"), "stop",
+  Qt::Key_Escape, this, SLOT(stop()), actionCollection(), "game_stop");
+  stopAction->setEnabled(false);
+  undoAction = KStdGameAction::undo(this, SLOT(undo()), actionCollection());
+  undoAction->setEnabled(false);
+  KStdAction::preferences(this, SLOT(showOptions()), actionCollection());
+
+  setupGUI();
+}
+
+void KJumpingCube::newGame(){
+   undoAction->setEnabled(false);
+   view->reset();
+   statusBar()->message(i18n("New Game"),MESSAGE_TIME);
+}
+
+void KJumpingCube::saveGame(bool saveAs)
+{
+   if(saveAs || gameURL.isEmpty())
+   {
+      int result=0;
+      KURL url;
+
+      do
+      {
+         url = KFileDialog::getSaveURL(gameURL.url(),"*.kjc",this,0);
+
+         if(url.isEmpty())
+            return;
+
+         // check filename
+         QRegExp pattern("*.kjc",true,true);
+         if(!pattern.exactMatch(url.filename()))
+         {
+            url.setFileName( url.filename()+".kjc" );
+         }
+
+         if(KIO::NetAccess::exists(url,false,this))
+         {
+            QString mes=i18n("The file %1 exists.\n"
+               "Do you want to overwrite it?").arg(url.url());
+            result = KMessageBox::warningContinueCancel(this, mes, QString::null, i18n("Overwrite"));
+            if(result==KMessageBox::Cancel)
+               return;
+         }
+      }
+      while(result==KMessageBox::No);
+
+      gameURL=url;
+   }
+
+   KTempFile tempFile;
+   tempFile.setAutoDelete(true);
+   KSimpleConfig config(tempFile.name());
+
+   config.setGroup("KJumpingCube");
+   config.writeEntry("Version",KJC_VERSION);
+   config.setGroup("Game");
+   view->saveGame(&config);
+   config.sync();
+
+   if(KIO::NetAccess::upload( tempFile.name(),gameURL,this ))
+   {
+      QString s=i18n("game saved as %1");
+      s=s.arg(gameURL.url());
+      statusBar()->message(s,MESSAGE_TIME);
+   }
+   else
+   {
+      KMessageBox::sorry(this,i18n("There was an error in saving file\n%1").arg(gameURL.url()));
+   }
+}
+
+void KJumpingCube::openGame()
+{
+   bool fileOk=true;
+   KURL url;
+
+   do
+   {
+      url = KFileDialog::getOpenURL( gameURL.url(), "*.kjc", this, 0 );
+      if( url.isEmpty() )
+         return;
+      if(!KIO::NetAccess::exists(url,true,this))
+      {
+         QString mes=i18n("The file %1 does not exist!").arg(url.url());
+         KMessageBox::sorry(this,mes);
+         fileOk=false;
+      }
+   }
+   while(!fileOk);
+
+   QString tempFile;
+   if( KIO::NetAccess::download( url, tempFile, this ) )
+   {
+      KSimpleConfig config(tempFile,true);
+      config.setGroup("KJumpingCube");
+      if(!config.hasKey("Version"))
+      {
+         QString mes=i18n("The file %1 isn't a KJumpingCube gamefile!")
+           .arg(url.url());
+         KMessageBox::sorry(this,mes);
+         return;
+      }
+
+      gameURL=url;
+      config.setGroup("Game");
+      view->restoreGame(&config);
+
+      undoAction->setEnabled(false);
+
+      KIO::NetAccess::removeTempFile( tempFile );
+   }
+   else
+      KMessageBox::sorry(this,i18n("There was an error loading file\n%1").arg( url.url() ));
+}
+
+void KJumpingCube::stop()
+{
+
+   if(view->isMoving())
+       undoAction->setEnabled(true);
+
+   view->stopActivities();
+
+   statusBar()->message(i18n("stopped activity"),MESSAGE_TIME);
+}
+
+void KJumpingCube::undo()
+{
+   if(view->isActive())
+      return;
+   view->undo();
+   undoAction->setEnabled(false);
+}
+
+void KJumpingCube::changePlayer(int newPlayer)
+{
+   undoAction->setEnabled(true);
+   currentPlayer->setBackgroundColor(newPlayer == 1 ? Prefs::color1() : Prefs::color2());
+   currentPlayer->repaint();
+}
+
+void KJumpingCube::showWinner(int player) {
+  QString s=i18n("Winner is Player %1!").arg(player);
+  KMessageBox::information(this,s,i18n("Winner"));
+  view->reset();
+}
+
+void KJumpingCube::disableStop()
+{
+//   toolBar()->setItemEnabled(ID_GAME_STOP_HINT,false);
+//   game->setItemEnabled(ID_GAME_STOP_HINT,false);
+//   toolBar()->setItemEnabled(ID_GAME_HINT,true);
+//   game->setItemEnabled(ID_GAME_HINT,true);
+  stopAction->setEnabled(false);
+  hintAction->setEnabled(true);
+  statusBar()->clear();
+}
+
+
+void KJumpingCube::enableStop_Moving()
+{
+//   toolBar()->setItemEnabled(ID_GAME_STOP_HINT,true);
+//   game->setItemEnabled(ID_GAME_STOP_HINT,true);
+//   toolBar()->setItemEnabled(ID_GAME_HINT,false);
+//   game->setItemEnabled(ID_GAME_HINT,false);
+  stopAction->setEnabled(true);
+  hintAction->setEnabled(false);
+  statusBar()->message(i18n("Performing move."));
+}
+
+void KJumpingCube::enableStop_Thinking(){
+  stopAction->setEnabled(true);
+  hintAction->setEnabled(false);
+  statusBar()->message(i18n("Computing next move."));
+}
+
+/**
+ * Show Configure dialog.
+ */
+void KJumpingCube::showOptions(){
+  if(KConfigDialog::showDialog("settings"))
+    return;
+
+  KConfigDialog *dialog = new KConfigDialog(this, "settings", Prefs::self(), KDialogBase::Swallow);
+  dialog->addPage(new Settings(0, "General"), i18n("General"), "package_settings");
+  connect(dialog, SIGNAL(settingsChanged()), view, SLOT(loadSettings()));
+  dialog->show();
+}
+
+#include "kjumpingcube.moc"
+
diff --git a/kjumpingcube/kjumpingcube.desktop b/kjumpingcube/kjumpingcube.desktop
new file mode 100644
index 00000000..3df8f3d6
--- /dev/null
+++ b/kjumpingcube/kjumpingcube.desktop
@@ -0,0 +1,102 @@
+[Desktop Entry]
+Name=KJumpingCube
+Name[af]=Kjumpingcube
+Name[ar]=لعبة المكعب القافز (KJumpingCube)
+Name[az]=K Hoppanan Kub
+Name[be]=Скокаючы кубік
+Name[bn]=কে-জাম্পিংকিউব
+Name[br]=KDiñsALamm
+Name[eo]=Saltanta kubo
+Name[hi]=के-जम्पिंगक्यूब
+Name[hu]=Ugráló kocka
+Name[is]=Hoppandi kubbur
+Name[ne]=केडीई जम्पिङ क्युब
+Name[pa]=ਕੇ-ਜੰਪ ਘਣ
+Name[pl]=Skaczący sześcian
+Name[pt]=Cubo Saltitão
+Name[pt_BR]=KSaltandoCubo
+Name[ro]=Cubul săritor
+Name[sk]=KSkákajúca kocka
+Name[sv]=Kjumpingcube
+Name[ta]=கேகுதிக்கும் கனசதுரம்
+Name[tg]=KКубикҳои Ҷиҳанда
+Name[tr]=Zıplayan Küp
+Name[xh]=Ityhubhu yeKJumping
+Name[zh_TW]=KJumpingCube 跳躍立方體
+Exec=kjumpingcube -caption "%c" %i %m
+Icon=kjumpingcube
+Type=Application
+DocPath=kjumpingcube/index.html
+GenericName=Tactical Game
+GenericName[af]=Taktiese Speletjie
+GenericName[ar]=لعبة تكتيكية
+GenericName[az]=Taktik oyunu
+GenericName[be]=Тактычная гульня
+GenericName[bg]=Тактическа игра
+GenericName[bn]=কৌশলের খেলা
+GenericName[br]=C'hoari a vrezelekaouriezh
+GenericName[bs]=Taktička igra
+GenericName[ca]=Joc de tàctica
+GenericName[cs]=Taktická hra
+GenericName[cy]=Gêm Dactegol
+GenericName[da]=Taktisk spil
+GenericName[de]=Taktikspiel
+GenericName[el]=Παιχνίδι τακτικής
+GenericName[eo]=Taktika ludo
+GenericName[es]=Juego de táctica
+GenericName[et]=Taktikamäng
+GenericName[eu]=Joko taktikoa
+GenericName[fa]=بازی برنامه‌ریزی‌شده
+GenericName[fi]=Taktiikkapeli
+GenericName[fo]=Taktiskt spæl
+GenericName[fr]=Jeu de tactique
+GenericName[ga]=Cluiche Taicticiúil
+GenericName[gl]=Xogo de Táctica
+GenericName[he]=משחק טקטי
+GenericName[hi]=रणनीतिक खेल
+GenericName[hr]=Taktička igra
+GenericName[hu]=Logikai
+GenericName[id]=Permainan Taktik
+GenericName[is]=Herkænskuleikur
+GenericName[it]=Gioco di tattica
+GenericName[ja]=戦略的ゲーム
+GenericName[km]=ល្បែង​ក្បួន​យុទ្ធសាស្ត្រ
+GenericName[ko]=전략 게임
+GenericName[lt]=Taktinis žaidimas
+GenericName[lv]=Taktiskā spēle
+GenericName[mk]=Тактичка игра
+GenericName[mt]=Logħba ta' tattika
+GenericName[nb]=Taktikk-spill
+GenericName[nds]=Taktikspeel
+GenericName[ne]=युक्तिसंगत खेल
+GenericName[nl]=Tactisch spel
+GenericName[nn]=Taktisk spel
+GenericName[pa]=ਟਾਕਟੀਕਲ ਖੇਡ
+GenericName[pl]=Gra taktyczna
+GenericName[pt]=Jogo de Estratégia
+GenericName[pt_BR]=Jogo Tático
+GenericName[ro]=Un joc de tactică
+GenericName[ru]=Тактическая игра
+GenericName[rw]=Umukino Mugambi
+GenericName[se]=Taktihkkaspeallu
+GenericName[sk]=Taktická hra
+GenericName[sl]=Taktična igra
+GenericName[sr]=Тактичка игра
+GenericName[sr@Latn]=Taktička igra
+GenericName[sv]=Taktikspel
+GenericName[ta]=தந்திரமான விளையாட்டு
+GenericName[tg]=Бозии Тактикӣ
+GenericName[th]=เกมวางแผน
+GenericName[tr]=Taktik oyunu
+GenericName[uk]=Тактична гра
+GenericName[ven]=Mutambo wa Tactical
+GenericName[vi]=Trò chơi chiến thuật 
+GenericName[wa]=Djeu di tactike
+GenericName[xh]=Umdlalo onamaqhinga
+GenericName[zh_CN]=战术游戏
+GenericName[zh_TW]=戰術遊戲
+GenericName[zu]=Umdlalo wamasu
+Terminal=false
+X-KDE-StartupNotify=true
+X-DCOP-ServiceType=Multi
+Categories=Qt;KDE;Game;StrategyGame;
diff --git a/kjumpingcube/kjumpingcube.h b/kjumpingcube/kjumpingcube.h
new file mode 100644
index 00000000..7ed961c7
--- /dev/null
+++ b/kjumpingcube/kjumpingcube.h
@@ -0,0 +1,76 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#ifndef KJUMPINGCUBE_H
+#define KJUMPINGCUBE_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <kmainwindow.h>
+#include <kurl.h>
+
+class KAction;
+class KCubeBoxWidget;
+
+/**
+ * This class serves as the main window for KJumpingCube.  It handles the
+ * menus, toolbars, and status bars.
+ *
+ * @short Main window class
+ * @author Matthias Kiefer <matthias.kiefer@gmx.de>
+ * @version 0.7.2
+ */
+class KJumpingCube : public KMainWindow {
+  Q_OBJECT
+
+public:
+  /** Default Constructor */
+  KJumpingCube();
+
+private:
+  KCubeBoxWidget *view;
+	QWidget *currentPlayer;
+	KAction *undoAction, *stopAction, *hintAction;
+
+  KURL gameURL;
+  void initKAction();
+
+private slots:
+  void newGame();
+  void saveGame(bool saveAs=false);
+  inline void saveAs() { saveGame(true); }
+  inline void save() { saveGame(false); }
+  void openGame();
+  void stop();
+  void undo();
+  void changePlayer(int newPlayer);
+  void showWinner(int);
+  void disableStop();
+  void enableStop_Moving();
+  void enableStop_Thinking();
+
+  void showOptions();
+};
+
+#endif // KJUMPINGCUBE_H
+
diff --git a/kjumpingcube/kjumpingcube.kcfg b/kjumpingcube/kjumpingcube.kcfg
new file mode 100644
index 00000000..ecd27d09
--- /dev/null
+++ b/kjumpingcube/kjumpingcube.kcfg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
+      http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
+  <kcfgfile name="kjumpingcuberc"/>
+  <group name="Game">
+    <entry name="Color1" type="Color">
+      <label>Color of player 1.</label>
+      <default>darkred</default>
+    </entry>
+    <entry name="Color2" type="Color">
+      <label>Color of player 2.</label>
+      <default>darkblue</default>
+    </entry>
+    <entry name="CubeDim" type="Int" min="5" max="10">
+      <label>Size of the playing field.</label>
+      <default>6</default>
+    </entry>
+    <entry name="Skill" type="Enum">
+      <choices>
+        <choice name="Beginner"/>
+        <choice name="Average"/>
+        <choice name="Expert"/>
+      </choices>
+      <label>Skill of the computer player.</label>
+      <default>Average</default>
+    </entry>
+    <entry name="ComputerPlayer1" type="Bool" key="Computer_Pl_1">
+      <label>Whether player 1 is played by the computer.</label>
+      <default>false</default>
+    </entry>
+    <entry name="ComputerPlayer2" type="Bool" key="Computer_Pl_2">
+      <label>Whether player 2 is played by the computer.</label>
+      <default>true</default>
+    </entry>
+  </group>
+</kcfg>
diff --git a/kjumpingcube/kjumpingcubeui.rc b/kjumpingcube/kjumpingcubeui.rc
new file mode 100644
index 00000000..359a87db
--- /dev/null
+++ b/kjumpingcube/kjumpingcubeui.rc
@@ -0,0 +1,20 @@
+<!DOCTYPE kpartgui>
+<kpartgui name="kjumpingcube" version="4">
+
+<MenuBar>
+  <Menu name="game"><text>&amp;Game</text>
+    <Action name="game_stop"/>
+  </Menu>
+</MenuBar>
+
+<ToolBar name="mainToolBar" noMerge="1"><text>Main Toolbar</text>
+    <Action name="game_new"/>
+    <Action name="game_open"/>
+    <Action name="game_save"/>
+    <Separator/>
+    <Action name="game_stop"/>
+    <Action name="game_hint"/>
+    <Action name="move_undo"/>
+</ToolBar>
+
+</kpartgui>
diff --git a/kjumpingcube/main.cpp b/kjumpingcube/main.cpp
new file mode 100644
index 00000000..eda42342
--- /dev/null
+++ b/kjumpingcube/main.cpp
@@ -0,0 +1,58 @@
+/* ****************************************************************************
+  This file is part of the game 'KJumpingCube'
+
+  Copyright (C) 1998-2000 by Matthias Kiefer
+                            <matthias.kiefer@gmx.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.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+**************************************************************************** */
+#include "version.h"
+#include "kjumpingcube.h"
+#include <kapplication.h>
+#include <kcmdlineargs.h>
+#include <kaboutdata.h>
+
+
+static const char description[] =
+	I18N_NOOP("Tactical one or two player game");
+
+// A hack to circumvent tricky i18n issue, not used later on in the code.
+// Both context and contents must be exactly the same as for the entry in
+// kdelibs/kdeui/ui_standards.rc
+static const char dummy[] = I18N_NOOP2("Menu title", "&Move");
+
+int main(int argc, char *argv[])
+{
+    KAboutData aboutData( "kjumpingcube", I18N_NOOP("KJumpingCube"),
+                          KJC_VERSION, description, KAboutData::License_GPL,
+                          "(c) 1998-2000, Matthias Kiefer");
+    aboutData.addAuthor("Matthias Kiefer",0, "matthias.kiefer@gmx.de");
+    aboutData.addAuthor("Benjamin Meyer",I18N_NOOP("Various improvements"), "ben+kjumpingcube@meyerhome.net");
+    KCmdLineArgs::init( argc, argv, &aboutData );
+
+    KApplication app;
+    KGlobal::locale()->insertCatalogue("libkdegames");
+
+    // All session management is handled in the RESTORE macro
+	if (app.isRestored())
+        RESTORE(KJumpingCube)
+    else {
+		KJumpingCube *kjumpingcube = new KJumpingCube;
+		app.setMainWidget(kjumpingcube);
+		kjumpingcube->show();
+	}
+   return app.exec();
+}
diff --git a/kjumpingcube/prefs.kcfgc b/kjumpingcube/prefs.kcfgc
new file mode 100644
index 00000000..95d81c69
--- /dev/null
+++ b/kjumpingcube/prefs.kcfgc
@@ -0,0 +1,8 @@
+# Code generation options for kconfig_compiler
+File=kjumpingcube.kcfg
+#IncludeFiles=defines.h
+ClassName=Prefs
+Singleton=true
+#Mutators=true
+#CustomAdditions=true
+#Mutators=true
diff --git a/kjumpingcube/settings.ui b/kjumpingcube/settings.ui
new file mode 100644
index 00000000..43908b76
--- /dev/null
+++ b/kjumpingcube/settings.ui
@@ -0,0 +1,268 @@
+<!DOCTYPE UI><UI version="3.1" stdsetdef="1">
+<class>Settings</class>
+<widget class="QWidget">
+    <property name="name">
+        <cstring>Settings</cstring>
+    </property>
+    <property name="geometry">
+        <rect>
+            <x>0</x>
+            <y>0</y>
+            <width>422</width>
+            <height>214</height>
+        </rect>
+    </property>
+    <vbox>
+        <property name="name">
+            <cstring>unnamed</cstring>
+        </property>
+        <property name="margin">
+            <number>0</number>
+        </property>
+        <property name="spacing">
+            <number>0</number>
+        </property>
+        <widget class="QFrame">
+            <property name="name">
+                <cstring>frame3</cstring>
+            </property>
+            <property name="frameShape">
+                <enum>StyledPanel</enum>
+            </property>
+            <property name="frameShadow">
+                <enum>Plain</enum>
+            </property>
+            <property name="lineWidth">
+                <number>0</number>
+            </property>
+            <grid>
+                <property name="name">
+                    <cstring>unnamed</cstring>
+                </property>
+                <widget class="QGroupBox" row="0" column="1">
+                    <property name="name">
+                        <cstring>groupBox3</cstring>
+                    </property>
+                    <property name="frameShape">
+                        <enum>GroupBoxPanel</enum>
+                    </property>
+                    <property name="frameShadow">
+                        <enum>Sunken</enum>
+                    </property>
+                    <property name="title">
+                        <string>Board Size</string>
+                    </property>
+                    <grid>
+                        <property name="name">
+                            <cstring>unnamed</cstring>
+                        </property>
+                        <widget class="QSlider" row="0" column="0" rowspan="1" colspan="3">
+                            <property name="name">
+                                <cstring>kcfg_CubeDim</cstring>
+                            </property>
+                            <property name="minValue">
+                                <number>5</number>
+                            </property>
+                            <property name="maxValue">
+                                <number>10</number>
+                            </property>
+                            <property name="pageStep">
+                                <number>1</number>
+                            </property>
+                            <property name="value">
+                                <number>6</number>
+                            </property>
+                            <property name="orientation">
+                                <enum>Horizontal</enum>
+                            </property>
+                            <property name="tickmarks">
+                                <enum>Right</enum>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="1" column="0">
+                            <property name="name">
+                                <cstring>textLabel6</cstring>
+                            </property>
+                            <property name="text">
+                                <string>5x5</string>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="1" column="2">
+                            <property name="name">
+                                <cstring>textLabel8</cstring>
+                            </property>
+                            <property name="text">
+                                <string>10x10</string>
+                            </property>
+                            <property name="alignment">
+                                <set>AlignVCenter|AlignRight</set>
+                            </property>
+                        </widget>
+                    </grid>
+                </widget>
+                <spacer row="2" column="0">
+                    <property name="name">
+                        <cstring>spacer1</cstring>
+                    </property>
+                    <property name="orientation">
+                        <enum>Vertical</enum>
+                    </property>
+                    <property name="sizeType">
+                        <enum>Expanding</enum>
+                    </property>
+                    <property name="sizeHint">
+                        <size>
+                            <width>20</width>
+                            <height>16</height>
+                        </size>
+                    </property>
+                </spacer>
+                <widget class="QGroupBox" row="1" column="1">
+                    <property name="name">
+                        <cstring>groupBox7</cstring>
+                    </property>
+                    <property name="title">
+                        <string>Board Color</string>
+                    </property>
+                    <grid>
+                        <property name="name">
+                            <cstring>unnamed</cstring>
+                        </property>
+                        <widget class="KColorButton" row="1" column="1">
+                            <property name="name">
+                                <cstring>kcfg_Color2</cstring>
+                            </property>
+                            <property name="text">
+                                <string></string>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="0" column="0">
+                            <property name="name">
+                                <cstring>textLabel1</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Player 1:</string>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="1" column="0">
+                            <property name="name">
+                                <cstring>textLabel2</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Player 2:</string>
+                            </property>
+                        </widget>
+                        <widget class="KColorButton" row="0" column="1">
+                            <property name="name">
+                                <cstring>kcfg_Color1</cstring>
+                            </property>
+                            <property name="text">
+                                <string></string>
+                            </property>
+                        </widget>
+                    </grid>
+                </widget>
+                <widget class="QGroupBox" row="0" column="0">
+                    <property name="name">
+                        <cstring>groupBox2</cstring>
+                    </property>
+                    <property name="title">
+                        <string>Computer Skill</string>
+                    </property>
+                    <grid>
+                        <property name="name">
+                            <cstring>unnamed</cstring>
+                        </property>
+                        <widget class="QLabel" row="1" column="1">
+                            <property name="name">
+                                <cstring>textLabel4</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Average</string>
+                            </property>
+                            <property name="alignment">
+                                <set>AlignCenter</set>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="1" column="0">
+                            <property name="name">
+                                <cstring>textLabel3</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Beginner</string>
+                            </property>
+                        </widget>
+                        <widget class="QLabel" row="1" column="2">
+                            <property name="name">
+                                <cstring>textLabel5</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Expert</string>
+                            </property>
+                            <property name="alignment">
+                                <set>AlignVCenter|AlignRight</set>
+                            </property>
+                        </widget>
+                        <widget class="QSlider" row="0" column="0" rowspan="1" colspan="3">
+                            <property name="name">
+                                <cstring>kcfg_Skill</cstring>
+                            </property>
+                            <property name="minValue">
+                                <number>0</number>
+                            </property>
+                            <property name="maxValue">
+                                <number>2</number>
+                            </property>
+                            <property name="pageStep">
+                                <number>1</number>
+                            </property>
+                            <property name="orientation">
+                                <enum>Horizontal</enum>
+                            </property>
+                            <property name="tickmarks">
+                                <enum>Right</enum>
+                            </property>
+                        </widget>
+                    </grid>
+                </widget>
+                <widget class="QGroupBox" row="1" column="0">
+                    <property name="name">
+                        <cstring>groupBox1</cstring>
+                    </property>
+                    <property name="title">
+                        <string>Computer Plays As</string>
+                    </property>
+                    <vbox>
+                        <property name="name">
+                            <cstring>unnamed</cstring>
+                        </property>
+                        <widget class="QCheckBox">
+                            <property name="name">
+                                <cstring>kcfg_ComputerPlayer1</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Player 1</string>
+                            </property>
+                        </widget>
+                        <widget class="QCheckBox">
+                            <property name="name">
+                                <cstring>kcfg_ComputerPlayer2</cstring>
+                            </property>
+                            <property name="text">
+                                <string>Player 2</string>
+                            </property>
+                            <property name="checked">
+                                <bool>true</bool>
+                            </property>
+                        </widget>
+                    </vbox>
+                </widget>
+            </grid>
+        </widget>
+    </vbox>
+</widget>
+<layoutdefaults spacing="6" margin="11"/>
+<includehints>
+    <includehint>kcolorbutton.h</includehint>
+</includehints>
+</UI>
diff --git a/kjumpingcube/version.h b/kjumpingcube/version.h
new file mode 100644
index 00000000..bbd8f90d
--- /dev/null
+++ b/kjumpingcube/version.h
@@ -0,0 +1 @@
+#define KJC_VERSION "1.1"