Cppcheck report - Fission: gameModules/gfMinigameCore/components/wordGames/wordSearch/gfCWordSearchMinigameGenerateComponent.cpp

#include "gfCWordSearchMinigameGenerateComponent.h"

#include <algorithm>

#include <fsCore/fsIFile.h>
#include <fsCore/src/fsNRnd.h>
#include <fsCore/src/fsCResourceName.h>

const fsCUniqueId gfCWordSearchMinigameGenerateComponent::mTypeId("fsCWordSearchMinigameGenerateComponent");
const fsStr gfCWordSearchMinigameGenerateComponent::mPlaceHolderTile("-");


void gfCWordSearchMinigameGenerateComponent::fileSave()
{
	fsStr saveStr;
	for (fsS32 row = 0; row < mDimensions.y; ++row)
	{
		fsStr rowStr;
		for (fsS32 column = 0; column < mDimensions.x; ++column)
		{
			rowStr += mTiles[row * mDimensions.x + column] + ",";
		}
		rowStr += '\n';
		saveStr += rowStr;
	}

	fsIFile::strWriteToFile(fsCResourceName(fsStr("test.csv"), fsCResourceName::eRES_LOCATION_USER_SETTINGS), saveStr);
}

fsStr gfCWordSearchMinigameGenerateComponent::randomLetterGet() const
{
	fsStr letter;
	const fsS32 asciiCodeLowerCaseA(0x61);
	letter = static_cast<fsChar>(asciiCodeLowerCaseA + fsNRnd::uInt32GetWithLimit(26));
	return letter;
}

void gfCWordSearchMinigameGenerateComponent::emptyTilesReplaceWithRandomLetter()
{
	for (fsS32 row = 0; row < mDimensions.y; ++row)
	{
		for (fsS32 column = 0; column < mDimensions.x; ++column)
		{
			if (mTiles[row * mDimensions.x + column] == mPlaceHolderTile)
			{
				mTiles[row * mDimensions.x + column] = randomLetterGet();
			}
		}
	}
}

std::vector<fsS32> gfCWordSearchMinigameGenerateComponent::randommIndicesGet(fsS32 pMaxIndex) const
{
	std::vector<fsS32> indices;
	for (fsS32 index = 0; index < pMaxIndex; ++index)
	{
		indices.push_back(index);
	}
	std::shuffle(std::begin(indices), std::end(indices), fsNRnd::randomDeviceGet());
	return indices;
}

fsBool gfCWordSearchMinigameGenerateComponent::wordAddHorizontal(const fsStr& pWord)
{
	for (fsS32 row : randommIndicesGet(mDimensions.y))<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		gfSRow rowCheck(this, mDimensions.x, row, pWord, 0 == fsNRnd::uInt32GetWithLimit(3));
		fsS32 column = rowCheck.startIndexFind();
		if (-1 != column)
		{
			rowCheck.copyToGrid(column, row);
			return true;
		}
	}
	return false;
}

fsBool gfCWordSearchMinigameGenerateComponent::wordAddVertical(const fsStr& pWord)
{
	for (fsS32 column : randommIndicesGet(mDimensions.x))<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		gfSColumn columnCheck(this, mDimensions.y, column, pWord, 0 == fsNRnd::uInt32GetWithLimit(3));
		fsS32 row = columnCheck.startIndexFind();
		if (-1 != row)
		{
			columnCheck.copyToGrid(column, row);
			return true;
		}
	}
	return false;
}

fsBool gfCWordSearchMinigameGenerateComponent::wordAddDiagonalTLBR(const fsStr& pWord)
{
	for (fsS32 row : randommIndicesGet(mDimensions.y))<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		gfSDiagonalTLBR diagonalCheck(this, mDimensions.x, row, pWord, 0 == fsNRnd::uInt32GetWithLimit(3));
		fsS32 column = diagonalCheck.startIndexFind();
		if (-1 != column)
		{
			diagonalCheck.copyToGrid(column, row);
			return true;
		}
	}
	return false;
}

