FCSDebugStateWithLocations.h

Go to the documentation of this file.

#ifndef MMANN_FCS_DEBUG_STATE_WITH_LOCATIONS_H
#define MMANN_FCS_DEBUG_STATE_WITH_LOCATIONS_H


class FCSDebugState;

template <class StateWithLocation>
class FCSDebugStateWithLocations : public StateWithLocation
{
public:
    FCSDebugStateWithLocations();

    virtual ~FCSDebugStateWithLocations();

    virtual void Copy(FCSStateWithLocations* State);

    int Compare(const FCSStateWithLocations* State);

    FCSCard* GetStackCard(int Stack, int Card);

    char GetStackCardSuit(int Stack, int Card);

    char GetStackCardNumber(int Stack, int Card);

    int GetStackLength(int Stack);

    FCSCard* GetFreecellCard(int Freecell);

    char GetFreecellCardSuit(int Freecell);

    char GetFreecellCardNumber(int Freecell);

    char GetFoundation(int Foundation);

    void IncrementFoundation(int Foundation);

    void SetFoundation(int Foundation, char Value);

    void PopStackCard(int Stack, FCSCard* Card);

    void PushStackCardIntoStack(int DestStack, int SrcStack, int SrcCard);

    void PushCardIntoStack(int DestStack, FCSCard* Card);

    void PutCardInFreecell(int Freecell, FCSCard* Card);

    void EmptyFreecell(int Freecell);

    void FlipStackCard(int Stack, int Card);

    void CanonizeState(int NumberOfFreecells, int NumberOfStacks);

    FCSState* GetState();

protected:
    FCSDebugState  m_State;
};

template <class StateWithLocation>
FCSDebugStateWithLocations<StateWithLocation>::FCSDebugStateWithLocations() : StateWithLocation()
{
}

template <class StateWithLocation>
FCSDebugStateWithLocations<StateWithLocation>::~FCSDebugStateWithLocations()
{
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::Copy(FCSStateWithLocations* State)
{
    StateWithLocation::Copy(State);

    m_State = ((FCSDebugStateWithLocations*)State)->m_State;
}

template <class StateWithLocation>
int FCSDebugStateWithLocations<StateWithLocation>::Compare(const FCSStateWithLocations *State)
{
    return m_State.Compare(&(((FCSDebugStateWithLocations*)State)->m_State));
}

template <class StateWithLocation>
FCSCard* FCSDebugStateWithLocations<StateWithLocation>::GetStackCard(int Stack, int Card)
{
    return &(m_State.m_Stacks[Stack].m_Cards[Card]);
}

template <class StateWithLocation>
char FCSDebugStateWithLocations<StateWithLocation>::GetStackCardSuit(int Stack, int Card)
{
    return m_State.m_Stacks[Stack].m_Cards[Card].GetSuit();
}

template <class StateWithLocation>
char FCSDebugStateWithLocations<StateWithLocation>::GetStackCardNumber(int Stack, int Card)
{
    return m_State.m_Stacks[Stack].m_Cards[Card].GetCardNumber();
}

template <class StateWithLocation>
int FCSDebugStateWithLocations<StateWithLocation>::GetStackLength(int Stack)
{
    return m_State.m_Stacks[Stack].m_NumberOfCards;
}

template <class StateWithLocation>
FCSCard* FCSDebugStateWithLocations<StateWithLocation>::GetFreecellCard(int Freecell)
{
    return &(m_State.m_Freecells[Freecell]);
}

template <class StateWithLocation>
char FCSDebugStateWithLocations<StateWithLocation>::GetFreecellCardSuit(int Freecell)
{
    return m_State.m_Freecells[Freecell].GetSuit();
}

template <class StateWithLocation>
char FCSDebugStateWithLocations<StateWithLocation>::GetFreecellCardNumber(int Freecell)
{
    return m_State.m_Freecells[Freecell].GetCardNumber();
}

template <class StateWithLocation>
char FCSDebugStateWithLocations<StateWithLocation>::GetFoundation(int Foundation)
{
    return m_State.m_Foundations[Foundation];
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::IncrementFoundation(int Foundation)
{
    m_State.m_Foundations[Foundation]++;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::SetFoundation(int Foundation, char Value)
{
    m_State.m_Foundations[Foundation] = Value;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::PopStackCard(int Stack, FCSCard* Card)
{
    Card->Copy(&m_State.m_Stacks[Stack].m_Cards[m_State.m_Stacks[Stack].m_NumberOfCards-1]);
    m_State.m_Stacks[Stack].m_Cards[m_State.m_Stacks[Stack].m_NumberOfCards-1].EmptyCard();
    m_State.m_Stacks[Stack].m_NumberOfCards--;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::PushStackCardIntoStack(int DestStack, int SrcStack, int SrcCard)
{
    m_State.m_Stacks[DestStack].m_Cards[m_State.m_Stacks[DestStack].m_NumberOfCards].Copy(&m_State.m_Stacks[SrcStack].m_Cards[SrcCard]);
    m_State.m_Stacks[DestStack].m_NumberOfCards++;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::PushCardIntoStack(int DestStack, FCSCard* Card)
{
    m_State.m_Stacks[DestStack].m_Cards[m_State.m_Stacks[DestStack].m_NumberOfCards].Copy(Card);
    m_State.m_Stacks[DestStack].m_NumberOfCards++;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::PutCardInFreecell(int Freecell, FCSCard* Card)
{
    m_State.m_Freecells[Freecell].Copy(Card);
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::EmptyFreecell(int Freecell)
{
    m_State.m_Freecells[Freecell].m_CardNumber = 0;
    m_State.m_Freecells[Freecell].m_Suit = 0;
    m_State.m_Freecells[Freecell].m_Flags = 0;
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::FlipStackCard(int Stack, int Card)
{
    m_State.m_Stacks[Stack].m_Cards[Card].SetFlipped(0);
}

template <class StateWithLocation>
void FCSDebugStateWithLocations<StateWithLocation>::CanonizeState(int NumberOfFreecells, int NumberOfStacks)
{
    int b,c;

    FCSDebugStack TempStack;
    FCSDebugCard TempFeecell;
    char TempLocation;

    /* Insertion-sort the stacks */
    for(b=1;b<NumberOfStacks;b++)
    {
        c = b;
        while((c>0) && (m_State.StackCompare(c, c-1) < 0))
        {
            TempStack = m_State.m_Stacks[c];
            m_State.m_Stacks[c] = m_State.m_Stacks[c-1];
            m_State.m_Stacks[c-1] = TempStack;

            TempLocation = m_StackLocations[c];
            m_StackLocations[c] = m_StackLocations[c-1];
            m_StackLocations[c-1] = TempLocation;

            c--;
        }
    }

    // Insertion sort the freecells
    for(b=1;b<NumberOfFreecells;b++)
    {
        c = b;
        while((c>0) && (m_State.m_Freecells[c].Compare(&m_State.m_Freecells[c-1]) < 0))
        {
            TempFeecell = m_State.m_Freecells[c];
            m_State.m_Freecells[c] = m_State.m_Freecells[c-1];
            m_State.m_Freecells[c-1] = TempFeecell;

            TempLocation = m_FreecellLocations[c];
            m_FreecellLocations[c] = m_FreecellLocations[c-1];
            m_FreecellLocations[c-1] = TempLocation;

            c--;
        }
    }   
}

template <class StateWithLocation>
FCSState* FCSDebugStateWithLocations<StateWithLocation>::GetState()
{
    return &m_State;
}

#endif

---