Cppcheck report - Fission: gameModules/gfHogCore/simple/gfCSimpleCoreMain.cpp

#include "gfCSimpleCoreMain.h"

#include <memory>

#include <fsCore/fsIFile.h>
#include <fsCore/fsIResourceNamePathAdjuster.h>
#include <fsCore/src/fsCAppSettings.h>

#include <fsAppCore/src/components/gui/fsCNotificationsGui.h>
#include <fsAppCore/fsIDisplay.h>
#include <fsAppCore/src/fsCProfileManager.h>

#include "gfCSimpleLevelComponent.h"
#include <gfGameCore/src/gfCGameInventoryComponent.h>
#include "gfComponents/components/gfCLevelCompleteCheckerComponent.h"
#include "gfComponents/components/gfICollectableComponent.h"
#include "gfComponents/components/gfCVisibilityStateComponent.h"
#include "src/gfCHogCollectorsLevelComponent.h"
#include "../components/gfCMaskComponent.h"

#if defined fsInAppPurchase
    #include <fsPlatform/iap/fsIapFactory.h>
#endif

#include "../components/gui/debug/gfCDebugWindowGui.h"
#include "../components/test/gfCAutoTestManager.h"
#include "../components/gui/gfCButtonDelayComponent.h"
#include "../components/gui/debug/gfCDebugMenuGui.h"

#include "../src/gfCCollectionEffectFactory.h"
#include "../src/gfCHogComponentFactory.h"
#include "../src/gfCHogEntityFactory.h"
#include "../src/gfCHogLevelComponent.h"
#include "../src/gfCHogUserSavedData.h"
#include "../src/gfCHogRunningOrder.h"
#include <gfGameCore/src/gfCGameMessageDispatcher.h>

#if defined fsTileMap
    #include <gfTileMapCore/gfCTileMapGameComponentFactory.h>
#endif

#include <fsAppCore/src/fsCComponentFactory.h>
#include <fsAppCore/src/fsCEntityFactory.h>

namespace
{
std::shared_ptr<fsCComponentFactory> (*sExtraComponentFactoryProvider)() = nullptr;
std::shared_ptr<fsCEntityFactory> (*sExtraEntityFactoryProvider)() = nullptr;
}

void gfCSimpleCoreMain::extraComponentFactoryProviderSet(std::shared_ptr<fsCComponentFactory> (*pProvider)())
{
	sExtraComponentFactoryProvider = pProvider;
}

void gfCSimpleCoreMain::extraEntityFactoryProviderSet(std::shared_ptr<fsCEntityFactory> (*pProvider)())
{
	sExtraEntityFactoryProvider = pProvider;
}

#if defined fsInAppPurchase
namespace
{
class fsCPurchaseEntitlementSync final : public fsIapService::Observer
{
public:
    fsCPurchaseEntitlementSync() :
        mService(fsIapServiceCreate(this)),
        mRestoreInFlight(false)
    {
    }

    ~fsCPurchaseEntitlementSync() override
    {
        if (mService)
        {
            mService->shutdown();
        }
    }

    void start()
    {
        if (!mService)
        {
            return;
        }

        fsCProfileManager* const profileManager = fsCProfileManager::instanceGet();<--- Variable 'profileManager' can be declared as pointer to const
        if (!profileManager)
        {
            return;
        }

        mRestoreInFlight = true;
        mService->restorePurchases();
    }

    void onPurchaseCompleted(const std::string& productId) override
    {
        (void)productId;
        mRestoreInFlight = false;
        purchaseKnownHandle();
    }

    void onPurchaseRestored(const std::string& productId) override
    {
        (void)productId;
        mRestoreInFlight = false;
        purchaseKnownHandle();
    }

    void onPurchaseFailed(const std::string& productId, const std::string& reason) override
    {
        (void)productId;
        const bool isRestoreFailure = mRestoreInFlight;
        mRestoreInFlight = false;

        if (!isRestoreFailure || reason != "No purchases to restore")
        {
            return;
        }

        fsCProfileManager* const profileManager = fsCProfileManager::instanceGet();
        if (!profileManager)
        {
            return;
        }

        if (profileManager->fullGamePurchasedPersistedGet())
        {
            profileManager->fullGamePurchaseRevokeHandle();
        }
    }

