Cppcheck report - Fission: libs/fsAppCore/src/fsILevelBasedAppCoreMain.cpp

#include "fsILevelBasedAppCoreMain.h"

#include <fsCore/fsIResourceNamePathAdjuster.h>
#include <fsCore/src/debug/fsAssert.h>

#include <fsAppCore/src/fsCAppMessageDispatcher.h>
#include <fsAppCore/fsIRunningOrder.h>
#include <fsAppCore/src/components/fsISubSceneComponent.h>

#include <fsAudio/fsIAudioManager.h>

#if defined fs3d
	#include <fs3d/fsC3dModelManager.h>
	#include <fs3d/fsC3dAnimationManager.h>
#endif

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

#include <fsRenderer/src/fsCBrushManager.h>
#include <fsRenderer/src/particles/fsCParticleDataManager.h>
#include <fsRenderer/src/animatingSprite/fsCAnimationDataManager.h>

#include <gfHogCore/src/gfCHogUserSavedData.h>
#include <gfHogCore/gfIHogLevel.h>

#include "../src/components/gui/fsIGuiComponent.h"
#include "fsCLocalisedStrings.h"
#include "fsCProfileManager.h"
#include "fsCSoftwareCursor.h"
#include "fsIInputManager.h"

const fsCUniqueId fsILevelBasedAppCoreMain::mLevelInitialisedMsg("levelInitialised");
const fsCUniqueId fsILevelBasedAppCoreMain::mLevelEntitiesCreatedMsg("levelEntitiesCreated");
const fsCUniqueId fsILevelBasedAppCoreMain::mLevelPostResetMsg("postResetLevel");
const fsStr fsILevelBasedAppCoreMain::mScenesFolder("scenes/");		// can't use fsIPathAdjuster as not sure when it's set
const fsStr fsILevelBasedAppCoreMain::mChaptersFolder("chapters");


fsStr fsILevelBasedAppCoreMain::chapterFolderGet()
{
	const auto chapter = fsCProfileManager::instanceGet()->chapterGet();
	const fsStr sep = fsIResourceNamePathAdjuster::mPathSeparator;
	return chapter.emptyGet() ? "" :
           mChaptersFolder + sep + chapter + sep + "assets" + sep;
}

void fsILevelBasedAppCoreMain::chaptersLocate()
{
	auto chapters = settingsGet()->strGet(mChaptersFolder);
	while (!chapters.emptyGet())
	{
		auto chap = chapters.chomp("-");
		mChapters.push_back(chap);
	}
}

void fsILevelBasedAppCoreMain::chapterClear()
{
	mCurrentChapter = "";
	fsCResourceName::chapterAdapterClear();
	fsIGuiComponent::flush();
}

void fsILevelBasedAppCoreMain::chapterEnable()
{
	chapterClear();
	const fsStr chapterFolder = fsCProfileManager::instanceGet()->chapterGet();
	if (!chapterFolder.emptyGet())
	{
		mCurrentChapter = chapterFolderGet();
		chapterLoaderEnable();
	}
}

void fsILevelBasedAppCoreMain::chapterLoaderEnable()
{
	fsIGuiComponent::flush();
	fsCResourceName::chapterAdapterAdd(std::function<void(fsStr&, fsCResourceName::eResourceLocation)>(
	[&](fsStr& pPath, fsCResourceName::eResourceLocation pLocation)
		{
			auto currentChapter = chapterFolderGet();
			{
				if (fsStr::npos == pPath.find(currentChapter.utf8Get()))
				{
					const auto chapterFile = currentChapter + pPath;
					if (fsIFile::fileExistsGet(fsCResourceName(chapterFile, fsCResourceName::eRES_LOCATION_ASSETS)))
					{
						pPath = chapterFile;
					}
				}
			}
		}));
}

std::vector<fsStr>
fsILevelBasedAppCoreMain::chaptersGet() const
{
	return mChapters;
}

fsStr fsILevelBasedAppCoreMain::scenesFolderGet()
{
	return chapterFolderGet() + mScenesFolder;
}

fsS32 fsILevelBasedAppCoreMain::levelCountGet() const
{
	return mRunningOrder->levelCountGet();
}

