gfCWordSearchMinigameLogicComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       Created:        13/1/2015   14:34
*
*       File:           gfCWordSearchMinigameLoaderComponent.h
*
*       Author:         Martin P. King
*       
*       Purpose:        Logic for word search - control grid of
*                               fsCWordSearchMinigameComponents
*
*********************************************************************/
 
#ifndef gfCWordSearchMinigameLoaderComponenthdr
#define gfCWordSearchMinigameLoaderComponenthdr
 
#include <fsCore/fsPoint.h>
#include <fsCore/fsGrid.h>
#include <fsCore/fsSColour.h>
 
#include "../../gfIMinigameLogic.h"
 
#include "gfComponents/components/subScene/gfIOpaqueLensComponent.h"
 
class fsCResourceName;
class gfCMinigameLetterTileComponent;
class gfCWordSearchMinigameGenerateComponent;
class gfCMazeMinigameGenerateComponent;
 
 
class gfCWordSearchMinigameLogicComponent : public gfIMinigameLogic
{
        friend class fsCComponentFactory;
 
public:
 
        struct sWordSearchMessageParam : public fsIMessageDispatcher::sStrMessageParam
        {
                fsCEntity* mEnt;
        };
 
        static const fsCUniqueId mTypeId;
        static const fsStr mEntityPrefix;
        static const fsStr mSelectionPrefix;
 
        fsBool hintActivate();
 
        std::vector<fsCEntity*> selectedWordsGet() const;
 
        void wordSelected();
        void tilesSelect(gfIOpaqueLensComponent::fsSSwipe const& pSwipe);
        void tilesHilite(gfIOpaqueLensComponent::fsSSwipe const& pSwipe);
        void tileTap(const fsPoint& pTapPos);
 
        fsStr tileSetGet() const { return mTileSet; }
 
        void initialiseWithGenerator(gfCWordSearchMinigameGenerateComponent* pGenerator);
        void initialiseWithGenerator(gfCMazeMinigameGenerateComponent* pGenerator);
 
        ~gfCWordSearchMinigameLogicComponent();
 
protected:
 
        void skipDo() override;
 
        void listenersRegisterDo() override;
        void listenersDeregisterDo() override;
        fsBool messageProcessDo(const fsCUniqueId& pMessageType,
                                const fsIMessageDispatcher::sMessageParameters& pParam) override;
 
        void resetDo() override;
        void deserialiseDo() override;
        void serialiseDo() override;
 
        void initialiseFromVariableTableDo(const fsCVariableTable& pVars) override;
 
        static fsIComponent* create(fsCEntity* pParent);
 
        gfCWordSearchMinigameLogicComponent(fsCEntity* pParent);
 
private:
 
        struct fsSSelection
        {
                fsStr mWord = {""};
                std::vector<fsCEntity*> mLines;
                std::vector<gfCMinigameLetterTileComponent*> mTiles;
                std::vector<fsPoint> mGridPoints;
 
                fsSSelection() = default;
                ~fsSSelection() = default;
 
                fsBool empty() const;
                void tilesTint(fsSColour4B const& pTint);
                void clear();
        };
 
        static const fsSColour4B mTileTint;
 
        std::vector<fsPoint> selectionLineSmooth(fsSSelection& pSelection);
        void selectionLineCreate(fsSSelection& pSelection, fsSColour4B const& pTint);
        void checkWords();
 
        void snakeWordSelect(fsPoint const& pTapPos);
        fsBool legalSnakeWord(const fsPoint& pTapPos);
 
        void tilesSelectionHighlight(fsPoint tileAlignedStart, fsPoint tileAlignedEnd);
 
        void gridInit(std::vector<std::vector<fsStr>>& pTileGrid, fsPoint const& pOrigin, fsPoint const& pGridDimensions);
        fsStr wordCandidate();
 
        void selectionAdjust(fsCEntity* pSelection, fsPoint const& pStart, fsPoint const& pEnd);
        fsCEntity* selectionSpriteCreate(fsSSelection& pSelection, const fsCResourceName& pBrushName,fsSColour4B const& pTint);
        void selectionSegmentCreate(fsSSelection& pSelection, fsPoint const& pStart, fsPoint const& pEnd, fsSColour4B const& pTint);
        void selectionCapAdjust(fsCEntity* pSelection, fsPoint const& pPos, fsF32 pAngle);
        fsPoint selectionCapOffsetGet(fsCEntity* pSelection, fsPoint const& pStart, fsPoint const& pEnd) const;
        fsPoint selectionEndConstrainedGet(fsPoint const& pStart, fsPoint const& pEnd) const;
        fsBool selectionDiagonalGet(fsPoint const& pSize) const;
        fsF32 selectionAngleGet(fsPoint const& pStart, fsPoint const& pEnd) const;
        fsBool selection2Available() const;
 
 
        gfCMinigameLetterTileComponent* const tileComponentGet(fsCEntity* pEnt);
        gfCMinigameLetterTileComponent* const tileCreate(fsPoint const& pGridPos,
                                                         std::vector<std::vector<fsStr>>& pLoadingLetterGrid);
 
        void selectionsClear();
        void selectionRecreate(fsStr& pSelectedWord);
        void selectionsRecreate();
        fsBool wordFindInGrid(fsSSelection& pSelection);
 
        void wordsEntitiesGenerate();
 
        static const fsStr mSelectionChunkMarker;
 
        fsStr mTileSet = {""};
        fsBool mMaze = {false};
 
        fsGrid<gfCMinigameLetterTileComponent*> mTileGrid;
        std::vector<fsStr> mHiddenWords;
 
        fsSSelection mHintSelection;
        fsSSelection mActiveSelection;
        
        std::vector<std::unique_ptr<fsSSelection>> mFoundWords;
 
        std::unique_ptr<fsCResourceName> mHilight;
        std::unique_ptr<fsCResourceName> mHilight2;
        std::unique_ptr<fsCResourceName> mHilight2End;
};
 
 
#endif