gfCHogLevelComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCHogLevel.h
*       
*       Purpose:        Create and control game entities.
*
*********************************************************************/
 
#ifndef gfCHogLevelhdr
#define gfCHogLevelhdr
 
#include <vector>
 
#include <fsCore/fsStr.h>
#include <fsCore/fsPoint.h>
 
#include "../gfIHogLevel.h"
#include "components/gfIMinigameLogic.h"
#include "src/fsCEntityFactory.h"
 
class gfCSubSceneComponent;
class fsRect;
 
 
class gfCHogLevelComponent : public gfIHogLevel
{
        friend class fsCComponentFactory;
 
public:
 
        static const fsCUniqueId mTypeId;
 
        static const fsCUniqueId mLevelSkippedMsg;
 
        void renderEffectRefresh();
 
 
        void listenersDeregisterDo() override;
        void listenersRegisterDo() override;
        fsBool messageProcessDo(const fsCUniqueId& pMessageType,
                                const fsIMessageDispatcher::sMessageParameters& pParam) override;
 
 
protected:
 
        static fsIComponent* create(fsCEntity* pParent);
 
    void skipDo() override;
 
    void updateDo(fsS32 pDeltaMs) override;
        void renderDo() override;
 
        virtual void actAdvance();
        virtual fsStr rewardSequencFileNameGetIfActive();
 
        virtual void levelResetDo();
        void abortDo() override;
 
        void doLevelCreate() override;
 
        gfCHogLevelComponent(fsCEntity* pParent);
        virtual ~gfCHogLevelComponent();
 
private:
 
        enum eDebugRenderEffect
        {
                eDEBUG_RENDER_EFFECT_NONE,
                eDEBUG_RENDER_EFFECT_MAGNIFY,
                eDEBUG_RENDER_EFFECT_TORCH
        };
 
        template<typename TLogic, typename  TMinigame>
        void minigameLogicAdd(std::vector<gfIMinigameLogic*>& pLogicEntities);
        template<typename TLogic>
        void minigameLogicAdd(std::vector<gfIMinigameLogic*>& pLogicEntities, const fsStr& pEntityName = "");
 
        fsBool devCheatKeyTest(fsS32 pTypedChar);
        void renderEffectApply(eDebugRenderEffect pEffect);
        void debugRenderEffectCycle();
        fsBool releaseCheatKeyTest(fsS32 pTypedChar);
 
        void tutorialAdd();
 
        void levelReset();
        
        void reset();
 
        void miniGameLogicComponentsAdd();
 
        void actCompleteHandle();
    fsBool levelSkippedForAnalytics() const;
    fsS32 adFreeLevelCountGet() const;
    fsS32 rewardPackSizeGet() const;
    fsS32 rewardTailGraceCountGet() const;
    fsS32 rewardUnlockedLevelCountGet(fsS32 pTotalLevels) const;
    void rewardUnlockedLevelCountSet(fsS32 pUnlockedCount) const;
    fsBool rewardGateRequiredForNextLevel() const;
    void rewardUnlockGrantForCurrentBoundary();
    fsBool interstitialAllowedForCurrentLevel() const;
    void rewardGatePaywallShow();
 
        fsBool typedCharacterHandle(fsS32 pTypedChar);
 
 
        fsBool mResetDuringFade;
    fsBool mPendingInterstitialOnFadeOut;
    fsBool mRewardGatePending;
    fsBool mPaywallDestroyOnFadeOut;
    fsBool mSkipInterstitialOnce;
    fsBool mLevelSkippedForAnalytics;
        eDebugRenderEffect mDebugRenderEffect;
        fsS32 mDebugRenderEffectCycleIndex;
};
 
// Always add/collect the logic, using its full construction plan when an entity name is supplied.
template<typename TLogic>
void gfCHogLevelComponent::minigameLogicAdd(std::vector<gfIMinigameLogic*>& logicEntities,
        const fsStr& entityName)
{
        auto* parent = parentGet();
        auto* logicEntity =     parent->firstChildEntityWithComponentsOfFamilyType<TLogic>();
 
        if (!logicEntity)
        {
                if (entityName.emptyGet())
                {
                        logicEntity = parent->entityFactoryGet()->emptyEntityCreate("minigameLogic");
                        logicEntity->template componentAdd<TLogic>();
                }
                else
                {
                        logicEntity = parent->entityFactoryGet()->entityConstruct(entityName);
                }
                parent->childAdd(logicEntity);
        }
 
        auto* logic = logicEntity->template firstComponentOfFamilyType<TLogic>();
 
        if (std::find(logicEntities.begin(), logicEntities.end(), logic) ==
                logicEntities.end())
        {
                logicEntities.push_back(logic);
        }
}
 
// Add/collect the logic only when the minigame exists.
template<typename TLogic, typename TMinigame>
void gfCHogLevelComponent::minigameLogicAdd(std::vector<gfIMinigameLogic*>& logicEntities)
{
        if (!parentGet()->template firstChildEntityWithComponentsOfFamilyType<TMinigame>())
        {
                return;
        }
 
        minigameLogicAdd<TLogic>(logicEntities);
}
#endif