Cppcheck report - Fission: gameModules/gfHogCore/gfIHogLevel.cpp

#include "gfIHogLevel.h"

#include <fsCore/src/fsCGlobalSavedData.h>

#include <fsAudio/fsIAudioManager.h>

#include <fsRenderer/src/components/fsCTextSpriteComponent.h>
#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsAppCore/src/fsCScreenFade.h>
#include <fsAppCore/src/fsCLocalisedStrings.h>
#include <fsAppCore/src/fsCGuiMessageDispatcher.h>
#include <fsAppCore/src/fsCProfileManager.h>
#include <fsAppCore/src/fsCAppMessageDispatcher.h>

#if defined fsCacheCheck
	#include <fsAppCore/renderer/fsIRenderer.h>
#endif

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

#include <gfComponents/components/gfCLevelCompleteCheckerComponent.h>
#include <gfComponents/components/gfICollectableComponent.h>
#include <gfComponents/components/gui/gfCAutoMinigameButtonComponent.h>
#include <gfMinigameCore/components/gfISimpleCutterComponent.h>
#include <gfMinigameCore/components/jigsaw/gfCJigsawMinigameComponent.h>

#include <gfGameCore/src/gfCGameInventoryComponent.h>
#include "components/gfCHogLevelLoaderComponent.h"
#include <fsCore/fsIResourceNamePathAdjuster.h>

#include "components/gui/debug/gfCDebugWindowGui.h"
#include <gfGameCore/components/gfCConversationGui.h>
#include "components/gui/gfCGameGui.h"
#include "components/gui/gfCInGameCheatMenu.h"
#include <gfGameCore/components/gfCPauseMenuGui.h>
#include "components/levelSequencer/map/gfCLevelSequencerMapComponent.h"

#include "src/gfCHogCoreMain.h"
#include "src/gfCHogUserSavedData.h"
#include "src/gfCInGameAdsManager.h"
#include "src/fsCAutoMinigameLevelComponent.h"
#include "src/gfCHogCollectorsLevelComponent.h"

#if defined fsMovies
	#include <fsCore/fsIFile.h>
	#include <fsRenderer/src/components/fsCMovieSpriteComponent.h>
#endif



void gfIHogLevel::skip()
{
	skippedEntitiesForceCollect();
	skipDo();
}

void gfIHogLevel::skippedEntitiesForceCollect()
{
	fsCAppMessageDispatcher::instanceGet()->messageDispatch(
		gfICollectableComponent::mLevelSkipForceCollectMsg, fsIMessageDispatcher::mNullParam);
}

fsStr gfIHogLevel::levelNameGet() const  
{
	auto lev = levelNameFilenameGet();
	lev.erase(0,lev.rfind(fsIResourceNamePathAdjuster::mPathSeparator) + 1);
	lev.erase(lev.rfind("."));
	return lev;
}

void gfIHogLevel::tutorialGuiLinkToGui()
{
	if (auto* const tutorialRoot = parentGet()->childFind("dialogueRoot"))
	{
		if (auto* const guiRoot = parentGet()->childFind("GameGui"))
		{
			guiRoot->childAdd(tutorialRoot);
		}
	}
}

void gfIHogLevel::guiInitDo()
{
	tutorialGuiLinkToGui();
}

void gfIHogLevel::bestRunningTimeSet()
{
	if (0 == mBestTime
		|| mLevelRunningTime < mBestTime)
	{
		mBestTime = mLevelRunningTime;
	}
}

void gfIHogLevel::resetDo()
{
	mLevelRunningTime = 0;
	mRunning = eRUNNING;
}

void gfIHogLevel::deserialiseDo()
{
	mRunning = static_cast<eRUN_STATE>(parentGet()->s32Deserialise());
	mLevelRunningTime = parentGet()->s32Deserialise();
	mBestTime = parentGet()->s32Deserialise();
}

void gfIHogLevel::serialiseDo()
{
	parentGet()->s32Serialise(mRunning);
	parentGet()->s32Serialise(mLevelRunningTime);
	parentGet()->s32Serialise(mBestTime);
}

fsS32 gfIHogLevel::bestLevelRunningTimeGet() const
{
	return mBestTime;
}

fsS32 gfIHogLevel::levelRunningTimeGet() const
{
	return mLevelRunningTime; // total level running time - can be multiple visits
}

fsS32 gfIHogLevel::totalGameRunningTimeGet() const
{
	return mRunningTime + fsCProfileManager::instanceGet()->userSavedDataGet()->s32Get(
		gfCHogUserSavedData::mAchievementTime);
}

fsCEntity* const gfIHogLevel::parentGet() const
{
	return static_cast<fsCEntity*>(fsIComponent::parentGet());
}