fsS32 fsILevelBasedAppCoreMain::currLevelPosGet() const
{
	return mRunningOrder->currLevelPosGet();
}

fsBool fsILevelBasedAppCoreMain::collectorsEditionContent(const fsStr& pLevelName)
{
	return fsStr::npos != pLevelName.find("collectors/");
}

void fsILevelBasedAppCoreMain::currentSubSceneBackgroundVisiblityToggle(fsBool pRender)
{
	fsISubSceneComponent* subScene = nullptr;
	for (auto subSceneComp = mSubScenes.rbegin(); subSceneComp != mSubScenes.rend(); ++subSceneComp)
	{
		if ((*subSceneComp)->parentGet()->visibleGet())
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			subScene = *subSceneComp;
			subScene->parentGet()->skipMeSet(!pRender);
			break;
		}
	}

	if (mSubScenes.front() != subScene)
	{
		mSubScenes.front()->parentGet()->visibleSet(pRender);
	}
}

void fsILevelBasedAppCoreMain::subScenesStore()
{
	fsS32 prevSubInd = -1;
	sceneRootGet()->forAllChildren(
		[this, &prevSubInd](fsCEntity* const ent) -> void
		{
			if (auto* const subSceneComp = ent->firstComponentOfFamilyType<fsISubSceneComponent>())
			{
				fsAssert(prevSubInd < subSceneComp->indexGet(),
				         "Code elsewhere assumes subscenes will be in order in this vector.\n");
				mSubScenes.push_back(subSceneComp);
				prevSubInd = subSceneComp->indexGet();
			}
		});
}

fsISubSceneComponent* fsILevelBasedAppCoreMain::currentSubSceneGet() const
{
	for (auto subSceneComp = mSubScenes.rbegin(); subSceneComp != mSubScenes.rend(); ++subSceneComp)
	{
		if ((*subSceneComp)->parentGet()->visibleGet())
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			return (*subSceneComp);
		}
	}

	fsAssert(false, "Expected to find an active subscene.\n");
	return nullptr;
}

fsCVariableTable* fsILevelBasedAppCoreMain::levelSettingsGet() const
{
	return mLevelSettings.get();
}

void fsILevelBasedAppCoreMain::levelSettingsLoad()
{
	mLevelSettings = std::make_unique<fsCVariableTable>();

	if (mRunningOrder->guiModeGet())
	{
		// mCurrentLevelName is the full config path (scenes/<name>/<name>.txt);
		// the resolved config is keyed by the bare scene name.
		fsStr sceneName = mCurrentLevelName;
		sceneName.eraseToLast(fsIResourceNamePathAdjuster::mPathSeparator);
		sceneName.eraseFromLast(".");
		if (const VarTableMap* const config = mRunningOrder->resolvedSceneConfigGet(sceneName))
		{
			for (const std::pair<const fsStr, fsStr>& entry : *config)
			{
				mLevelSettings->strSet(entry.first, entry.second);
			}
			return;
		}
		// Not a resolved running-order scene (e.g. the levelList map screen or
		// collectors bonus content) - fall through to the on-disk config.
	}

	mLevelSettings->load(fsCResourceName(mCurrentLevelName, fsCResourceName::eRES_LOCATION_ASSETS));
}

void fsILevelBasedAppCoreMain::quitToMenuSet()
{
	fadeOut();
	nextLocationSet(fsCAppCoreMain::instanceGet()->settingsGet()->strGet("mainMenu"));
}

fsILevelBasedAppCoreMain* fsILevelBasedAppCoreMain::instanceGet()
{
	return static_cast<fsILevelBasedAppCoreMain*>(fsCAppCoreMain::instanceGet());
}

fsStr fsILevelBasedAppCoreMain::sceneFolderGet() const
{
	fsStr ret = mCurrentLevelName;
	ret.erase(ret.rfind(fsIResourceNamePathAdjuster::mPathSeparator) + 1);
	return ret;
}

fsStr fsILevelBasedAppCoreMain::currentLevelNameGet() const
{
	fsStr ret = mCurrentLevelName;
	ret.erase(0, ret.rfind(fsIResourceNamePathAdjuster::mPathSeparator) + 1);
	return ret;
}

