Cppcheck report - Fission: gameModules/gfHogCore/components/levelSequencer/map/gfCLevelSequencerMapLevelComponent.cpp

#include "gfCLevelSequencerMapLevelComponent.h"

#include <fsCore/fsSColour.h>
#include <fsCore/fsIResourceNamePathAdjuster.h>
#include <fsCore/src/fsNMaths.h>

#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsRenderer/src/components/fsCTextSpriteComponent.h>
#include <fsRenderer/src/fsCBrushManager.h>
#include <fsRenderer/src/fsCMaterial.h>

#include <fsAppCore/src/fsCLocalisedStrings.h>
#include <fsAppCore/src/fsCEntityFactory.h>
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>
#include <fsAppCore/src/fsCProfileManager.h>

#include <gfComponents/components/subScene/gfCSubSceneViewComponent.h>

#include "../../../src/gfCHogUserSavedData.h"
#include "../../gui/gfCMapPopUpGui.h"
#include "../../gui/gfCEndMenuGui.h"

#include "gfCLevelSequencerMapLevelIconComponent.h"
#include "gfCLevelSequencerMapComponent.h"
#include "gfComponents/gfILevelLoaderComponent.h"
#include "src/fsCAppSettings.h"

const fsStr gfCLevelSequencerMapLevelComponent::mLevPrefix("lev-");


void gfCLevelSequencerMapLevelComponent::rollOverSet(fsBool pOver)
{
	gfCLevelSequencerMapComponent* const mapComp = fsCAppCoreMain::instanceGet()->sceneGet()->firstEntityWithComponentsOfFamilyType<
		gfCLevelSequencerMapComponent>()->componentGet<gfCLevelSequencerMapComponent>();
	mapComp->levelRollOverSet(pOver ? mLevelIconEntity : nullptr);
}

fsS32 gfCLevelSequencerMapLevelComponent::widthGet() const
{
	return mLevelIconEntity->childFind("levelIcon")->spriteComponentGet()->widthGet();
}

void gfCLevelSequencerMapLevelComponent::activeGlowUpdate(fsS32 pTime)
{
	if (fsCEntity* activeLevEnt = mLevelIconEntity->childFind("currLevEnt"))
	{
		fsISpriteComponent* const sprtComp = activeLevEnt->firstComponentOfFamilyType<fsISpriteComponent>();

		const fsF32 alpha = ((fsNMaths::sinF32(static_cast<fsF32>(pTime) / 100.0f) * 0.25f) + 0.75f);
		sprtComp->colourSet(fsSColour4B(255, 255, 255, alpha * 255));
	}
}

void gfCLevelSequencerMapLevelComponent::visibilitySet(fsBool pVisibility)
{
	mLevelIconEntity->visibleSet(pVisibility);
}

void gfCLevelSequencerMapLevelComponent::posSet(const fsPoint& pPos)
{
	if (gfCLevelSequencerMapLevelIconComponent* levIcon = mLevelIconEntity->componentGet<gfCLevelSequencerMapLevelIconComponent>())
	{
		levIcon->posSet(pPos);
	}
	else
	{
		mLevelIconEntity->posSet(pPos);
	}
}

void gfCLevelSequencerMapLevelComponent::levelIconAlphaSet(fsF32 pVal)
{
	fsISpriteComponent* const levEntSprt = mLevelIconEntity->childFind("levelIcon")->spriteComponentGet();
	levEntSprt->alphaBlendSet(fsCMaterial::eALPHA_ADD);
	levEntSprt->colourSet(fsSColour4B(255, 255, 255, pVal * 255));
	if (gfCLevelSequencerMapLevelIconComponent* levIcon = mLevelIconEntity->componentGet<
		gfCLevelSequencerMapLevelIconComponent>())
	{
		levIcon->deactivate();
	}
}

fsStr gfCLevelSequencerMapLevelComponent::levelNameGetDo() const
{
	auto levelName = mLevelName;
	levelName.erase(levelName.rfind("."));

	return levelName;
}