std::vector<fsCEntity*> gfIHogLevel::minigameEntitiesGet()
{
	std::vector<fsCEntity*> minigameEnts;
	parentGet()->forAllChildren(
		[&minigameEnts](fsCEntity* const ent) -> void
		{
			if (auto* const comp = ent->firstComponentOfFamilyType<gfIMinigameComponent>())<--- Variable 'comp' is assigned a value that is never used.
			{
				minigameEnts.emplace_back(ent);
			}
		});
	return minigameEnts;
}

void gfIHogLevel::updateDo(fsS32 pDeltaMs)
{
#if defined fsInGameInterstitialAds
	if (mWaitingForInterstitialTransition)
	{
		if (gfCInGameAdsManager::instanceGet().transitionBlocked())
		{
			return;
		}

		mWaitingForInterstitialTransition = false;
		levelStateSave();
		parentGet()->destroy();
		return;
	}
#endif

	if (eRUNNING == mRunning)
	{
		if (!parentGet()->firstChildEntityWithComponentsOfFamilyType<fsCPauseMenuGui>())
		{
			mRunningTime += pDeltaMs;
			mLevelRunningTime += pDeltaMs;
		}
#if defined fsDEBUG
		if (gfCDebugWindowGui::instanceGet())
		{
			gfCDebugWindowGui::instanceGet()->timersUpdate(totalGameRunningTimeGet(), levelRunningTimeGet());
		}
#endif
	}
}

fsStr gfIHogLevel::nextLevelGet() const
{
	return gfCHogCoreMain::instanceGet()->nextLocationGet(mLevelName);
}

void gfIHogLevel::cheatMenuToggle()
{
	if (fsCEntity* const cheatEnt = parentGet()->childFind("inGameCheatWindow"))
	{
		fsCInGameCheatMenu* const cheatMenu = cheatEnt->componentGet<fsCInGameCheatMenu>();
		cheatMenu->parentGet()->destroy();
	}
	else
	{
		fsIGuiComponent::guiCreateFromFile(fsCResourceName("gui/debugWindow/inGameCheatWindow.txt",
		                                                   fsCResourceName::eRES_LOCATION_ASSETS), parentGet());
	}
}

void gfIHogLevel::abort()
{
	abortDo();
	levelStateSave();
}

void gfIHogLevel::guiLoad()
{
	const fsStr guiPath = fsILevelBasedAppCoreMain::instanceGet()->levelSettingsGet()->strGetWithDefault(
		"GUI", "gui/hogGui/hogGui.txt");
	fsIGuiComponent::guiCreateFromFile(fsCResourceName(guiPath, fsCResourceName::eRES_LOCATION_ASSETS), parentGet());
}

void gfIHogLevel::guiInit()
{
	if (auto* const gameGui = parentGet()->firstChildEntityWithComponentsOfFamilyType<fsCGameGui>())
	{
		gameGui->componentGet<fsCGameGui>()->delayButtonsInitialise();
	}

	guiInitDo();
}

void gfIHogLevel::jigsawEntitiesBorderSet()
{
	if (fsILevelBasedAppCoreMain::collectorsEditionContent(mLevelName))
	{
		return;
	}

	if (fsCEntity* const guiEnt = parentGet()->firstChildEntityWithComponentsOfFamilyType<fsCGameGui>())
	{
	{
		fsCEntity* const bgEnt = guiEnt->childFind("GameGuiBackground");
		fsCEntity* const topEnt = guiEnt->childFind("topGuiBackground");
		fsISpriteComponent* const bgSprite = bgEnt ? bgEnt->spriteComponentGet() : nullptr;
		fsISpriteComponent* const topSprite = topEnt ? topEnt->spriteComponentGet() : nullptr;
		if (bgSprite && topSprite)
		{
			const fsS32 guiBottomHeight = bgSprite->heightGet();
			const fsS32 guiTopHeight = topSprite->heightGet();

			if (fsCEntity* const minigameEnt = parentGet()->firstChildEntityWithComponentsOfFamilyType<
				gfCJigsawMinigameComponent>())
			{
				gfCJigsawMinigameComponent* minigameComp = minigameEnt->firstComponentOfFamilyType<
					gfCJigsawMinigameComponent>();
				minigameComp->bordersRegister(guiTopHeight, guiBottomHeight);
			}
		}
	}
	}
}

void gfIHogLevel::miniGameHelpSet()
{
	const fsStr minigameHelpTextKey = fsILevelBasedAppCoreMain::instanceGet()->levelSettingsGet()->strGet("helpText");
	if (!minigameHelpTextKey.emptyGet())
	{
		if (fsCEntity* minigameHelpTextEnt = parentGet()->childFind("GUIMinigameHelpText"))
		{
			fsITextSpriteComponent* helpTextSprComp = minigameHelpTextEnt->textComponentGet();
			fsAssert(helpTextSprComp != nullptr,
			         "Expected GUIMinigameHelpText entity to have a text sprite component.\n");
			helpTextSprComp->textSet(fsCLocalisedStrings::localisedStringGet(minigameHelpTextKey));
		}
	}
}