    void onPurchaseCancelled(const std::string& productId) override
    {
        (void)productId;
        mRestoreInFlight = false;
    }

private:
    void purchaseKnownHandle()
    {
        fsCProfileManager* const profileManager = fsCProfileManager::instanceGet();
        if (!profileManager)
        {
            return;
        }

        if (!profileManager->fullGamePurchasedPersistedGet())
        {
            profileManager->fullGamePurchasedHandle();
        }
    }

    std::unique_ptr<fsIapService> mService;
    bool mRestoreInFlight;
};

std::unique_ptr<fsCPurchaseEntitlementSync> sPurchaseEntitlementSync;
}
#endif


void gfCSimpleCoreMain::stateSaveDo()
{
	if (sceneRootGet())
	{
		if (auto hogLevel = sceneRootGet()->firstChildEntityWithComponentsOfFamilyType<gfIHogLevel>())
		{
			hogLevel->firstComponentOfFamilyType<gfIHogLevel>()->levelStateSave();
		}
	}
}

void gfCSimpleCoreMain::profileManagerCreateDo()
{
	fsCProfileManager::create(fsCGlobalSavedData::create(), fsCUserSavedData::create<gfCHogUserSavedData>());
}

void gfCSimpleCoreMain::runningOrderReplace(const std::vector<fsStr> pNewOrder)
{
	mRunningOrder->replace(pNewOrder);
}

void gfCSimpleCoreMain::runningOrderCreate()
{
	delete mRunningOrder;
	
	mRunningOrder = new gfCHogRunningOrder(fsCResourceName(
			scenesFolderGet()
			+ "runningOrder.txt",
		fsCResourceName::eRES_LOCATION_ASSETS));
}

void gfCSimpleCoreMain::postUninitialiseDo()
{
	gfCAutoTestManager::destroy();
	fsILevelBasedAppCoreMain::postUninitialiseDo();
}

void gfCSimpleCoreMain::postInitialiseDo()
{
	fsILevelBasedAppCoreMain::postInitialiseDo();
	gfCAutoTestManager::create(entityFactoryGet(), componentFactoryGet());
}

void gfCSimpleCoreMain::abort(const fsStr& pNextLevelName)
{
	nextLocationSet(pNextLevelName);
	fsCProfileManager::instanceGet()->userSavedDataGet()->strSet(fsCUserSavedData::mCurrentLocation, pNextLevelName);
}

void gfCSimpleCoreMain::updateDo(fsS32 pDeltaMs)
{
	if (nextLocationReady() && sceneGet()->emptyGet())
	{
		nextLocationInitialise();
	}
}

void gfCSimpleCoreMain::nextLocationInitialiseDo(const fsStr& pLevelName)
{
	if (fsStr::npos == mCurrentLevelName.find(scenesFolderGet())
		&& !collectorsEditionContent(pLevelName))
	{
		childAddToAppScene(fsIGuiComponent::guiCreateFromFile(
			fsCResourceName(mCurrentLevelName, fsCResourceName::eRES_LOCATION_ASSETS)));
	}
	else
	{
		childAddToAppScene(fsIScene::create(mRootEntityName));

	    gfIHogLevel* gameLevelComponent{ nullptr };
	    fsCEntity* const gameLevelEntity{fsCAppCoreMain::instanceGet()->sceneRootGet()};

	    gameLevelComponent = gameLevelEntity->componentAdd<gfCSimpleLevelComponent>();
	    gameLevelEntity->componentAdd<gfCLevelCompleteCheckerComponent>();
	    gameLevelEntity->componentAdd<gfCGameInventoryComponent>();

	    gameLevelComponent->levelCreate(pLevelName);
	    fsCProfileManager::instanceGet()->userSavedDataGet()->strSet(gfCHogUserSavedData::mCurrentLocation, pLevelName);
	    fsCProfileManager::instanceGet()->allDataSave(true);
	}
}

