gfCJigsawMinigameComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCJigsawMinigameComponent.h
*
*       Purpose:        Identification of JIG entities.
*
*********************************************************************/
 
#ifndef gfCJigsawMinigameComponenthdr
#define gfCJigsawMinigameComponenthdr
 
#include <fsCore/fsPoint.h>
#include <fsCore/src/fsCUniqueId.h>
 
#include "../gfIMinigameComponent.h"
#include "../gfIMinigameHintable.h"
#include "../gfCDrawOrderStateComponent.h"
 
#include "gfCJigsawDeckComponent.h"
#include "gfComponents/components/gfCGhostSpriteComponent.h"
 
class gfIStencil;
class fsCBrush;
class gfCDrawOrderControllerComponent;
class gfCJigsawDeckComponent;
class gfCJigsawLogicComponent;
 
 
class gfCJigsawMinigameComponent : public gfIMinigameComponent, public gfIMinigameHintable
{
        friend class gfCJigsawCluster;
        friend class gfCDrawOrderControllerComponent;
        friend class fsCComponentFactory;
        friend class gfCJigsawComponentCutter;
        friend class gfCDrawOrderStateComponent;
        // Reads home and rotation to aim its drags - the drop still goes through input.
        friend class gfCAutoTestAim;
 
public:
 
        static const fsCUniqueId mToggleEdgesMsg;
        static const fsCUniqueId mJigssawDroppedPieceMsg;
        static const fsStr mStartSuffix;
        static const fsCUniqueId mTypeId;
        static const fsStr mEntityPrefix;
 
        static void edgePiecesOnlyToggle();
 
        void hintPieceAndHomeSlot();
 
        fsBool isHintableGet() const override;
        fsBool hintDo() override;
 
        void gameLogicSet(gfCJigsawLogicComponent* const pParentLogic);
        fsBool activePickAndPlaceStartPiece() const;
        void unlink();
        void link(fsCEntity* pParent);
        void posSet(fsPoint const& pPos);
 
        void bordersRegister(fsS32 pTop, fsS32 pBottom);
 
        void cut(std::shared_ptr<fsCBrush> pTexture, gfIStencil* pStencil);
 
protected:
 
        static fsS32 mHomePositionThreshold;
 
        void listenersRegisterDo() override;
        void listenersDeregisterDo() override;
        fsBool messageProcessDo(const fsCUniqueId& pMessageType,
                                const fsIMessageDispatcher::sMessageParameters& pParam) override;
 
        void onTap(const fsPoint& pTapPos) override;
        void onDragStart(const fsPoint& pStartPos) override;
        void onDragMove(const fsPoint& pCurrPos) override;
        void onDragEnd(const fsPoint& pEndPos) override;
 
        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);
 
        gfCJigsawMinigameComponent(fsCEntity* pParent);
        virtual ~gfCJigsawMinigameComponent();
 
private:
 
        void droppedPiece();
 
        gfCDrawOrderControllerComponent* const drawOrderGet() const;
        gfCJigsawDeckComponent* const deckGet() const;
 
        void positionRelativeTo(gfCJigsawMinigameComponent* const pPiece) const;
 
        void pieceDrop();
 
        void drawOrderUpdate();
        void relink();
 
        void moveHome();
 
        void staticsReset();
 
        static void homePositionRangesGet();
 
        void moveBegin(const fsPoint& pNewDragPos);
        void move(const fsPoint& pNewDragPos);
 
        fsCEntity* const moveEntityGet() const;
        void startEntitiesLocate();
 
        void homePositonModify(const fsPoint& pAdjustment, fsBool pFirstTime);
        void shadowCreate();
        void shadowDestroy();
 
        void positionRegulate(fsPoint& pDragPos) const;
 
        void randomPositionSet(const fsCVariableTable& pVars);
        void randomRotationSet(const fsCVariableTable& pVars);
 
        void angleRotate();
        void angleSet(fsBool pPosSetRelativeToRoot);
        void positionUpdateFromDrag(const fsPoint& pDragPos);
        void completionFinalise(fsBool pShowCompletion);
        void completionFinalise();
        fsBool homePositionWithinLimits();
 
        void playSFX(const fsStr& pName) const;
 
        static gfCJigsawMinigameComponent* const namedSiblingsGet(const fsStr& pName);
        static std::vector<gfCJigsawMinigameComponent*> siblingssGet();
 
        fsPoint mPrevDragPos;
 
        fsS32 mNumRotSteps;
        fsS32 mCurrRotStep;
 
        fsBool mInHomePosition;
 
        fsCEntity* mShadowEntity;
        fsCEntity* mStartPair;
 
        fsBool mCutFromStencil;
 
        gfCJigsawMinigameComponent* mNextInCluster;
        gfCJigsawMinigameComponent* mPrevInCluster;
 
        gfCJigsawLogicComponent* mGameLogic;
 
        gfCGhostSpriteComponent* mGhostSprite;
        gfCGhostSpriteComponent* mOtherGhost;
        
        static fsS32 mBorderTop;
        static fsS32 mBorderBottom;
        static fsPoint mMaxPos;
        static fsPoint mMinPos;
        static fsPoint mBaseSize;
        static fsBool mClusteringEnabled;
 
        class CHomePosition
        {
        public:
 
                CHomePosition();
 
                fsPoint get() const;
                fsPoint originalHomeGet() const;
                void set(const fsPoint& pPos);
                void offsetSet(const fsPoint& pPos);
                const fsPoint& offsetGet() const;
 
        private:
 
                fsPoint mAdjustment;
                fsPoint mPos;
        } mHomePosition;
};
 
#endif