MiscFreecellGameBoards.h

Go to the documentation of this file.

#ifndef MISC_FREECELL_GAME_BOARDS_H
#define MISC_FREECELL_GAME_BOARDS_H


#include "AFreecellGameBoard.h"

class MicrosoftFreecellGameBoard : public AFreecellGameBoard
{
public:
    MicrosoftFreecellGameBoard(bool Display10AsT);
    virtual ~MicrosoftFreecellGameBoard();

    virtual void Shuffle(int Seed);

    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();
};

class GnomeFreecellGameBoard : public MicrosoftFreecellGameBoard
{
public:
    GnomeFreecellGameBoard(bool Display10AsT);
    virtual ~GnomeFreecellGameBoard();

    virtual void Shuffle(int Seed);
};

class AisleRiotGameBoard : public AFreecellGameBoard
{
public:
    virtual ~AisleRiotGameBoard();

/***************************
When I figure out what the algorithm for the UNIX srandom/random, I'll write
the appropriate functions for the shuffle algorithm
***************************/
    virtual void Shuffle(int Seed);

    virtual int GetGameBoardSize() = 0;

protected:
    AisleRiotGameBoard(bool Display10AsT);
    AisleRiotGameBoard();
};

class AisleRiotFreecellGameBoard : public AisleRiotGameBoard
{
public:
    AisleRiotFreecellGameBoard(bool Display10AsT);
    virtual ~AisleRiotFreecellGameBoard();

    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();
};

class AisleRiotKlondikeGameBoard : public AisleRiotGameBoard
{
public:
    AisleRiotKlondikeGameBoard(bool Display10AsT);
    ~AisleRiotKlondikeGameBoard();

    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();
};

class AisleRiotEightOffGameBoard : public AisleRiotGameBoard
{
public:
    AisleRiotEightOffGameBoard(bool Display10AsT);
    virtual ~AisleRiotEightOffGameBoard();

    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();
};

class AisleRiotSeahavenTowersGameBoard : public AisleRiotGameBoard
{
public:
    AisleRiotSeahavenTowersGameBoard(bool Display10AsT);
    virtual ~AisleRiotSeahavenTowersGameBoard();

    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();
};

class AisleRiotBeleagueredCastleGameBoard : public AisleRiotGameBoard
{
public:
    AisleRiotBeleagueredCastleGameBoard(bool Display10AsT);
    virtual ~AisleRiotBeleagueredCastleGameBoard();

    /***************************
    When I figure out what the algorithm for the UNIX srandom/random, I'll write
    the appropriate functions for the shuffle algorithm
    ***************************/
    virtual void Deal(char* GameBoard);

    virtual int GetGameBoardSize();

protected:
    virtual int GetNumberOfCardsInDeck();
};


#endif

---