FCState.h

Go to the documentation of this file.

#ifndef MMANN_FCSTATE_H
#define MMANN_FCSTATE_H


#include "FCEnums.h"
#include "FCSMove.h"
#include "FCSCard.h"
#include "Config.h"
#include "FCSDebugDisplayInfo.h"
#include "HashAlgorithms.h"
#include "FCSStateWithLocationsMatrix.h"

//forward declaration
class AFCSGenericStackStorage;

class FCSState
{
public:
    virtual ~FCSState();

    virtual int GetClassSize() = 0;

protected:
    FCSState();
};

class FCSStateWithLocations
{
public: 

    virtual ~FCSStateWithLocations();

    virtual void Copy(FCSStateWithLocations* State);

    virtual int Compare(const FCSStateWithLocations* State) = 0;

    static FCSStateWithLocations* CreateInitialState(const char *String, 
                                                    int NumberOfFreecells, int NumberOfStacks, int NumberOfDecks);

    virtual void StateAsString(char* String, FCSDebugDisplayInfo* DebugInfo);

    virtual int CheckStateValidity(int NumberOfFreecells, int NumberOfStacks, 
                                    int NumberOfDecks, FCSCard** MisplacedCard, FCSTalonType TalonType);

    virtual FCSCard* GetStackCard(int Stack, int Card) = 0;

    virtual char GetStackCardSuit(int Stack, int Card) = 0;

    virtual char GetStackCardNumber(int Stack, int Card) = 0;

    virtual int GetStackLength(int Stack) = 0;

    virtual FCSCard* GetFreecellCard(int Freecell) = 0;

    virtual char GetFreecellCardSuit(int Freecell) = 0;

    virtual char GetFreecellCardNumber(int Freecell) = 0;

    virtual char GetFoundation(int Foundation) = 0;

    virtual void IncrementFoundation(int Foundation) = 0;

    virtual void SetFoundation(int Foundation, char Value) = 0;

    virtual void PopStackCard(int Stack, FCSCard* Card) = 0;

    virtual void PushStackCardIntoStack(int DestStack, int SrcStack, int SrcCard) = 0;

    virtual void PushCardIntoStack(int DestStack, FCSCard* Card) = 0;

    virtual void PutCardInFreecell(int Freecell, FCSCard* Card) = 0;

    virtual void EmptyFreecell(int Freecell) = 0;

    virtual void FlipStackCard(int Stack, int Card) = 0;

    virtual void CleanState();

    virtual void CacheStacks(AFCSGenericStackStorage* Storage, int StackNumber);

    virtual void Initialize(int NumberOfStacks);

    virtual void CanonizeState(int NumberOfFreecells, int NumberOfStacks) = 0;

    virtual FCSState* GetState() = 0;

    FCSStateWithLocations* m_Parent;
    FCSMoveStack* m_MovesToParent;
    int m_Depth;
    int m_Visited;
    int m_VisitIterations;
    char m_StackLocations[MAX_NUM_STACKS];
    char m_FreecellLocations[MAX_NUM_FREECELLS];

protected:
    FCSStateWithLocations();
};

class FCSStateWithLocationsLinkedList
{
public:
    FCSStateWithLocations* m_State;

    FCSStateWithLocationsLinkedList* m_Next;
};

int GetFCSStateWithLocationsClassSize();

FCSStateWithLocations* CreateStateWithLocations();

AFCSStateWithLocationsMatrix* CreateStateWithLocationsMatrix(int Size);

void ReallocStateWithLocationsArray(FCSStateWithLocations*** Array, int OldSize, int NewSize);

FCSStateWithLocations* CreateInitialState(const char *String, int NumberOfFreecells, 
                                          int NumberOfStacks, int NumberOfDecks, FCSTalonType TalonType);

class MD5StateWithLocationsHashAlgorithm : public MD5HashAlgorithm<FCSStateWithLocations>
{
public:
    virtual int Hash(const FCSStateWithLocations* key);
};

extern FCStateType GlobalStateType;

#endif

---