gfCWordSearchMinigameGenerateComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCWordSearchMinigameGenerateComponent.h
*
*       Purpose:        Generate word search files to be consumed by the
*                               word search mini game
*
*********************************************************************/
 
#ifndef gfCWordSearchMinigameGenerateComponenthdr
#define gfCWordSearchMinigameGenerateComponenthdr
 
#include <vector>
#include <fsCore/src/fsCUniqueId.h>
 
#include <fsAppCore/src/components/fsIComponent.h>
 
 
class gfCWordSearchMinigameGenerateComponent : public fsIComponent
{
        friend class fsCComponentFactory;
        friend class gfCWordSearchMinigameLogicComponent;
 
public:
 
        fsBool generate(fsStr const& pTileSet, fsStr const& pHilight, fsPoint const& pDimensions, fsPoint const& pOffset,
                        std::vector<fsStr> pWords);
 
        static const fsCUniqueId mTypeId;
 
protected:
 
        static fsIComponent* create(fsCEntity* pParent);
 
        gfCWordSearchMinigameGenerateComponent(fsCEntity* pParent);
        virtual ~gfCWordSearchMinigameGenerateComponent();
 
private:
 
        struct gfSGridDirection
        {
                gfSGridDirection(gfCWordSearchMinigameGenerateComponent* const pParent, fsS32 pDimensionLimit,
                                 fsS32 pDimensionIndex, const fsStr& pWord, fsBool pReverse) :
                        mParent(pParent),
                        mWord(pWord),
                        mDimensionLimit(pDimensionLimit),
                        mDimensionIndex(pDimensionIndex),
                        mReverse(pReverse)
                {
                }
 
                fsS32 wordIndexGet(fsS32 pIndex) const;
                virtual void copyToGrid(fsS32 pColumn, fsS32 pRow) const;
                virtual fsS32 startIndexFind();
 
                fsS32 dimensionLimitGet() const { return mDimensionLimit; }
                fsS32 wordLengthGet() const { return mWord.lengthGet(); }
 
                virtual void doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const = 0;
                virtual fsBool legalEntry(fsS32 pIndex) const { return false; }
 
                gfCWordSearchMinigameGenerateComponent* const mParent;
                const fsStr mWord;
                const fsS32 mDimensionLimit;
                const fsS32 mDimensionIndex;
                const fsBool mReverse;
        };
 
        struct gfSColumn : public gfSGridDirection
        {
                gfSColumn(gfCWordSearchMinigameGenerateComponent* const pParent, fsS32 pMax, fsS32 pIndex, const fsStr& pWord,
                          fsBool pReverse):
                        gfSGridDirection(pParent, pMax, pIndex, pWord, pReverse)
                {
                }
 
                fsBool legalEntry(fsS32 pIndex) const override;
                void doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const override;
        };
 
        struct gfSRow : public gfSGridDirection
        {
                gfSRow(gfCWordSearchMinigameGenerateComponent* const pParent, fsS32 pMax, fsS32 pIndex, const fsStr& pWord,
                       fsBool pReverse):
                        gfSGridDirection(pParent, pMax, pIndex, pWord, pReverse)
                {
                }
 
                fsBool legalEntry(fsS32 pIndex) const override;
                void doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const override;
        };
 
        struct gfSDiagonalBLTR : public gfSGridDirection
        {
                gfSDiagonalBLTR(gfCWordSearchMinigameGenerateComponent* const pParent, fsS32 pMax, fsS32 pIndex,
                                const fsStr& pWord, fsBool pReverse):
                        gfSGridDirection(pParent, pMax, pIndex, pWord, pReverse)
                {
                }
 
                virtual fsBool legalColRowEntry(fsS32 pColumn, fsS32 pRow) const;
                void doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const override;
                fsS32 startIndexFind() override;
        };
 
        struct gfSDiagonalTLBR : public gfSGridDirection
        {
                gfSDiagonalTLBR(gfCWordSearchMinigameGenerateComponent* const pParent, fsS32 pMax, fsS32 pIndex,
                                const fsStr& pWord, fsBool pReverse):
                        gfSGridDirection(pParent, pMax, pIndex, pWord, pReverse)
                {
                }
 
                virtual fsBool legalColRowEntry(fsS32 pColumn, fsS32 pRow) const;
                void doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const override;
                fsS32 startIndexFind() override;
        };
 
        static const fsStr mPlaceHolderTile;
 
        std::vector<fsS32> randommIndicesGet(fsS32 pMaxIndex) const;
 
        fsStr randomLetterGet() const;
        void emptyTilesReplaceWithRandomLetter();
 
        fsS32 startDiagonalBLTRColumnFindInRow(fsS32 pRow, const fsStr& pWord);
        fsS32 startDiagonalTLBRColumnFindInRow(fsS32 pRow, const fsStr& pWord);
 
        fsBool wordAddDiagonalTLBR(const fsStr& pWord);
        fsBool wordAddDiagonalBLTR(const fsStr& pWord);
        fsBool wordAddVertical(const fsStr& pWord);
        fsBool wordAddHorizontal(const fsStr& pWord);
        fsBool wordsAdd(std::vector<fsStr>& pWords);
 
        void wordListSortLongestFirst(std::vector<fsStr>& pWords);
 
        void fileSave();
 
        void gridCreate();
 
        fsPoint mDimensions;
        fsPoint mOffest;
        fsStr mTileSet;
        fsStr mHilight;
 
        std::vector<fsStr> mTiles;
        std::vector<fsStr> mWords;
};
 
#endif