fsBool fsILevelBasedAppCoreMain::nextLocationReady() const
{
	return mRunningOrder->nextLocationReady();
}

fsStr fsILevelBasedAppCoreMain::nextLocationGet() const
{
	return mRunningOrder->nextLocationGet(mCurrentLevelName);
}

fsStr fsILevelBasedAppCoreMain::nextLocationGet(const fsStr& pCurrentLocation) const
{
	return mRunningOrder->nextLocationGet(pCurrentLocation);
}

const std::vector<fsStr>& fsILevelBasedAppCoreMain::rawSequenceGet() const
{
	return mRunningOrder->rawSequenceGet();
}

const fsStr& fsILevelBasedAppCoreMain::firstLocationGet() const
{
	return mRunningOrder->firstLocationGet();
}

void fsILevelBasedAppCoreMain::levelCompleteSet()
{
	mRunningOrder->levelCompleteSet();
}

void fsILevelBasedAppCoreMain::newGameStart()
{
	fsLogMsg("DEBUG newGameStart called");
	chapterEnable();
	runningOrderCreate();
	mRunningOrder->newGameStart();
	fadeOut();
	fsLogMsg("DEBUG newGameStart done, nextLocationReady=%d", nextLocationReady());
}

void fsILevelBasedAppCoreMain::gameContinue()
{
	fsLogMsg("DEBUG gameContinue called");
	chapterEnable();
	runningOrderCreate();
	mRunningOrder->gameContinue();
	fadeOut();
	fsLogMsg("DEBUG gameContinue done, nextLocationReady=%d", nextLocationReady());
}

void fsILevelBasedAppCoreMain::gameSingleLevel()
{
	mRunningOrder->singleLevel();
}

void fsILevelBasedAppCoreMain::nextLocationSet(const fsStr& pNextLevelName)
{
	mRunningOrder->nextLocationSet(pNextLevelName);
}

void fsILevelBasedAppCoreMain::cachesFlush()
{
	hardwareGet()->engineCacheFlush();
	particleDataManagerGet()->flush();
	animationManagerGet()->flush();
	fsCBrushManager::instanceGet()->flush();
	fsIGuiComponent::flush();
	fsIAudioManager::instanceGet()->effectsCacheFlush();

	fsIInputManager::instanceGet()->messageDispatch(fsCSoftwareCursor::mMovedOffHotComponentMsg,
						fsIInputManager::mNullParam);

#if defined fs3d
	// fsC3dAnimationManager::instanceGet()->flush();
	// fsC3dModelManager::instanceGet()->flush();
#endif
}

void fsILevelBasedAppCoreMain::nextLocationInitialise()
{
	mCurrentLevelName = mRunningOrder->nextLocationGet();

	fsStr msg = "Next level: " + mCurrentLevelName;
	fsLogMsg("%s", msg.utf8Get());

	mSubScenes.clear();

	// fsCResourceName::chapterAdapterClear();

	cachesFlush();

	hardwareGet()->freeMemoryReset();
	
	if (fsStr::npos != mCurrentLevelName.find(mScenesFolder) || collectorsEditionContent(mCurrentLevelName))
	{
		levelSettingsLoad();
	}

	nextLocationInitialiseDo(mCurrentLevelName);

	fsCAppMessageDispatcher::instanceGet()->messageDispatch(mLevelInitialisedMsg,
	                                                        fsIMessageDispatcher::sStrMessageParam(currentLevelNameGet()));

	mRunningOrder->nextLocationClear();

	fadeIn();
}

void fsILevelBasedAppCoreMain::postInitialiseDo()
{
	fsCAppCoreMain::postInitialiseDo();
	runningOrderCreate();
}

fsILevelBasedAppCoreMain::fsILevelBasedAppCoreMain():
	fsCAppCoreMain(),
	mRunningOrder(nullptr),
	mCurrentChapter("")
{
}

fsILevelBasedAppCoreMain::~fsILevelBasedAppCoreMain()
{
	delete mRunningOrder;
}