fsBool gfCWordSearchMinigameGenerateComponent::wordAddDiagonalBLTR(const fsStr& pWord)
{
	for (fsS32 row : randommIndicesGet(mDimensions.y))<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		gfSDiagonalBLTR diagonalCheck(this, mDimensions.x, row, pWord, 0 == fsNRnd::uInt32GetWithLimit(3));
		fsS32 column = diagonalCheck.startIndexFind();
		if (-1 != column)
		{
			diagonalCheck.copyToGrid(column, row);
			return true;
		}
	}
	return false;
}

fsBool gfCWordSearchMinigameGenerateComponent::wordsAdd(std::vector<fsStr>& pWords)<--- Parameter 'pWords' can be declared as reference to const
{
	typedef fsBool (gfCWordSearchMinigameGenerateComponent::*fsTWordInsertFnc)(const fsStr& pWord);
	std::vector<fsTWordInsertFnc> wordInsertFncs;

	wordInsertFncs.push_back(&gfCWordSearchMinigameGenerateComponent::wordAddHorizontal);
	wordInsertFncs.push_back(&gfCWordSearchMinigameGenerateComponent::wordAddDiagonalTLBR);
	wordInsertFncs.push_back(&gfCWordSearchMinigameGenerateComponent::wordAddDiagonalBLTR);
	wordInsertFncs.push_back(&gfCWordSearchMinigameGenerateComponent::wordAddVertical);

	for (fsStr word : pWords)
	{
		std::shuffle(std::begin(wordInsertFncs), std::end(wordInsertFncs), std::default_random_engine{});

		for (fsTWordInsertFnc wordInsertFnc : wordInsertFncs)
		{
			if (((this)->*(wordInsertFnc))(word))
			{
				break;
			}
		}
	}
	return true;
}

void gfCWordSearchMinigameGenerateComponent::gridCreate()
{
	for (fsS32 row = 0; row < mDimensions.y; ++row)
	{
		for (fsS32 column = 0; column < mDimensions.x; ++column)
		{
			mTiles.push_back(mPlaceHolderTile);
		}
	}
}

void gfCWordSearchMinigameGenerateComponent::wordListSortLongestFirst(std::vector<fsStr>& pWords)
{
	// Word-search entries are treated as English/ASCII words for placement and tile counts.
	std::sort(pWords.begin(), pWords.end(),
	          [](fsStr wordA, fsStr wordB) { return wordB.lengthGet() < wordA.lengthGet(); });
}

fsBool gfCWordSearchMinigameGenerateComponent::generate(fsStr const& pTileSet, fsStr const& pHilight,
                                                        fsPoint const& pDimensions, fsPoint const& pOffset,
                                                        std::vector<fsStr> pWords)
{
	mTileSet = pTileSet;
	mHilight = pHilight;
	mDimensions = pDimensions;
	mWords = pWords;
	mOffest = pOffset;

	gridCreate();
	wordListSortLongestFirst(pWords);
	wordsAdd(mWords);
	emptyTilesReplaceWithRandomLetter();
	fileSave();
	return true;
}

fsIComponent* gfCWordSearchMinigameGenerateComponent::create(fsCEntity* pParent)
{
	return new gfCWordSearchMinigameGenerateComponent(pParent);
}

gfCWordSearchMinigameGenerateComponent::gfCWordSearchMinigameGenerateComponent(fsCEntity* const pParent) :
	fsIComponent(pParent),
	mDimensions{0, 0}
{
}

gfCWordSearchMinigameGenerateComponent::~gfCWordSearchMinigameGenerateComponent()
{
}

void gfCWordSearchMinigameGenerateComponent::gfSGridDirection::copyToGrid(fsS32 pColumn, fsS32 pRow) const
{
	// Grid placement is byte-per-letter by design for the authored word lists used here.
	for (fsS32 currChar = 0; currChar < mWord.lengthGet(); ++currChar)
	{
		doCopyToGrid(pColumn, pRow, currChar);
	}
}

