FCSCompactStateWithLocations.h

Go to the documentation of this file.

#ifndef MMANN_FCS_COMPACT_STATE_WITH_LOCATIONS_H
#define MMANN_FCS_COMPACT_STATE_WITH_LOCATIONS_H


/*
 * Stack: 0 - Number of cards 
 *        1-19 - Cards
 * Stacks: stack_num*20 where stack_num >= 0 and 
 *         stack_num <= (MAX_NUM_STACKS-1)
 * Bytes: (MAX_NUM_STACKS*20) to 
 *      (MAX_NUM_STACKS*20+MAX_NUM_FREECELLS-1) 
 *      are Freecells.
 * Bytes: (MAX_NUM_STACKS*20+MAX_NUM_FREECELLS) to
 *      MAX_NUM_STACKS*20+MAX_NUM_FREECELLS+3
 *      are Foundations.
 * */

/*  ===== Depracated Information =====
 * Stack: 0 - Number of cards 1-19 - Cards
 * Stacks: stack_num*20 where stack_num >= 0 and stack_num <= 7
 * Bytes 160-163 - Freecells
 * Bytes 164-167 - Decks
 */

//class FCSCompactState;
#include "FCCompactState.h"


#define FCS_FREECELLS_OFFSET (MAX_NUM_STACKS*(MAX_NUM_CARDS_IN_A_STACK+1))

#define FCS_FOUNDATIONS_OFFSET (MAX_NUM_STACKS*(MAX_NUM_CARDS_IN_A_STACK+1)+MAX_NUM_FREECELLS) 

template <class StateWithLocation>
class FCSCompactStateWithLocations : public StateWithLocation
{
public:

    FCSCompactStateWithLocations();

    virtual ~FCSCompactStateWithLocations();

    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:
    FCSCompactState  m_State;
};

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

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

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

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

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

template <class StateWithLocation>
FCSCard* FCSCompactStateWithLocations<StateWithLocation>::GetStackCard(int Stack, int Card)
{
    return &(m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)+Card+1]);
}

template <class StateWithLocation>
char FCSCompactStateWithLocations<StateWithLocation>::GetStackCardSuit(int Stack, int Card)
{
    return m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)+Card+1].GetSuit();
}

template <class StateWithLocation>
char FCSCompactStateWithLocations<StateWithLocation>::GetStackCardNumber(int Stack, int Card)
{
    return m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)+Card+1].GetCardNumber();
}

template <class StateWithLocation>
int FCSCompactStateWithLocations<StateWithLocation>::GetStackLength(int Stack)
{
    return (int)m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)].m_Card;
}

template <class StateWithLocation>
FCSCard* FCSCompactStateWithLocations<StateWithLocation>::GetFreecellCard(int Freecell)
{
    return &(m_State.m_Data[FCS_FREECELLS_OFFSET + Freecell]);
}

template <class StateWithLocation>
char FCSCompactStateWithLocations<StateWithLocation>::GetFreecellCardSuit(int Freecell)
{
    return m_State.m_Data[FCS_FREECELLS_OFFSET + Freecell].GetSuit();
}

template <class StateWithLocation>
char FCSCompactStateWithLocations<StateWithLocation>::GetFreecellCardNumber(int Freecell)
{
    return m_State.m_Data[FCS_FREECELLS_OFFSET + Freecell].GetCardNumber();
}

template <class StateWithLocation>
char FCSCompactStateWithLocations<StateWithLocation>::GetFoundation(int Foundation)
{
    return m_State.m_Data[FCS_FOUNDATIONS_OFFSET + Foundation].m_Card;
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::IncrementFoundation(int Foundation)
{
    m_State.m_Data[FCS_FOUNDATIONS_OFFSET + Foundation].m_Card++;
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::SetFoundation(int Foundation, char Value)
{
    m_State.m_Data[FCS_FOUNDATIONS_OFFSET + Foundation].m_Card = Value;
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::PopStackCard(int Stack, FCSCard* Card)
{
    FCSCard* Temp = GetStackCard(Stack, GetStackLength(Stack)-1);
    Card->Copy(Temp);

    m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)+1+GetStackLength(Stack)-1].EmptyCard();
    m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)].m_Card--;
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::PushStackCardIntoStack(int DestStack, int SrcStack, int SrcCard)
{
    FCSCard* Temp = GetStackCard(SrcStack, SrcCard);
    PushCardIntoStack(DestStack, Temp);
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::PushCardIntoStack(int DestStack, FCSCard* Card)
{
    m_State.m_Data[DestStack*(MAX_NUM_CARDS_IN_A_STACK+1)+1+GetStackLength(DestStack)].Copy(Card);
    m_State.m_Data[DestStack*(MAX_NUM_CARDS_IN_A_STACK+1)].m_Card++;
}

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

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::EmptyFreecell(int Freecell)
{
    m_State.m_Data[FCS_FREECELLS_OFFSET+Freecell].m_Card = 0;
}

template <class StateWithLocation>
void FCSCompactStateWithLocations<StateWithLocation>::FlipStackCard(int Stack, int Card)
{
    m_State.m_Data[Stack*(MAX_NUM_CARDS_IN_A_STACK+1)+Card+1].SetFlipped(0);
}

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

    FCSCompactCard TempStack[(MAX_NUM_CARDS_IN_A_STACK+1)];
    FCSCompactCard TempFeecell;
    char TempLocation;

    /* Insertion-sort the stacks */

    for(b=1;b<NumberOfStacks;b++)
    {
        c = b;
        while((c>0) && (m_State.StackCompare(c*(MAX_NUM_CARDS_IN_A_STACK+1), (c-1)*(MAX_NUM_CARDS_IN_A_STACK+1)) < 0))
        {
            for (int a1 = 0;a1<(MAX_NUM_CARDS_IN_A_STACK+1);a1++)
                TempStack[a1] = m_State.m_Data[a1+c*(MAX_NUM_CARDS_IN_A_STACK+1)];

            for (int a2 = 0;a2<(MAX_NUM_CARDS_IN_A_STACK+1);a2++)
                m_State.m_Data[a2+c*(MAX_NUM_CARDS_IN_A_STACK+1)] = m_State.m_Data[a2+ (c-1)*(MAX_NUM_CARDS_IN_A_STACK+1)];

            for (int a3 = 0;a3<(MAX_NUM_CARDS_IN_A_STACK+1);a3++)
                m_State.m_Data[a3+(c-1)*(MAX_NUM_CARDS_IN_A_STACK+1)] = TempStack[a3];

            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_Data[FCS_FREECELLS_OFFSET+c].Compare(&(m_State.m_Data[FCS_FREECELLS_OFFSET+c-1])) < 0) )
        {
            TempFeecell = m_State.m_Data[FCS_FREECELLS_OFFSET+c];
            m_State.m_Data[FCS_FREECELLS_OFFSET+c] = m_State.m_Data[FCS_FREECELLS_OFFSET+c-1];
            m_State.m_Data[FCS_FREECELLS_OFFSET+c-1] = TempFeecell;

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

            c--;
        }
    }
}

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

#endif

---