gfCHOGHint.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCHOGHint.h
*
*       Purpose:        Wrap up all the hint behaviour
*
*********************************************************************/
 
#ifndef gfCHOGHinthdr
#define gfCHOGHinthdr
 
#include <algorithm>
#include <vector>
 
#include <fsCore/fsBaseTypes.h>
#include <fsCore/src/fsNRnd.h>
 
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>
 
#include <gfComponents/components/subScene/gfCSubSceneComponent.h>
 
#include "components/gui/gfCGameGui.h"
#include "src/fsCEntity.h"
 
 
class gfCHOGHint
{
public:
 
        fsBool hinted() const;
 
        fsBool activate(fsCEntity* pStartEnt, fsCEntity* pEndEnt);
        fsBool activate(std::vector<fsCEntity*>& pCandidates);
 
        gfCHOGHint(fsCGameGui* pParent);
        ~gfCHOGHint();
 
protected:
 
private:
 
        template<typename TMinigameType>
        std::vector<fsCEntity*>
        minigameEntsGet() const;
 
        template<typename T>
        fsBool hintOnMinigames() const;
 
        fsBool hintOnSubSceneNavigationComponents() const;
        fsBool hintOnWordSearch() const;
 
        void zoomedLevelReset() const;
 
        void hintEffectActivate(fsCEntity* pTargetEntity) const;
 
        fsBool previoustlyHinted(fsCEntity* pEnt) const;
 
        std::vector<fsCEntity*> mPreviouslyHintedEnts;
 
        fsCGameGui* mParent;
};
 
template<typename TMinigameType>
std::vector<fsCEntity*>
gfCHOGHint::minigameEntsGet() const
{
        std::vector<fsCEntity*> minigameEnts;
 
        auto subSceneEnts = mParent->appSceneEntitiesWithComponentOfFamilyType<gfCSubSceneComponent>();
        for (fsCEntity* subSceneEnt : subSceneEnts)
        {
                if (subSceneEnt->visibleGet())
                {
                        minigameEnts = subSceneEnt->childEntitiesWithComponentsOfFamilyType<TMinigameType>();
                }
        }
 
        if (minigameEnts.empty())  // linked to minigame logic not sub scene
        {
                minigameEnts = mParent->grandparentGet()->childEntitiesWithComponentsOfFamilyType<TMinigameType>();
        }
 
        minigameEnts.erase(std::remove_if(std::begin(minigameEnts), std::end(minigameEnts),
                [](fsCEntity* ent)
                {
                        return nullptr == ent->componentGet<TMinigameType>();
                }),
                minigameEnts.end());
 
        return minigameEnts;
}
 
template<typename T>
fsBool gfCHOGHint::hintOnMinigames() const
{
        auto minigameEnts = minigameEntsGet<T>();
 
        minigameEnts.erase(std::remove_if(std::begin(minigameEnts), std::end(minigameEnts),
                [](fsCEntity* const ent) { return !ent->componentGet<T>()->isHintableGet(); }),
                std::end(minigameEnts));
 
        if (minigameEnts.empty())
                return false;
 
        auto active = std::find_if(std::begin(minigameEnts), std::end(minigameEnts),
                [](fsCEntity* ent) { return ent->componentGet<T>()->isActiveGet(); });
 
        fsCEntity* chosen;
        if (active != std::end(minigameEnts))
        {
                chosen = *active;
        }
        else
        {
                std::shuffle(std::begin(minigameEnts), std::end(minigameEnts), fsNRnd::randomDeviceGet());
                chosen = minigameEnts.front();
        }
 
        if (!chosen->componentGet<T>()->hintDo())
        {
                auto* const gameGui = fsILevelBasedAppCoreMain::instanceGet()->sceneGet()
                        ->firstEntityWithComponentsOfFamilyType<fsCGameGui>()->componentGet<fsCGameGui>();
                return gameGui->hintActivate(chosen, nullptr);
        }
        return true;
}
 
#endif