void gfCLevelSequencerMapLevelComponent::levelIconEntityCreate(fsCEntity* const pParent, const fsStr& pLayoutFile,
                                                               fsBool pCurrLev)
{
	mLevelIconEntity = fsIGuiComponent::guiCreateFromFile(
		fsCResourceName(pLayoutFile, fsCResourceName::eRES_LOCATION_ASSETS), pParent, false);

	mLevelIconEntity->nameSet(mLevPrefix + levelNameGet() + ".png");
	mLevelIconEntity->visibleSet(false);

	gfCLevelSequencerMapLevelIconComponent* levIcon = mLevelIconEntity->componentAdd<gfCLevelSequencerMapLevelIconComponent>();
	levIcon->componentsLink(
		dynamic_cast<fsCEntity*>(mLevelIconEntity->parentGet())->componentGet<gfCSubSceneViewComponent>(), this);

	infoSet(pCurrLev);
}

fsStr gfCLevelSequencerMapLevelComponent::iconFileNameGet(const fsStr& pLevelname, const fsStr& pFolder)
{
	// levelList level packs the thumbnails from the gui folder into it's own texture page to speed up loading, so we try to
	// locate the packed icons first and default to the originals if they don't exist
	// This all to handle the texture paging which is a bit of a hack as we have to handle localised textures here by hand
	// The default return gets localised
	const fsStr fileType = fsStr(".png");
	fsStr iconFilename = pFolder
                                   + gfILevelLoaderComponent::layersSubFolderGet(pFolder)
                                   + pLevelname;

#if defined fsDownCaseFilename
	iconFilename.downcase();
#endif
	auto localeCodeExtension = "_" + fsCAppCoreMain::instanceGet()->localeGet()->localeCodeGet() + fileType;
	localeCodeExtension.downcase();

	auto candidates = {
		iconFilename + localeCodeExtension,
		iconFilename + fileType
	};

	for (const auto& candidate : candidates)
	{
		if (fsCBrushManager::instanceGet()->textureExistsGet(
			fsCResourceName(candidate, fsCResourceName::eRES_LOCATION_ASSETS)))
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			return candidate;
		}
	}

	const fsStr mapHUDRoot = fsCAppCoreMain::instanceGet()->settingsGet()->
							strGetWithDefault("mapHUDRoot", "gui/mapHUD/");

	return  mapHUDRoot + "mapThumbs/" + pLevelname + fileType;
}


fsStr gfCLevelSequencerMapLevelComponent::newIconFileNameGet(const fsStr& pLevelname)
{
	const fsStr levelListName = "scenes/" + gfCLevelSequencerMapComponent::levelListNameGet() + "/";
	const fsStr fileType = fsStr(".jpg");
	fsStr iconFilename = levelListName 
								   + gfILevelLoaderComponent::layersSubFolderGet(levelListName)
								   + pLevelname;

#if defined fsDownCaseFilename
	iconFilename.downcase();
#endif
	auto localeCodeExtension = "_" + fsCAppCoreMain::instanceGet()->localeGet()->localeCodeGet() + fileType;
	localeCodeExtension.downcase();

	auto candidates = {
		iconFilename + localeCodeExtension,
		iconFilename + fileType
	};

	for (const auto& candidate : candidates)
	{
		if (fsCBrushManager::instanceGet()->textureExistsGet(
			fsCResourceName(candidate, fsCResourceName::eRES_LOCATION_ASSETS)))
		{<--- Consider using std::find_if algorithm instead of a raw loop.
			return candidate;
		}
	}

	return levelListName
			+ gfILevelLoaderComponent::layersSubFolderGet(levelListName)
			+ pLevelname + fileType;
}

fsStr gfCLevelSequencerMapLevelComponent::iconFileNameGet(const fsStr& pLevelname)
{
	// Hacky but we save out the thumbnails from the game so we use fsCResourceName which goes caseless
	auto caselessName = pLevelname;
#if defined fsDownCaseFilename
	caselessName.downcase();
#endif

    auto installedName = fsCAppCoreMain::instanceGet()->settingsGet()->strGetWithDefault("installedName", "My Game");
	if (installedName.find("Park Ranger 17") == 0
		|| installedName.find("Christmas Wonderland 16") == 0) {
		caselessName.downcase();
	}

	if (fsCAppCoreMain::instanceGet()->settingsGet()->strGet("mapIconRoot").emptyGet())
	{
		return iconFileNameGet(caselessName, fsILevelBasedAppCoreMain::instanceGet()->sceneFolderGet());
	}
	return newIconFileNameGet(caselessName);
}