void gfCSimpleCoreMain::factoriesCreateDo()
{
	auto hogcomponentFactory = gfCHogComponentFactory::create();

#if defined fsTileMap
	auto tileMapCoreFactory = gfCTileMapGameComponentFactory::create();
	hogcomponentFactory->merge(tileMapCoreFactory.get());
#endif

	if (sExtraComponentFactoryProvider)
	{
		auto extraComponentFactory = sExtraComponentFactoryProvider();
		hogcomponentFactory->merge(extraComponentFactory.get());
	}

	componentFactorySet(hogcomponentFactory);

	auto entityFactory = gfCHogEntityFactory::create();

	if (sExtraEntityFactoryProvider)
	{
		auto extraEntityFactory = sExtraEntityFactoryProvider();
		entityFactory->merge(extraEntityFactory.get());
	}

	entityFactorySet(entityFactory);

	gfCCollectionEffectFactory::create();

	gfICollectableComponent::extraPersistentTagCheckProviderSet([](fsCEntity* const pEntity) -> fsBool
	{
		return pEntity->tagExists(gfCHogEntityFactory::bonusPickablePrefix)
			|| pEntity->tagExists(gfCHogEntityFactory::bonusSilhouettePickablePrefix)
			|| pEntity->tagExists(gfCHogEntityFactory::bonusPhotoPickablePrefix)
			|| pEntity->tagExists(gfCHogEntityFactory::bonusBonusPickablePrefix)
			|| pEntity->tagExists(gfCHogEntityFactory::bonusStaffPickablePrefix);
	});

	gfCVisibilityStateComponent::maskKeyCheckProviderSet(&gfCMaskComponent::get);

	hogSpecificComponentsRegister();
	gameSpecificComponentsRegister();
}

void gfCSimpleCoreMain::hogSpecificComponentsRegister()
{
	componentFactoryGet()->componentRegister<fsCButtonDelayComponent>();
	componentFactoryGet()->componentRegister<gfCDebugWindowGui>();
	componentFactoryGet()->componentRegister<gfCDebugMenuGui>();
}

void gfCSimpleCoreMain::initialiseDo()
{
#if defined fsInAppPurchase
    if (!sPurchaseEntitlementSync)
    {
        sPurchaseEntitlementSync = std::make_unique<fsCPurchaseEntitlementSync>();
    }
    sPurchaseEntitlementSync->start();
#endif
}

void gfCSimpleCoreMain::preInitialiseDo()
{
	fsILevelBasedAppCoreMain::preInitialiseDo();
	chaptersLocate();
	fsCProfileManager::instanceGet()->userSavedDataGet()->strSet(gfCHogUserSavedData::mLastMainMenuGui, "");
}

void gfCSimpleCoreMain::preUninitialiseDo()
{
	if (auto* const hoglevelEnt = sceneGet()->firstEntityWithComponentsOfFamilyType<gfIHogLevel>())
	{
		if (auto* const hogLevel = hoglevelEnt->firstComponentOfFamilyType<gfIHogLevel>())
		{
			hogLevel->abort();
		}
	}
}

void gfCSimpleCoreMain::uninitialiseDo()
{
	gfCCollectionEffectFactory::destroy();
	fsCProfileManager::instanceGet()->userSavedDataGet()->strSet(gfCHogUserSavedData::mLastMainMenuGui, "");

#if defined fsInAppPurchase
    sPurchaseEntitlementSync.reset();
#endif
}

void gfCSimpleCoreMain::messageDispatchersCreateDo()
{
	gfCGameMessageDispatcher::create();
}

void gfCSimpleCoreMain::messageDispatchersDestroyDo()
{
	gfCGameMessageDispatcher::destroy();
}

void gfCSimpleCoreMain::create()
{
	if (instanceGet() != nullptr)
	{
		fsAssert(false, "Already created fsCHogCoreMain.");
		destroy();
	}

	mInstance = new gfCSimpleCoreMain();
	static_cast<gfCSimpleCoreMain*>(mInstance)->initialise();
}

gfCSimpleCoreMain* gfCSimpleCoreMain::instanceGet()
{
	return static_cast<gfCSimpleCoreMain*>(mInstance);
}

gfCSimpleCoreMain::gfCSimpleCoreMain():
fsILevelBasedAppCoreMain()
{
}

gfCSimpleCoreMain::~gfCSimpleCoreMain()
{
}