path: root/kbackgammon/kbgboard.h

/* Yo Emacs, this -*- C++ -*-

  Copyright (C) 1999-2001 Jens Hoefkens
  jens@hoefkens.com

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  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.

*/


/*

  This file contains the declaration and definition of a couple of
  classes related to the KBgBoard class.

  Effort has been made to keep this class general. Please comment on that
  if you want to use it in your own project. Most of the stuff is private
  and/or in utility classes that shouldn't be used directly. All public
  interfaces are in teh beginning of the file.

*/

#ifndef KBGBOARD_H
#define KBGBOARD_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <tqspinbox.h>
#include <tqpushbutton.h>
#include <tqcheckbox.h>
#include <tqdialog.h>
#include <tqstring.h>
#include <tqpainter.h>
#include <tqpixmap.h>
#include <tqbitmap.h>
#include <tqregexp.h>
#include <tqradiobutton.h>
#include <tqwidget.h>
#include <tqptrlist.h>
#include <tqtimer.h>
#include <tqlabel.h>
#include <tqcursor.h>
#include <tqpopupmenu.h>
#include <tqcombobox.h>
#include <kdialogbase.h>
#include <kfontdialog.h>

#include "kbgstatus.h"

/*
 * Just some internal constants and classes
 */
const int US   = KBgStatus::US;
const int THEM = KBgStatus::THEM;
const int BOTH = KBgStatus::BOTH;

const int HOME_US_LEFT     = 101;
const int HOME_US_RIGHT    = 102;
const int HOME_THEM_LEFT   = 103;
const int HOME_THEM_RIGHT  = 104;
const int BAR_US           = 105;
const int BAR_THEM         = 106;
const int HOME_US          = 107;
const int HOME_THEM        = 108;

const int SHORT_MOVE_NONE   = 0;
const int SHORT_MOVE_SINGLE = 1;
const int SHORT_MOVE_DOUBLE = 2;

class KBgBoard;
class KBgBoardCell;
class KBgBoardMove;
class KBgBoardHome;
class KBgBoardBar;
class KBgBoardField;
class KBgBoardQDice;


/**
 * The KBgBoard class.
 *
 * This class handles all game operations of the client.
 */
class KBgBoard : public TQWidget
{
	Q_OBJECT
  TQ_OBJECT

	friend class KBgBoardCell;
	friend class KBgBoardHome;
	friend class KBgBoardBar;
	friend class KBgBoardField;

 public:

	/**
	 * Constructor and destructor. Parameter as usual.
	 */
	KBgBoard(TQWidget *parent = 0, const char *name = 0,
			 TQPopupMenu *menu = 0);
	virtual ~KBgBoard();

	/**
	 * Returns the current read/write status of the board.
	 */
	bool movingAllowed() const;

	/**
	 * Returns the current up-to-the-second pip count (including
	 * the moves that have been done.
	 */
	int getPipCount(const int& w) const;

	/**
	 * Sets the momentary short move mode. The parameter should
	 * be one of the constanst SHORT_MOVE_NONE, SHORT_MOVE_SINGLE
	 * or SHORT_MOVE_DOUBLE. This the automatic moving of a checker
	 * with the shortest possible move away from the current field.
	 */
	void setShortMoveMode(int m);

	/**
	 * Returns the current short move mode.
	 */
	int getShortMoveMode();

	/**
	 * Sets the background color and passes the info to the
	 * child widgets
	 */
	virtual void setBackgroundColor(const TQColor &col);

	/**
	 * Prints the baord along with some basic info onto the
	 * painetr p. It is assumed that this painter is a postscript
	 * printer. Hence the plot is black/white only.
	 */
	void print(TQPainter *p);

	/**
	 * Get whose turn it is - US, THEM or 0
	 */
	int getTurn() const;

	/**
	 * Allows for overriding the current turn color in edit mode.
	 */
	void storeTurn(const int pcs);

	/**
	 * Retrurns the current edit mode status.
	 */
	bool getEditMode() const;

	/**
	 * Get a new value for the cube from the user - this opens a dialog
	 */
	void queryCube();

	/**
	 * Get the font the board cells should use for the display of
	 * numbers and cube value.
	 */
	TQFont getFont() const;

	/**
	 * This function has to be reimplemented to provide a minimum size for
	 * the playing area.
	 */
	TQSize minimumSizeHint() const;
public slots:

