You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegames/kjumpingcube/brain.h

136 lines
4.2 KiB

/* ****************************************************************************
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