void gfCLevelSequencerMapLevelComponent::infoSet(fsBool pCurrLev)
{
	if (fsISpriteComponent* sprt = mLevelIconEntity->childFind("levelIcon")->spriteComponentGet())
	{
		sprt->brushSet(
			fsCBrushManager::instanceGet()->get(fsCResourceName(iconFileNameGet(levelNameGet()), fsCResourceName::eRES_LOCATION_ASSETS),
			                                    false));

		if (pCurrLev && nullptr == mLevelIconEntity->childFind("currLevEnt"))
		{
			fsCEntity* currLevEnt = mLevelIconEntity->entityFactoryGet()->emptyEntityCreate("currLevEnt");
			sprt = currLevEnt->spriteComponentAdd();
			sprt->brushSet(fsCBrushManager::instanceGet()->get(fsCResourceName("gui/levelList/active.png",
			                                                                   fsCResourceName::eRES_LOCATION_ASSETS),
			                                                   false));

			mLevelIconEntity->childAdd(currLevEnt);
		}
	}

	levelNameSet();

	starRatingSet();

	bonusBonusSet();
}

void gfCLevelSequencerMapLevelComponent::levelNameSet()
{
	if (fsCEntity* const levNameEnt = mLevelIconEntity->childFind("levelNameStr"))
	{
		if (fsITextSpriteComponent* txt = levNameEnt->textComponentGet())
		{
			txt->textSet(fsCLocalisedStrings::localisedStringGet(levelNameGet()));
			txt->parentGet()->visibleSet(true);
		}
	}
}

void gfCLevelSequencerMapLevelComponent::bonusBonusSet()
{
	if (fsCEntity* const starEnt = mLevelIconEntity->childFind("ratingFrosty"))
	{
		fsS32 bonusBonusCount = 0;
		fsCMapPopUpGui::bonusBonusTotalGet(levelFilenameCompose(mFolder, mLevelName), bonusBonusCount);
		starEnt->visibleSet(bonusBonusCount != 0);
	}
}

void gfCLevelSequencerMapLevelComponent::starRatingSet()
{
	const fsStr levelRank = fsCMapPopUpGui::levelCompletionRankGet(
		levelFilenameCompose(mFolder, mLevelName));
	starInit("ratingStarBronze", mVisited);
	starInit("ratingStarSilver", false);
	starInit("ratingStarGold", false);

	if (mVisited)
	{
		if (levelRank == "silver" || levelRank == "gold")
		{
			starInit("ratingStarSilver", true);
			if (levelRank == "gold")
			{
				starInit("ratingStarGold", true);
			}
		}

		if (gfCHogUserSavedData::eDIFFICULTY::eEXTREME == fsCProfileManager::instanceGet()->userSavedDataGet()->
			difficultyGet())
		{
			starInit("ratingStarExtreme", true);
		}
	}
}

void gfCLevelSequencerMapLevelComponent::starInit(const fsStr& pName, fsBool pVisible)
{
	if (fsCEntity* const starEnt = mLevelIconEntity->childFind(pName))
	{
		starEnt->visibleSet(pVisible);
	}
}

gfCLevelSequencerMapLevelComponent::gfCLevelSequencerMapLevelComponent(const fsStr& pLevelPath,
                                                                       const fsStr& pLevelFolder) :
	gfCLevelSequencerLevelComponent(pLevelPath, pLevelFolder),
	mLevelIconEntity(nullptr)
{
	mVisited = !fsCProfileManager::instanceGet()->userSavedDataGet()->strGet(
			gfCHogUserSavedData::mLevelDataPrefix + levelFilenameGet()).emptyGet()
		|| fsCProfileManager::instanceGet()->userSavedDataGet()->strGet(gfCHogUserSavedData::mMapLocation).find(
			fsCEndMenuGui::mRevealAllStr) != fsStr::npos;
}

gfCLevelSequencerMapLevelComponent::~gfCLevelSequencerMapLevelComponent()
{
}