void gfIHogLevel::entitiesCreateFromCoordsFile()
{
#if defined fsTileMap
	if (fsStr::npos != mLevelName.find("tile"))
	{
		gfCTileMapLevelLoaderComponent* const loaderComp = parentGet()->componentAdd< gfCTileMapLevelLoaderComponent >();
		loaderComp->levelLoad(mLevelName, sceneFolderGet());
		parentGet()->componentDestroy(gfCTileMapLevelLoaderComponent::mTypeId);
	}
	else
#endif
	{
		gfCHogLevelLoaderComponent* const loaderComp = parentGet()->componentAdd<gfCHogLevelLoaderComponent>();
		loaderComp->levelLoad(mLevelName, sceneFolderGet());
		parentGet()->componentDestroy(gfCHogLevelLoaderComponent::mTypeId);
	}
}

fsStr gfIHogLevel::sceneFolderGet() const
{
	auto levName = mLevelName;
	levName.erase(levName.rfind(fsIResourceNamePathAdjuster::mPathSeparator) + 1);
	return levName;
}

void gfIHogLevel::cuttersStencilCreate()
{
	auto cutterEnts = parentGet()->childEntitiesWithComponentsOfFamilyType<gfICutterComponent>();
	for (auto cutter: cutterEnts)
	{
		cutter->firstComponentOfFamilyType<gfICutterComponent>()->stencilsCreate();
	}
}

void gfIHogLevel::cuttersCut(fsBool pFirstTime)
{
	auto cutterEnts = parentGet()->childEntitiesWithComponentsOfFamilyType<gfICutterComponent>();
	for (auto cutter: cutterEnts)
	{
		cutter->firstComponentOfFamilyType<gfICutterComponent>()->cut(pFirstTime);
	}
}

fsStr gfIHogLevel::saveStateKeyGet()
{
	return gfCHogUserSavedData::mLevelDataPrefix + mLevelName;
}

void gfIHogLevel::levelStateSaveDo()
{
	fsCProfileManager::instanceGet()->userSavedDataGet()->s32Set(gfCHogUserSavedData::mAchievementTime, mRunningTime +
	                                                             fsCProfileManager::instanceGet()->userSavedDataGet()->
	                                                             s32Get(gfCHogUserSavedData::mAchievementTime));
}

void gfIHogLevel::levelStateSave()
{
	fsStr saveStr;
	parentGet()->serialise(saveStr);
	fsCProfileManager::instanceGet()->userSavedDataGet()->strSet(saveStateKeyGet(), saveStr);

	levelStateSaveDo();

	fsCProfileManager::instanceGet()->allDataSave(true);
}

void gfIHogLevel::levelStateRestore(fsStr& pLoadStr)
{
	if (!pLoadStr.emptyGet())
	{
		parentGet()->deserialise(pLoadStr);
	}
	doLevelStateRestore();
}

