FCSIndirectStateWithLocations.h

Go to the documentation of this file.

#ifndef MMANN_FCS_INDIRECT_STATE_WITH_LOCATIONS_H
#define MMANN_FCS_INDIRECT_STATE_WITH_LOCATIONS_H


#include <malloc.h>
#include "FCSStackStorage.h"
#include "FCHelpingAlgorithms.h"

class FCSIndirectState;

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

    virtual ~FCSIndirectStateWithLocations();

    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 Initialize(int NumberOfStacks);

    void CleanState();

    void CacheStacks(AFCSGenericStackStorage* Storage, int StackNumber);

    void CanonizeState(int NumberOfFreecells, int NumberOfStacks);

    FCSState* GetState();

public:
    FCSIndirectState  m_State;  
};

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

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

template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::Copy(FCSStateWithLocations* State)
{
    StateWithLocation::Copy(State);
    int StackLength;

    m_State.Copy(&(((FCSIndirectStateWithLocations*)State)->m_State));

    for(int a=0;a<MAX_NUM_STACKS;a++)
    {
        if (((FCSIndirectStateWithLocations*)State)->m_State.m_Stacks[a] != NULL)
        {
            StackLength = State->GetStackLength(a);
            
            m_State.m_Stacks[a] = new FCSIndirectCard[StackLength+53];
            for (int b = 0;b<StackLength+1;b++)
                m_State.m_Stacks[a][b].m_Card = ((FCSIndirectStateWithLocations*)State)->m_State.m_Stacks[a][b].m_Card;
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

    m_State.m_Stacks[Stack][GetStackLength(Stack)].EmptyCard();
    m_State.m_Stacks[Stack][0].m_Card--;
}

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

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

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

template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::EmptyFreecell(int Freecell)
{
    m_State.m_Freecells[Freecell].m_Card = 0;
}

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

template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::Initialize(int NumberOfStacks)
{
    for(int a=0;a<NumberOfStacks;a++)
        m_State.m_Stacks[a] = new FCSIndirectCard[MAX_NUM_DECKS*52+1];
}


template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::CleanState()
{
    for(int s=0;s<MAX_NUM_STACKS;s++)
        if (m_State.m_Stacks[s] != NULL)
            delete [] m_State.m_Stacks[s];
}

template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::CacheStacks(AFCSGenericStackStorage* Storage, int StackNumber)
{
    FCSIndirectCard *CacheStack;

    for (int a = 0;a<StackNumber;a++)
    {
        Realloc<FCSIndirectCard>(&m_State.m_Stacks[a], GetStackLength(a)+1, GetStackLength(a)+1);

        CacheStack = Storage->Insert(m_State.m_Stacks[a]);
        if (CacheStack != NULL)
        {
            delete [] m_State.m_Stacks[a];
            m_State.m_Stacks[a] = CacheStack;
        }
    }
}

template <class StateWithLocation>
void FCSIndirectStateWithLocations<StateWithLocation>::CanonizeState(int NumberOfFreecells, int NumberOfStacks)
{
    int b,c;
    FCSIndirectCard *TempStack,
                    TempFreecell;
    char TempLocation;

    /* Insertion-sort the stacks */
    for(b=1;b<NumberOfStacks;b++)
    {
        c = b;
        while(
            (c>0) && 
            (
#if MAX_NUM_DECKS > 1
                m_State.StackCompare
#else
                m_State.StackSortCompare
#endif
                (
                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) )
        {
            TempFreecell.m_Card = m_State.m_Freecells[c].m_Card;
            m_State.m_Freecells[c].m_Card = m_State.m_Freecells[c-1].m_Card;
            m_State.m_Freecells[c-1].m_Card = TempFreecell.m_Card;

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

            c--;
        }
    }   
}

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

#endif

---