	/**
	 * This allows the users of this widget to dis- and enable
	 * mouse events. In effect this triggers the read/write
	 * flag of the board.
	 */
	void allowMoving(const bool fl);

	/**
	 * Overwritten resize event handler.
	 *
	 * We overwrite the handler to make sure that all the cells are
	 * repainted as well.
	 */
	virtual void resizeEvent(TQResizeEvent *);

        /**
	 * Undo the last move.
	 */
	void undoMove();

        /**
	 * Redo a previously undone move
	 */
	void redoMove();

	/**
	 * This is the most important public member. It takes
	 * a board status - s. the KBgBoardStatus class -
	 * and sets the board accordingly.
	 */
	void setState(const KBgStatus &);

	/**
	 * Set the context menu
	 */
	void setContextMenu(TQPopupMenu *menu);

	/**
	 * Get the current state of the board.
	 */
	KBgStatus *getState(KBgStatus *st) const;

	/**
	 * Sets the edit mode of the board. In that mode the board can be
	 * modified arbitrarily.
	 */
	void setEditMode(const bool m);

	/**
	 * Allows the users of the board classe to set the font to be used
	 * on the board. Note that the fontsize is dynamically set
	 */
	void setFont(const TQFont& f);

	/**
	 * Write the current configuration to the application's data base
	 */
	void saveConfig();

	/**
	 * Restore the stored configuration or start with reasonable defaults
	 */
	void readConfig();

 signals:

	/**
	 * The text identifies the current game status - could be put
	 * into the main window caption
	 */
	void statText(const TQString &msg);

	/**
	 * The cells connect to this signal and it tells them that it is
	 * time to update their content now if necessary.
	 */
	void finishedUpdate();

	/**
	 * The user has requested the dice to be rolled. Emit the
	 * request to somebody who knows how to do that.
	 */
	void rollDice(const int w);

	/**
	 * Ask the server to double
	 */
	void doubleCube(const int w);

	/**
	 * Once the moves are all made, build a server command and send
	 * them out.
	 */
	void currentMove(TQString *s);

	/* ************************************************** */
	/* ************************************************** */

	/*    Everything below this line is private and it    */
	/*    shouldn't be used by users of this widget.      */

	/*    This means the whole file! All following        */
	/*    classes and members are private.                */

	/* ************************************************** */
	/* ************************************************** */

protected:
  virtual TQSize sizeHint() const;

	TQColor baseColors[2];
	TQFont boardFont;
        KBgBoardCell* cells[30];
	bool computePipCount;

 private:

	/**
	 * Emits a currentMove string to whomever cares.
	 */
	void sendMove();

	/**
	 * Emit a request for doubling.
	 */
	void getDoubleCube(const int w);

	/**
	 * Get pieces on who's bar - US or THEM
	 */
	int getOnBar( int who ) const;

	/**
	 * Get who's dice num - who = US or THEM, num = 0 or 1
	 */
	int getDice(  int w, int n ) const;

	/**
	 * Get the number on the cube
	 */
	int getCube() const;

	/**
	 * Ask the server for rolling
	 */
	void getRollDice(const int w);

	/**
	 * Tell the board that we kicked a piece off and store
	 * the information
	 */
	void kickedPiece();

	/**
	 * Check whether a move off is possible by checking that all pieces
	 * are either in the home board or already off
	 */
	bool moveOffPossible() const;

	/**
	 * Check whether who (US or THEM) can double
	 */
	bool canDouble( int who ) const;

	/**
	 * The cells have to tell us if the change the number of pieces, since
	 * we check that sometimes
	 */
	void updateField( int f, int v );

	/**
	 * Convert an ID from to the board numbers
	 */
	int IDtoNum(const int ID ) const;

	/**
	 * Checks if there is a possibility to get from src to dest.
	 */
	int checkMultiMove( int src, int dest, int m[4] );

	/**
	 * Checks whether the dice allow a move from src to dest (ID's)
	 */
	bool diceAllowMove( int src, int dest );

	/**
	 * Make a move from src to dest. The numbers are cellID's.
	 */
	void makeMove( int src, int dest );

	/**
	 * Translates a field number to a pointer to the cell.
	 */
	KBgBoardCell* getCell(int num);

	/**
	 * Draws a piece on the painter p, with the upper left corner
	 * of the enclosing rectangle being (x,y)
	 */
	void drawCircle(TQPainter *p, int x, int y, int pcs, int diam,
			int col, bool upper, bool outer) const;