void gfIHogLevel::listenersDeregisterDo()
{
	fsIMessageListener::listenersDeregisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(gfCHogLevelComponent::mLevelSkippedMsg, this);
	fsCGuiMessageDispatcher::instanceGet()->listenerDeregister(fsCScreenFade::mFadeOutCompleteMsg, this);
	fsCGuiMessageDispatcher::instanceGet()->listenerDeregister(fsCScreenFade::mFadeInCompleteMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(
		gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingCongratsMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerDeregister(
		gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingMsg, this);
}

void gfIHogLevel::listenersRegisterDo()
{
	fsIMessageListener::listenersRegisterDo();
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(gfCHogLevelComponent::mLevelSkippedMsg, this);
	fsCGuiMessageDispatcher::instanceGet()->listenerRegister(fsCScreenFade::mFadeOutCompleteMsg, this);
	fsCGuiMessageDispatcher::instanceGet()->listenerRegister(fsCScreenFade::mFadeInCompleteMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(
		gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingCongratsMsg, this);
	fsCAppMessageDispatcher::instanceGet()->listenerRegister(gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingMsg,
	                                                         this);
}

fsBool gfIHogLevel::mapLevelGet() const
{
	return fsCAppCoreMain::instanceGet()->sceneRootGet()->nameGet() == gfCLevelSequencerMapComponent::levelListNameGet()
		||
		fsCAppCoreMain::instanceGet()->sceneRootGet()->nameGet() == "map";
}

fsBool gfIHogLevel::messageProcessDo(const fsCUniqueId& pMessageType,
                                     const fsIMessageDispatcher::sMessageParameters& pParam)
{
	if (pMessageType == fsCScreenFade::mFadeOutCompleteMsg)
	{
#if defined fsInGameInterstitialAds
		if (!mapLevelGet())
		{
			mWaitingForInterstitialTransition = true;
			return true;
		}
#endif
		levelStateSave();
		parentGet()->destroy();
	}
	else if (pMessageType == fsCScreenFade::mFadeInCompleteMsg)
	{
		if (eWAITING == mRunning)
		{
			mRunning = eRUNNING;
		}
	}
	else if (pMessageType == gfCLevelCompleteCheckerComponent::mLevelCompleterMsg
		|| pMessageType == gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingCongratsMsg
		|| pMessageType == gfCLevelCompleteCheckerComponent::mLevelCompleteWaitingMsg
		|| pMessageType == gfCHogLevelComponent::mLevelSkippedMsg)
	{
		mRunning = eDONE;
	}
	return false;
}

void gfIHogLevel::levelCreate(const fsStr& pLevelName)
{
    mLevelName = pLevelName;
	entitiesCreateFromCoordsFile();

	doPostEntityCreation();

	fsStr levelState = fsCProfileManager::instanceGet()->userSavedDataGet()->strGet(saveStateKeyGet());
	const fsBool firstTime = levelState.emptyGet();
	if (firstTime)
	{
		// no level saved data so create stencils and cut out mini game pieces BEFORE mini game randomize called
		cuttersStencilCreate();
		cuttersCut(firstTime);
	}

	doLevelCreate();

	fsCAppMessageDispatcher::instanceGet()->messageDispatch(fsILevelBasedAppCoreMain::mLevelEntitiesCreatedMsg,
	                                                        fsIMessageDispatcher::sStrMessageParam(mLevelName));

	guiLoad();

	levelStateRestore(levelState);
	
	if (firstTime)
	{
		if (!fsILevelBasedAppCoreMain::collectorsEditionContent(levelNameFilenameGet()) 
			&& gfCConversationGui::conversationExists(levelNameGet() + "-pre"))
		{
			parentGet()->childAdd(gfCConversationGui::conversationCreate(levelNameGet() + "-pre"));
		}
	}
	else
	{
		// saved game data so stencils recreated so we can cut out same mini game pieces
		cuttersCut(firstTime);
	}

	guiInit();

	jigsawEntitiesBorderSet();
	miniGameHelpSet();

	parentGet()->update(1); // make sure all matrices are up to date

	fsIAudioManager::instanceGet()->musicPlay(fsCResourceName(fsILevelBasedAppCoreMain::instanceGet()->
													          levelSettingsGet()->strGet("music"),
													          fsCResourceName::eRES_LOCATION_ASSETS));
	fsIAudioManager::instanceGet()->effectPlay(fsCResourceName(fsILevelBasedAppCoreMain::instanceGet()->
																levelSettingsGet()->strGet("ambient"),
																fsCResourceName::eRES_LOCATION_ASSETS), true);
	
	fsLogMsg("Level loaded - load interstitial\n");

#if defined fsCacheCheck
	fsIRenderer::instanceGet()->cacheSizeReset();
#endif

#if defined fsInAppPurchaseProcess
	const fsBool rewardGateActive =
#if defined fsInGameAds
		gfCInGameAdsManager::instanceGet().rewardUnlockAvailable();
#else
		false;<--- Assignment 'rewardGateActive=false', assigned value is 0
#endif
	if (!rewardGateActive && fsCProfileManager::instanceGet()->progressBlockedByPaywallGet())<--- Condition '!rewardGateActive' is always true
	{
		fsIGuiComponent::guiCreateFromFile(fsCResourceName("gui/buyNowGui/buyNowGui.txt", fsCResourceName::eRES_LOCATION_ASSETS), parentGet());
	}
#endif

#if defined fsMovies
	auto movieFilename = fsCResourceName(fsStr("scenes/") + levelNameGet() + "/intro.mp4", fsCResourceName::eRES_LOCATION_ASSETS);
	if (fsIFile::fileExistsGet(movieFilename))
	{
		fsCEntity *movieEnt = parentGet()->entityFactoryGet()->emptyEntityCreate("movieEnt");
		auto movie = movieEnt->componentAdd<fsCMovieSpriteComponent>();
		movie->filenameSet(movieFilename);
		movie->play();
		parentGet()->childAdd(movieEnt);
	}
#endif

}

gfIHogLevel::gfIHogLevel(fsCEntity* const pParent) :
	fsIMessageListenerComponent(pParent),
	mLevelName(""),
	mLevelRunningTime(0),
	mRunningTime(0),
	mBestTime(0),
	mSkippedMiniGame(false),
	mWaitingForInterstitialTransition(false),
	mRunning(eWAITING)
{
};

gfIHogLevel::~gfIHogLevel()
{
}