fsS32 gfCWordSearchMinigameGenerateComponent::gfSGridDirection::startIndexFind()
{
	fsS32 suitableTileCount = 0;
	for (fsS32 index = dimensionLimitGet() - 1; index >= 0; --index)
	{
		if (legalEntry(index))
		{
			if (++suitableTileCount == wordLengthGet())
			{
				return index;
			}
		}
		else
		{
			suitableTileCount = -1;
		}
	}
	return -1;
}


fsS32 gfCWordSearchMinigameGenerateComponent::gfSGridDirection::wordIndexGet(fsS32 pIndex) const
{
	if (mReverse)
	{
		return mWord.lengthGet() - 1 - pIndex;
	}
	return pIndex;
}

fsBool gfCWordSearchMinigameGenerateComponent::gfSColumn::legalEntry(fsS32 pIndex) const
{
	return mParent->mTiles[pIndex * mParent->mDimensions.x + mDimensionIndex] == mParent->mPlaceHolderTile;
}

void gfCWordSearchMinigameGenerateComponent::gfSColumn::doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const
{
	mParent->mTiles[(pRow + pCurrChar) * mParent->mDimensions.x + pColumn] = mWord[wordIndexGet(pCurrChar)];
}

fsBool gfCWordSearchMinigameGenerateComponent::gfSRow::legalEntry(fsS32 pIndex) const
{
	return mParent->mTiles[mDimensionIndex * mParent->mDimensions.x + pIndex] == mParent->mPlaceHolderTile;
}

void gfCWordSearchMinigameGenerateComponent::gfSRow::doCopyToGrid(fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const
{
	mParent->mTiles[pRow * mParent->mDimensions.x + pColumn + pCurrChar] = mWord[wordIndexGet(pCurrChar)];
}

fsBool gfCWordSearchMinigameGenerateComponent::gfSDiagonalBLTR::legalColRowEntry(fsS32 pColumn, fsS32 pRow) const
{
	return mParent->mTiles[pRow * mParent->mDimensions.x + pColumn] == mParent->mPlaceHolderTile;
}

void gfCWordSearchMinigameGenerateComponent::gfSDiagonalBLTR::doCopyToGrid(
	fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const
{
	mParent->mTiles[(pRow + (mWord.lengthGet() - 1 - pCurrChar)) * mParent->mDimensions.x + pColumn + pCurrChar] = mWord
		[wordIndexGet(pCurrChar)];
}

fsS32 gfCWordSearchMinigameGenerateComponent::gfSDiagonalBLTR::startIndexFind()
{
	fsS32 suitableTileCount = 0;
	for (fsS32 column = dimensionLimitGet() - 1, row = mDimensionIndex; column >= 0 && row < mDimensionLimit; --column,
	     ++row)
	{
		if (legalColRowEntry(column, row))
		{
			if (++suitableTileCount == wordLengthGet())
			{
				return column;
			}
		}
		else
		{
			suitableTileCount = 0;
			row = mDimensionIndex - 1;
		}
	}
	return -1;
}

fsBool gfCWordSearchMinigameGenerateComponent::gfSDiagonalTLBR::legalColRowEntry(fsS32 pColumn, fsS32 pRow) const
{
	return mParent->mTiles[pRow * mParent->mDimensions.x + pColumn] == mParent->mPlaceHolderTile;
}

void gfCWordSearchMinigameGenerateComponent::gfSDiagonalTLBR::doCopyToGrid(
	fsS32 pColumn, fsS32 pRow, fsS32 pCurrChar) const
{
	mParent->mTiles[(pRow + pCurrChar) * mParent->mDimensions.x + pColumn + pCurrChar] = mWord[wordIndexGet(pCurrChar)];
}

fsS32 gfCWordSearchMinigameGenerateComponent::gfSDiagonalTLBR::startIndexFind()
{
	fsS32 suitableTileCount = 0;
	for (fsS32 column = dimensionLimitGet() - 1, row = mDimensionIndex + wordLengthGet() - 1; column >= 0 && row >= 0;
	     --column, --row)
	{
		if (legalColRowEntry(column, row))
		{
			if (++suitableTileCount == wordLengthGet())
			{
				return column;
			}
		}
		else
		{
			suitableTileCount = 0;
			row = mDimensionIndex + wordLengthGet();
		}
	}
	return -1;
}