	/**
	 * Draws an anti-aliased checker on the painter p.
	 */
	void drawChecker(TQPainter *p, int x, int y, int pcs, int diam,
			 int col, bool upper) const;

	/**
	 * Draws a simple 2-color checker on the painter p. This is intended
	 * for printing.
	 */
	void drawSimpleChecker(TQPainter *p, int x, int y, int pcs,
			       int diam) const;

	/**
	 * Given a position on the board, return the cell under the mouse pointer
	 */
	KBgBoardCell* getCellByPos(const TQPoint& p) const;

	/**
	 * Name says it all, doesn't it?
	 */
	void showContextMenu();

	/**
	 * Temporary replace the cursor, saves the old one
	 */
	void replaceCursor(const TQCursor& c);

	/**
	 * Restore the previously stored cursor.
	 */
	void restoreCursor();

	/**
	 * Given the sign of p, return the current base color
	 */
	TQColor getCheckerColor(int p) const;

	/**
	 * Small utility function for makeMove - just for readability
	 */
	int makeMoveHelper(int si, int sf, int delta);

	/**
	 * Private data members - no description needed
	 */
	TQPopupMenu *contextMenu;
	TQPtrList<KBgBoardMove> moveHistory;
	TQPtrList<KBgBoardMove> redoHistory;
	int direction, color;
	int hasmoved;
	bool allowmoving, editMode;
	int storedTurn;
	int onbar[2];
	int onhome[2];
	int board[26];
	int dice[2][2];
	int possMoves[7];
	int cube;
	int checkerDiam;
	bool cubechanged;
	bool maydouble[2];
	int shortMoveMode;
	TQCursor *savedCursor;
};

/**
 * Base class for the cells on the board
 *
 * This base class provides all the necessary functions of a cell
 * on a backgammon board. It has a bunch of virtual functions that
 * are overloaded in the derived classes.
 */
class KBgBoardCell : public TQLabel
{
      	Q_OBJECT
  TQ_OBJECT

 public:

	/**
	 * Constructor and destructor
	 */
	KBgBoardCell(TQWidget * parent, int numID);
	virtual ~KBgBoardCell();

	/**
	 * sets the number and color of checkers on this cell
	 * takes care of repainting
	 */
	virtual void cellUpdate(const int p, const bool cubechanged = false) = 0;

	/**
	 * Draws the content of the cell on the painter *p
	 */
	virtual void paintCell(TQPainter *p, int xo = 0, int yo = 0,
			       double sf = 1.0) const;

	/**
	 * Updates all the status variables at once
	 */
	virtual void statusUpdate(int dir, int col);

protected:

	/**
	 * Draw vertical lines around the board.
	 */
	void drawVertBorder(TQPainter *p, int xo, int yo, double sf = 1.0) const;
	void drawOverlappingCheckers(TQPainter *p, int xo, int yo,
				     double sf = 1.0) const;
	void drawCube(TQPainter *p, int who, int xo, int yo, double sf = 1.0) const;

	/**
	 * Puts a piece of color on a field
	 */
	void putPiece( int newColor );

	/**
	 * Removes a piece from a field. Returns true if success or false else
	 * (i.e. there is no piece on this field.
	 */
	bool getPiece();

	/**
	 * Return the number of this cell
	 */
	virtual int getNumber() const;

	/**
	 * Return the suggested diameter of a piece
	 */
	int getCheckerDiameter() const;
	int getCellColor();

	/**
	 * Do we allow a drop of the DragEvent ? This checks the payload and
	 * reacts on it.
	 */
	virtual bool dropPossible(int fromCellID, int newColor) = 0;

 protected:

	/**
	 * Overwrite how a cell draws itself
	 */
	virtual void drawContents(TQPainter *);

	/**
	 * Status numbers that store the current board status.
	 */
	int mouseButton;
	int direction;
	int color;

	/**
	 * How many pieces are we currently holding ?
	 */
	int pcs;

	/**
	 * Our own ID
	 */
	int cellID;

	/**
	 * Indicates whether this cell needs to tqrepaint itself after
	 * the board has been processed.
	 */
	bool stateChanged;
	bool colorChanged, directionChanged;

	/**
	 * the board and the pieces are one unit (none makes
	 * sense without the other). So the pieces know and access their parent.
	 */
	KBgBoard *board;
 	void checkAndMakeShortMove(TQMouseEvent *e, int m);

