board.h

Go to the documentation of this file.

/***************************************************************************
 *   KShisen - A japanese game similar to mahjongg                         *
 *   Copyright 1997  Mario Weilguni <mweilguni@sime.com>                   *
 *   Copyright 2002-2004  Dave Corrie <kde@davecorrie.com>                 *
 *   Copyright 2007  Mauricio Piacentini <mauricio@tabuleiro.com>          *
 *   Copyright 2009-2012  Frederik Schwarzer <schwarzer@kde.org>           *
 *                                                                         *
 *   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, see <http://www.gnu.org/licenses/>. *
 ***************************************************************************/

// KMahjonggLib integration and SVG support for KDE 4: Mauricio Piacentini <mauricio@tabuleiro.com>

#ifndef BOARD_H
#define BOARD_H

#include "debug.h"

#include <KgSound>

#include <kgameclock.h>
#include <kmahjonggtileset.h>
#include <kmahjonggbackground.h>

#include <kdebug.h>
#include <krandomsequence.h>

#include <QList>
#include <QSize>
#include <QWidget>

#include <phonon/mediaobject.h>

// used in board.cpp and app.cpp, thus defined here
static int sizeX[6] = {14, 16, 18, 24, 26, 30};
static int sizeY[6] = { 6,  9,  8, 12, 14, 16};

struct Position {
    Position() : x(0), y(0) { }
    Position(int _x, int _y) : x(_x), y(_y) { }
    int x; 
    int y; 
};

typedef QList<Position> Path;

class PossibleMove
{
public:
    PossibleMove(Path &path) :
        m_path(path), m_hasSlide(false) { }
    PossibleMove(Path &path, Path &slide) :
        m_path(path), m_hasSlide(true), m_slide(slide) { }

    bool isInPath(int x, int y) const;

    void Debug() const {
        kDebug() << "PossibleMove";
        QList<Position>::const_iterator iter;
        for (iter = m_path.constBegin(); iter != m_path.constEnd(); ++iter) {
            kDebug() << "    Path:" << iter->x << "," << iter->y;
        }

        if (m_hasSlide) {
            kDebug() << "   hasSlide";
            for (iter = m_slide.constBegin(); iter != m_slide.constEnd(); ++iter) {
                kDebug() << "    Slide:" << iter->x << "," << iter->y;
            }
        }
    }

    Path m_path; 
    bool m_hasSlide; 
    Path m_slide; 
};

typedef QList<PossibleMove> PossibleMoves;


class Move
{
public:
    Move(int x1, int y1, int x2, int y2, int tile) :
        m_x1(x1), m_y1(y1), m_x2(x2), m_y2(y2), m_tile1(tile), m_tile2(tile), m_hasSlide(false), m_slideX1(-1), m_slideY1(-1), m_slideX2(-1), m_slideY2(-1) { }
    Move(int x1, int y1, int x2, int y2, int tile1, int tile2) :
        m_x1(x1), m_y1(y1), m_x2(x2), m_y2(y2), m_tile1(tile1), m_tile2(tile2), m_hasSlide(false), m_slideX1(-1), m_slideY1(-1), m_slideX2(-1), m_slideY2(-1) { }
    Move(int x1, int y1, int x2, int y2, int tile1, int tile2, int slideX1, int slideY1, int slideX2, int slideY2) :
        m_x1(x1), m_y1(y1), m_x2(x2), m_y2(y2), m_tile1(tile1), m_tile2(tile2), m_hasSlide(true), m_slideX1(slideX1), m_slideY1(slideY1), m_slideX2(slideX2), m_slideY2(slideY2) { }

    int m_x1, m_y1, m_x2, m_y2; 
    int m_tile1; 
    int m_tile2; 
    bool m_hasSlide; 
    int m_slideX1; 
    int m_slideY1; 
    int m_slideX2; 
    int m_slideY2; 
};


class Board : public QWidget
{
    Q_OBJECT

public:
    Board(QWidget *parent = 0);
    ~Board();

    static const int nTiles = 42;

    virtual void paintEvent(QPaintEvent *e);
    virtual void mousePressEvent(QMouseEvent *e);
    virtual void resizeEvent(QResizeEvent *e);

    void setDelay(int);
    int  delay() const;

