psminigameboard.h

Go to the documentation of this file.

/*
* psminigameboard.h
*
* Copyright (C) 2008 Atomic Blue (info@planeshift.it, http://www.atomicblue.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 (version 2 of the License)
* 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*
*/

#ifndef __MINIGAMEBOARD_H
#define __MINIGAMEBOARD_H

//=============================================================================
// Crystal Space Includes
//=============================================================================

//=============================================================================
// Project Includes
//=============================================================================
#include "psstdint.h"

//=============================================================================
// Local Includes
//=============================================================================

class Client;

#define GAMEBOARD_MIN_PLAYERS 1
#define GAMEBOARD_MAX_PLAYERS 2
#define GAMEBOARD_DEFAULT_PLAYERS 2

enum Rule_PlayerTurn
{
    RELAXED,
    ORDERED,
    STRICT_ORDERED
};
enum Rule_MovePieceType
{
    PLACE_OR_MOVE,
    PLACE_ONLY,
    MOVE_ONLY
};
enum Rule_MoveablePieces
{
    ANY_PIECE,
    OWN_PIECES_ONLY
};
enum Rule_MovePiecesTo
{
    ANYWHERE,
    VACANCY_ONLY
};
enum Rule_MoveDirection
{
    ANY,
    VERTICAL,
    HORIZONTAL,
    CROSS,
    DIAGONAL
};

enum Endgame_TileType
{
    PLAYED_PIECE,
    WHITE_PIECE,
    BLACK_PIECE,
    NO_PIECE,
    FOLLOW_SOURCE_TILE,
    SPECIFIC_TILE
};

struct Endgame_TileSpec
{
    int col;
    int row;
    Endgame_TileType tile;
    uint8_t specificTile;
};

struct Endgame_Spec
{
    bool positionsAbsolute;       // true=x,y coords absolute, false=coords relative to source tile
    Endgame_TileType sourceTile;
    Endgame_TileType winner;
    csArray<Endgame_TileSpec*> endgameTiles;
};

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

class psMiniGameBoardDef
{
    friend class psMiniGameBoard;

public:

    psMiniGameBoardDef(const uint8_t defCols, const uint8_t defRows,
                       const char* defLayout, const char* defPieces,
                       const uint8_t defPlayers, const int16_t options);

    ~psMiniGameBoardDef();

    uint8_t GetCols() const
    {
        return cols;
    }

    uint8_t GetRows() const
    {
        return rows;
    }

    int GetLayoutSize() const
    {
        return layoutSize;
    };

    void PackLayoutString(const char* layoutStr, uint8_t* packedLayout);

    uint8_t PackPiece(char pieceStr);

    uint16_t GetGameboardOptions(void)
    {
        return gameboardOptions;
    };

    bool DetermineGameRules(csString rulesXMLstr, csString name);

    bool DetermineEndgameSpecs(csString endgameXMLstr, csString name);

    void ClearOutEndgames(void)
    {
        endgames.Empty();
    };

private:
    int layoutSize;

    uint8_t* layout;

    uint8_t cols;

    uint8_t rows;

    uint8_t numPieces;

    uint8_t piecesSize;

    uint8_t* pieces;

    uint8_t numPlayers;

    int16_t gameboardOptions;

    Rule_PlayerTurn playerTurnRule;
    Rule_MovePieceType movePieceTypeRule;
    Rule_MoveablePieces moveablePiecesRule;
    Rule_MovePiecesTo movePiecesToRule;
    Rule_MoveDirection moveDirectionRule;
    int moveDistanceRule;

    csArray<Endgame_Spec*> endgames;
    bool EvaluateTileTypeStr(csString TileTypeStr, Endgame_TileType &tileType);

};


class psMiniGameBoard
{
public:

    psMiniGameBoard();

    ~psMiniGameBoard();

    void Setup(psMiniGameBoardDef* newGameDef, uint8_t* preparedLayout);

    uint8_t GetCols() const
    {
        return gameBoardDef->cols;
    }

    uint8_t GetRows() const
    {
        return gameBoardDef->rows;
    }

    uint8_t* GetLayout() const
    {
        return layout;
    };

    uint8_t GetNumPieces() const
    {
        return gameBoardDef->numPieces;
    }

    uint8_t GetPiecesSize() const
    {
        return gameBoardDef->piecesSize;
    }

    uint8_t* GetPieces() const
    {
        return gameBoardDef->pieces;
    }

    uint8_t Get(uint8_t col, uint8_t row) const;

    void Set(uint8_t col, uint8_t row, uint8_t state);

    uint8_t GetNumPlayers(void)
    {
        return gameBoardDef->numPlayers;
    };

    Rule_PlayerTurn GetPlayerTurnRule(void)
    {
        return gameBoardDef->playerTurnRule;
    };
    Rule_MovePieceType GetMovePieceTypeRule(void)
    {
        return gameBoardDef->movePieceTypeRule;
    };
    Rule_MoveablePieces GetMoveablePiecesRule(void)
    {
        return gameBoardDef->moveablePiecesRule;
    };
    Rule_MovePiecesTo GetMovePiecesToRule(void)
    {
        return gameBoardDef->movePiecesToRule;
    };
    Rule_MoveDirection GetMoveDirectionRule(void)
    {
        return gameBoardDef->moveDirectionRule;
    };
    int GetMoveDistanceRule(void)
    {
        return gameBoardDef->moveDistanceRule;
    };

    bool DetermineEndgame(Endgame_TileType &winningPiece);

private:

    Endgame_TileType EndgameWinner(uint8_t winningTileState);

    uint8_t* layout;

    psMiniGameBoardDef* gameBoardDef;
};

#endif