	/**
	 * Returns the bounding rectangle of the cube on this cell
	 */
	TQRect cubeRect( int who, bool big, double sf = 1.0 ) const;

	/**
	 * Returns the bounding rectangle of the dice i on this cell
	 */
	TQRect diceRect(int i, bool big, double sf = 1.0, double scale = 0.45) const;
	bool dragInProgress;

 protected slots:
        /**
	 * Refreshes the widget. This is essentially a call to update().
	 */
        virtual void refresh();

	/**
	 * Can we currently drag from this field ?
	 */
	virtual bool dragPossible() const = 0;

	/**
	 * Possibly initiate a drag.
	 */
	virtual void mouseMoveEvent( TQMouseEvent * );
	virtual void mousePressEvent(TQMouseEvent *e);

	/**
	 * Make the shortes possible move away from this cell
	 */
	void makeShortMove();
	void makeShortMoveHelper(int s, int d);

	/**
	 * Catch a single left click and perhapes make a move.
	 */
	virtual void mouseReleaseEvent( TQMouseEvent *e );

	/**
	 * Catch a double left click and perhapes make a move.
	 */
	virtual void mouseDoubleClickEvent( TQMouseEvent *e );
};

/**
 * The homes are derived from the regular cells. They just overwrite
 * some members.
 */
class KBgBoardHome : public KBgBoardCell
{
      	Q_OBJECT
  TQ_OBJECT

 public:
	/**
	 * sets the number and color of checkers on this cell
	 * takes care of repainting
	 */
	virtual void cellUpdate(const int p, const bool cubechanged = false);

	/*
	 * Draws the content of the cell on the painter *p
	 */
	virtual void paintCell(TQPainter *p, int xo = 0, int yo = 0,
			       double sf = 1.0) const;

	/**
	 * Constructor and destructor
	 */
	KBgBoardHome( TQWidget * parent, int numID);
	virtual ~KBgBoardHome();

	/**
	 * Check whether a drop on the home cell is possible.
	 */
	virtual bool dropPossible(int fromCellID, int newColor);

 protected:
	/**
	 * Determine whether a drag from the home is possible.
	 */
	virtual bool dragPossible() const;

	/**
	 * Get the double clicks
	 */
	virtual void mouseDoubleClickEvent( TQMouseEvent *e );

        /**
	 * The homes contain dice and cube. This draws them.
	 */
        void drawDiceAndCube(TQPainter *p, int who, int xo, int yo,
			      double sf) const;

	void drawDiceFrame(TQPainter *p, int col, int num, int xo, int yo,
			   bool big, double sf) const;
	void drawDiceFace(TQPainter *p, int col, int num, int who, int xo,
			  int yo, double sf) const;

 private:
	/**
	 * Save old dice to avoid repainting
	 */
	int savedDice[2];

};

/**
 * The bars are derived from the regular cells. They just overwrite
 * some members.
 */
class KBgBoardBar : public KBgBoardCell
{
       	Q_OBJECT
  TQ_OBJECT

 public:
	/**
	 * sets the number and color of checkers on this cell
	 * takes care of repainting
	 */
	virtual void cellUpdate(const int p, const bool cubechanged = false);

	/**
	 * Draws the content of the cell on the painter *p
	 */
	virtual void paintCell(TQPainter *p, int xo = 0, int yo = 0,
			       double sf = 1.0) const;

	/**
	 * Constructor
	 */
	KBgBoardBar( TQWidget * parent, int numID );

	/**
	 * Destructor
	 */
	virtual ~KBgBoardBar();

	/**
	 * Check whether a drop on the bar cell is possible.
	 */
	virtual bool dropPossible(int fromCellID, int newColor);

 protected:
	/**
	 * Determine whether a drag from the bar is possible.
	 */
	virtual bool dragPossible() const;
	/**
	 * Get the double clicks
	 */
	virtual void mouseDoubleClickEvent(TQMouseEvent *e);
};

/**
 * The fields are derived from the regular cells. They just overwrite
 * some members.
 */
class KBgBoardField : public KBgBoardCell
{
	Q_OBJECT
  TQ_OBJECT

 public:
	/**
	 * Constructor and destructor
	 */
	KBgBoardField( TQWidget * parent, int numID);
	virtual ~KBgBoardField();

	/**
	 * sets the number and color of checkers on this cell
	 * takes care of repainting
	 */
	virtual void cellUpdate(const int p, const bool cubechanged = false);

