gfCSlidasquareMinigameComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCSlidasquareMinigameComponent.h
*
*       Purpose:        Sliding squares mini game
*
*********************************************************************/
 
#ifndef gfCSlidasquareMinigameComponenthdr
#define gfCSlidasquareMinigameComponenthdr
 
#include <algorithm>
 
#include "../rotate/gfCRotateMinigameComponent.h"
 
class gfIStencil;
class fsCBrush;
 
 
class gfCSlidasquareMinigameComponent : public gfCRotateMinigameComponent
{
        friend class fsCComponentFactory;
 
public:
 
        static const fsStr mCloneName;
        static const fsCUniqueId mTypeId;
        static const fsStr mEntityPrefix;
 
        void cut(std::shared_ptr<fsCBrush> pTexture, gfIStencil* pStencil);
 
protected:
 
        fsBool homeGet() const override;
        fsBool fullHomeLock() const override;
 
        void listenersDeregisterDo() override;
        void listenersRegisterDo() override;
        fsBool messageProcessDo(const fsCUniqueId& pMessageType,
                                const fsIMessageDispatcher::sMessageParameters& pParam) override;
 
        void updateDo(fsS32 pDeltaMs) override;
 
        void tileSlide(fsS32 pDeltaMs);
 
        void serialiseDo() override;
        void deserialiseDo() override;
 
        void resetDo() override;
        void initialiseDo(const fsCVariableTable& pVars) override;
        void skipDo() override;
 
        fsBool acceptingInputGet() const override;
 
        static fsIComponent* create(fsCEntity* pParent);
 
        gfCSlidasquareMinigameComponent(fsCEntity* pParent);
        virtual ~gfCSlidasquareMinigameComponent();
 
private:
 
        void tileSlideInstantly(const fsPoint& pPos);
 
        void gameTypeSet(const fsStr& pGameType);
 
        typedef fsBool (gfCSlidasquareMinigameComponent::*fsTSortMemFnc)(gfCSlidasquareMinigameComponent* pSlida) const;
        typedef fsBool (gfCSlidasquareMinigameComponent::*fsTMatchMemFnc)(const fsPoint& pPos) const;
 
        fsBool rowOrder(gfCSlidasquareMinigameComponent* pSlida) const;
        fsBool columnOrder(gfCSlidasquareMinigameComponent* pSlida) const;
        fsBool sameRowGet(const fsPoint& pPos) const;
        fsBool sameColumnGet(const fsPoint& pPos) const;
 
        fsCEntity* const wrapRoundTileClone();
        std::vector<gfCSlidasquareMinigameComponent*> stackCollate(fsTMatchMemFnc pMatch, fsTSortMemFnc pSort,
                                                                   fsS32 pDirection);
        void stackTargetPositionsSet(std::vector<gfCSlidasquareMinigameComponent*>& pStack, fsBool pImmediate);
 
        void columnSlide(fsS32 pDirection, fsBool pImmediate);
        void rowSlide(fsS32 pDirection, fsBool pImmediate);
 
        void slide(const fsPoint& pTapPos, fsBool pImmediate);
 
        static fsBool holeAdjacent(fsCEntity* pEnt);
        static void staticsInit(fsS32 pHoleID);
 
        void randomize();
 
        void completedCheck();
 
        std::vector<gfCSlidasquareMinigameComponent*> slidaComponentsGet(fsBool pIncludeClones);
 
        enum eGameType
        {
                eTRADITIONAL_SLIDA,
                eROW_SLIDE,
                eCOLUMN_SLIDE,
                eROW_AND_COLUMN_SLIDE
        };
 
 
        fsPoint mHomePosition;
        fsPoint mTargetPosition;
 
        static fsBool mCompleted;
        static fsS32 mHoleID;
        static fsS32 mSpeed;
        static eGameType mGameType;
        static fsCEntity* mHole;
        static fsCEntity* mSlida;
 
        static const fsS32 mHoleIDNotSet;
        static const fsS32 mNoHole;
};
 
#endif