    bool canUndo() const;
    bool canRedo() const;
    void undo();
    void redo();

    void setSize(int x, int y);
    void resizeBoard();

    void showHint();
    bool hint_I(PossibleMoves &possibleMoves) const;

#ifdef DEBUGGING
    void makeHintMove();
    void finish();
    void dumpBoard() const;
    void dumpBoard(const int *) const;
#endif

    int tilesLeft() const;
    int currentTime() const;

    bool solvable(bool noRestore = false); // const?

    bool solvableFlag() const;
    void setSolvableFlag(bool b);
    bool gravityFlag() const;
    void setGravityFlag(bool b);
    void setChineseStyleFlag(bool b);
    void setTilesCanSlideFlag(bool b);

    int xTiles() const;
    int yTiles() const;

    void resetTimer();
    void resetUndo();
    void resetRedo();
    void setGameStuckEnabled(bool enabled);
    void setGameOverEnabled(bool enabled);
    void setCheatModeEnabled(bool enabled);

    bool isOver() const;

    bool isPaused() const;

    bool isStuck() const;

    bool hasCheated() const;

signals:
    void markMatched(); // unused?
    void newGameStarted();
    void changed();
    void endOfGame();
    void resized();
    void invalidMove();
    void tilesDoNotMatch();
    void selectATile();
    void selectAMove();
    void selectAMatchingTile();
    void cheatStatusChanged();

public slots:
    void newGame();

    void setPauseEnabled(bool enabled);

    void setSoundsEnabled(bool enabled);
    void loadSettings();
    bool loadTileset(const QString &);
    bool loadBackground(const QString &);

private slots:
    void undrawConnection();

    bool gravity(int column, bool update);

protected:
    virtual QSize sizeHint() const;

private: // functions
    int xOffset() const;
    int yOffset() const;

    int lineWidth() const;

    void setField(int x, int y, int value);
    int field(int x, int y) const;
    void updateField(int, int);
    void showInfoRect(QPainter &, const QString &message);
    void drawTiles(QPainter &, QPaintEvent *);
    void clearHighlight();

    bool tilesMatch(int tile1, int tile2) const;

    bool canMakePath(int x1, int y1, int x2, int y2) const;

    bool canSlideTiles(int x1, int y1, int x2, int y2, Path &path) const;

    int findPath(int x1, int y1, int x2, int y2, PossibleMoves &possibleMoves) const;

    int findSimplePath(int x1, int y1, int x2, int y2, PossibleMoves &possibleMoves) const;
    void performMove(PossibleMove &possibleMoves);
    void performSlide(int x, int y, Path& s);
    void reverseSlide(int x, int y, int slideX1, int slideY1, int slideX2, int slideY2);
    bool isTileHighlighted(int x, int y) const;
    void drawConnection();
    void drawPossibleMoves(bool b);
    QPoint midCoord(int x, int y) const;
    void unmarkTile();
    void marked(int x, int y);
    void madeMove(int x1, int y1, int x2, int y2, Path slide = Path());

    void gravity(bool update);

private:
    KGameClock m_gameClock;

    KMahjonggTileset m_tiles;
    KMahjonggBackground m_background;

    KRandomSequence m_random;

    QList<Move*> m_undo; 
    QList<Move*> m_redo; 

    int m_markX;
    int m_markY;
    Path m_connection;
    PossibleMoves m_possibleMoves;
    int *m_field; 
    int m_xTiles;
    int m_yTiles;
    int m_delay;
    int m_level;
    int m_shuffle;

    enum GameState { Normal, Paused, Stuck, Over }; 
    GameState m_gameState;
    bool m_cheat; 

    bool m_gravityFlag; 
    bool m_solvableFlag; 
    bool m_chineseStyleFlag; 
    bool m_tilesCanSlideFlag; 
    QList<int> m_gravCols;

    int m_highlightedTile;

    bool m_paintConnection;
    bool m_paintPossibleMoves;
    bool m_paintInProgress;
    QPair<int, int> m_tileRemove1;
    QPair<int, int> m_tileRemove2;
    KgSound m_soundPick; 
    KgSound m_soundFall; 
};

#endif // BOARD_H

// vim: expandtab:tabstop=4:shiftwidth=4
// kate: space-indent on; indent-width 4