	/**
	 * Draws the content of the cell on the painter *p
	 */
	virtual void paintCell(TQPainter *p, int xo = 0, int yo = 0,
			       double sf = 1.0) const;

	/**
	 * Check whether a drop on the field cell is possible.
	 */
	virtual bool dropPossible(int fromCellID, int newColor);

 protected:
	/**
	 * Determine whether a drag from the field is possible.
	 */
	virtual bool dragPossible() const;

	/**
	 * Return the y-coordinate of the number of the field.
	 */
	int numberBase() const;
};

/**
 * Internal class for storing a move in the undo history buffer.
 */
class KBgBoardMove
{
 public:
	/**
	 * Accepts source, destination and the dice that made this move
	 * possible. Set the kicked flag to false.
	 */
	KBgBoardMove(int src, int dest, int delta)
		{s = src; d = dest; l = delta; k = false;}

	/**
	 * Set this move to be a kick
	 */
	void setKicked(bool kicked) {k = kicked;}

	/**
	 * Look up the source
	 */
	int source() const {return s;}

	/**
	 * Look up the destination
	 */
	int destination() const {return d;}

	/**
	 * Look up the dice that made this move
	 */
	int length() const {return l;}

	/**
	 * Check whether the move kicked a piece
	 */
	bool wasKicked() const {return k;}

 private:
	/**
	 * Source, destination, dice
	 */
	int s, d, l;

	/**
	 * Kicked move ?
	 */
	bool k;
};

/**
 * Simple dialog that allows to query the user for dice values.
 *
 * A very simple dialog with two SpinBoxes and two buttons.
 */
class KBgBoardQDice : public TQDialog
{
	Q_OBJECT
  TQ_OBJECT

public:

	/**
	 * Constructor and destructor
	 */
	KBgBoardQDice(const char *name = 0);
	virtual ~KBgBoardQDice();

protected:

	/**
	 * Spin boxes and buttons are tqchildren
	 */
	TQSpinBox     *sb[2];
	TQPushButton  *ok;
	TQPushButton  *cancel;

public slots:

	/**
	 * Get the face values.
	 */
        int getDice(int n);
};


/**
 * Simple dialog that allows to query the user for the cube value.
 */
class KBgBoardQCube : public TQDialog
{
	Q_OBJECT
  TQ_OBJECT

public:

	/**
	 * Constructor and destructor
	 */
	KBgBoardQCube(int val, bool us, bool them);
	virtual ~KBgBoardQCube();

protected:

	/**
	 * Spin boxes and buttons are tqchildren
	 */
	TQComboBox    *cb[2];
	TQPushButton  *ok;
	TQPushButton  *cancel;

public slots:

	/**
	 * Get the face values.
	 */
        int getCubeValue();
        int getCubeOwner();

protected slots:

        /**
         * These slots are needed to get consistent relations
	 * between the two combo boxes.
         */
        void changePlayer(int val);
	void changeValue(int player);

};


/**
 * Extension of the KBgBoard class that can add itself
 * to a TQTabDialog for configuration.
 */
class KBgBoardSetup : public KBgBoard
{
	Q_OBJECT
  TQ_OBJECT

public:

	/**
	 * Constructor
	 */
	KBgBoardSetup(TQWidget *parent = 0, const char *name = 0,
			      TQPopupMenu *menu = 0);

	/**
	 * Lets the board put its setup pages into the notebook nb
	 */
	void getSetupPages(KDialogBase *nb);

public slots:

        /**
	 * Setup changes are confirmed. Store them.
	 */
	void setupOk();

	/**
	 * Setup has been cancelled. Undo the color changes
	 */
	void setupCancel();

	/**
	 * Load default values for user settings
	 */
	void setupDefault();

protected slots:

        /**
	 * Open a color dialog for the background color
	 */
	void selectBackgroundColor();

        /**
	 * Open a color dialog for the first checker color
	 */
	void selectBaseColorOne();

        /**
	 * Open a color dialog for the second checker color
	 */
	void selectBaseColorTwo();

private:

	/**
	 * Save settings before the user changed them
	 */
	KFontChooser *kf;

	TQRadioButton *rbMove[3];

	TQColor saveBackgroundColor;
	TQColor saveBaseColors[2];

	/**
	 * Need these to change their colors
	 */
	TQPushButton *pbc_1, *pbc_2, *pbc_3;
	TQCheckBox *cbp;
};

#endif // KBGBOARD_H