Fix build errors.

Flone-dnb · Flone-dnb · commit ca0d9e1b2ba9 · 2020-04-25T22:06:16.000+05:00
diff --git a/Source/FWorldGenerator/Private/FWGChunk.cpp b/Source/FWorldGenerator/Private/FWGChunk.cpp
@@ -28,26 +28,26 @@ void AFWGChunk::BeginPlay()
 	//pTriggerBox->OnComponentEndOverlap.AddDynamic(this, &AFWGChunk::OnEndOverlap);
 }
 
-void AFWGChunk::setInit(long long iX, long long iY, int32 iSectionIndex, bool bAroundCenter)
+void AFWGChunk::setInit(long long ix, long long iy, int32 iSectionindex, bool bAroundcenter)
 {
 	pMeshSection = nullptr;
 
-	this->iX = iX;
-	this->iY = iY;
+	this->iX = ix;
+	this->iY = iy;
 
-	this->iSectionIndex = iSectionIndex;
+	this->iSectionIndex = iSectionindex;
 
-	this->bAroundCenter = bAroundCenter;
+	this->bAroundCenter = bAroundcenter;
 }
 
-void AFWGChunk::setUpdate(long long iX, long long iY, bool bAroundCenter)
+void AFWGChunk::setUpdate(long long ix, long long iy, bool bAroundcenter)
 {
 	clearChunk();
 
-	this->iX = iX;
-	this->iY = iY;
+	this->iX = ix;
+	this->iY = iy;
 
-	this->bAroundCenter = bAroundCenter;
+	this->bAroundCenter = bAroundcenter;
 }
 
 void AFWGChunk::setChunkSize(int32 iXCount, int32 iYCount)
@@ -60,9 +60,9 @@ void AFWGChunk::setChunkSize(int32 iXCount, int32 iYCount)
 	}
 }
 
-void AFWGChunk::setChunkMap(FWGenChunkMap* pChunkMap)
+void AFWGChunk::setChunkMap(FWGenChunkMap* pChunkmap)
 {
-	this->pChunkMap = pChunkMap;
+	this->pChunkMap = pChunkmap;
 }
 
 void AFWGChunk::setOverlapToActors(std::vector<FString> vClasses)
@@ -83,9 +83,9 @@ void AFWGChunk::clearChunk()
 	vChunkCells.clear();
 }
 
-void AFWGChunk::setMeshSection(FProcMeshSection* pMeshSection)
+void AFWGChunk::setMeshSection(FProcMeshSection* pMeshsection)
 {
-	this->pMeshSection  = pMeshSection;
+	this->pMeshSection  = pMeshsection;
 }
 
 AFWGChunk::~AFWGChunk()
diff --git a/Source/FWorldGenerator/Private/FWGChunk.h b/Source/FWorldGenerator/Private/FWGChunk.h
@@ -28,12 +28,12 @@ class AFWGChunk : public AActor
 
 	AFWGChunk();
 
-	void setInit             (long long iX, long long iY, int32 iSectionIndex, bool bAroundCenter);
-	void setUpdate           (long long iX, long long iY, bool bAroundCenter);
+	void setInit             (long long ix, long long iy, int32 iSectionindex, bool bAroundcenter);
+	void setUpdate           (long long ix, long long iy, bool bAroundcenter);
 	void setChunkSize        (int32 iXCount, int32 iYCount);
-	void setChunkMap         (FWGenChunkMap* pChunkMap);
+	void setChunkMap         (FWGenChunkMap* pChunkmap);
 	void setOverlapToActors  (std::vector<FString> vClasses);
-	void setMeshSection      (FProcMeshSection* pMeshSection);
+	void setMeshSection      (FProcMeshSection* pMeshsection);
 
 	~AFWGChunk();
 
diff --git a/Source/FWorldGenerator/Private/FWGen.cpp b/Source/FWorldGenerator/Private/FWGen.cpp
@@ -1107,23 +1107,23 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)
 		std::vector<FWGCallback> vSecondLayer;
 		std::vector<FWGCallback> vThirdLayer;
 
-		for (size_t i = 0; i < vObjectsToSpawn.size(); i++)
+		for (size_t k = 0; k < vObjectsToSpawn.size(); k++)
 		{
-			if (areEqual(vObjectsToSpawn[i].fLayer, -0.5f, 0.1f))
+			if (areEqual(vObjectsToSpawn[k].fLayer, -0.5f, 0.1f))
 			{
-				vWaterLayer.push_back(vObjectsToSpawn[i]);
+				vWaterLayer.push_back(vObjectsToSpawn[k]);
 			}
-			else if (areEqual(vObjectsToSpawn[i].fLayer, 0.0f, 0.1f))
+			else if (areEqual(vObjectsToSpawn[k].fLayer, 0.0f, 0.1f))
 			{
-				vFirstLayer.push_back(vObjectsToSpawn[i]);
+				vFirstLayer.push_back(vObjectsToSpawn[k]);
 			}
-			else if (areEqual(vObjectsToSpawn[i].fLayer, 0.5f, 0.1f))
+			else if (areEqual(vObjectsToSpawn[k].fLayer, 0.5f, 0.1f))
 			{
-				vSecondLayer.push_back(vObjectsToSpawn[i]);
+				vSecondLayer.push_back(vObjectsToSpawn[k]);
 			}
 			else
 			{
-				vThirdLayer.push_back(vObjectsToSpawn[i]);
+				vThirdLayer.push_back(vObjectsToSpawn[k]);
 			}
 		}
 
@@ -1167,10 +1167,10 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)
 				vXOffset.push_back(TraceStart.X - fXCellSize / 2);
 				
 
-				for (size_t i = 0; i < vXOffset.size(); i++)
+				for (size_t k = 0; k < vXOffset.size(); k++)
 				{
-					TraceStart.X = vXOffset[i];
-					TraceEnd.X   = vXOffset[i];
+					TraceStart.X = vXOffset[k];
+					TraceEnd.X   = vXOffset[k];
 
 					if (GetWorld()->LineTraceSingleByChannel(OutHit, TraceStart, TraceEnd, ECC_Visibility, CollisionParams))
 					{
@@ -1191,10 +1191,10 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)
 					vYOffset.push_back(TraceStart.Y + fYCellSize / 2);
 					vYOffset.push_back(TraceStart.Y - fYCellSize / 2);
 
-					for (size_t i = 0; i < vYOffset.size(); i++)
+					for (size_t k = 0; k < vYOffset.size(); k++)
 					{
-						TraceStart.Y = vYOffset[i];
-						TraceEnd.Y   = vYOffset[i];
+						TraceStart.Y = vYOffset[k];
+						TraceEnd.Y   = vYOffset[k];
 
 						if (GetWorld()->LineTraceSingleByChannel(OutHit, TraceStart, TraceEnd, ECC_Visibility, CollisionParams))
 						{
@@ -1685,9 +1685,9 @@ bool AFWGen::SetGenerationMaxZFromActorZ(float NewGenerationMaxZFromActorZ)
 	}
 }
 
-void AFWGen::SetInvertWorld(bool InvertWorld)
+void AFWGen::SetInvertWorld(bool Invertworld)
 {
-	this->InvertWorld = InvertWorld;
+	this->InvertWorld = Invertworld;
 }
 
 bool AFWGen::SetWorldSize(int32 NewWorldSize)
@@ -1806,9 +1806,9 @@ bool AFWGen::SetThirdMaterialOnOtherProbability(float ThirdOnFirst, float ThirdO
 	}
 }
 
-void AFWGen::SetCreateWater(bool CreateWater)
+void AFWGen::SetCreateWater(bool Createwater)
 {
-	this->CreateWater = CreateWater;
+	this->CreateWater = Createwater;
 }
 
 bool AFWGen::SetZWaterLevelInWorld(float NewZWaterLevelInWorld)
@@ -2408,29 +2408,29 @@ bool AFWGen::SetMinSlopeHeightMultiplier(float NewMinSlopeHeightMultiplier)
 	}
 }
 
-bool AFWGen::SetDivideChunkXCount(int32 DivideChunkXCount)
+bool AFWGen::SetDivideChunkXCount(int32 DivideChunkXcount)
 {
-	if (DivideChunkXCount < 1)
+	if (DivideChunkXcount < 1)
 	{
 		return true;
 	}
 	else
 	{
-		this->DivideChunkXCount = DivideChunkXCount;
+		this->DivideChunkXCount = DivideChunkXcount;
 
 		return false;
 	}
 }
 
-bool AFWGen::SetDivideChunkYCount(int32 DivideChunkYCount)
+bool AFWGen::SetDivideChunkYCount(int32 DivideChunkYcount)
 {
-	if (DivideChunkYCount < 1)
+	if (DivideChunkYcount < 1)
 	{
 		return true;
 	}
 	else
 	{
-		this->DivideChunkYCount = DivideChunkYCount;
+		this->DivideChunkYCount = DivideChunkYcount;
 
 		return false;
 	}

Original file line number	Diff line number	Diff line change
`@@ -28,26 +28,26 @@ void AFWGChunk::BeginPlay()`
`28`	`28`	`//pTriggerBox->OnComponentEndOverlap.AddDynamic(this, &AFWGChunk::OnEndOverlap);`
`29`	`29`	`}`
`30`	`30`
`31`		`-void AFWGChunk::setInit(long long iX, long long iY, int32 iSectionIndex, bool bAroundCenter)`
	`31`	`+void AFWGChunk::setInit(long long ix, long long iy, int32 iSectionindex, bool bAroundcenter)`
`32`	`32`	`{`
`33`	`33`	`pMeshSection = nullptr;`
`34`	`34`
`35`		`- this->iX = iX;`
`36`		`- this->iY = iY;`
	`35`	`+ this->iX = ix;`
	`36`	`+ this->iY = iy;`
`37`	`37`
`38`		`- this->iSectionIndex = iSectionIndex;`
	`38`	`+ this->iSectionIndex = iSectionindex;`
`39`	`39`
`40`		`- this->bAroundCenter = bAroundCenter;`
	`40`	`+ this->bAroundCenter = bAroundcenter;`
`41`	`41`	`}`
`42`	`42`
`43`		`-void AFWGChunk::setUpdate(long long iX, long long iY, bool bAroundCenter)`
	`43`	`+void AFWGChunk::setUpdate(long long ix, long long iy, bool bAroundcenter)`
`44`	`44`	`{`
`45`	`45`	`clearChunk();`
`46`	`46`
`47`		`- this->iX = iX;`
`48`		`- this->iY = iY;`
	`47`	`+ this->iX = ix;`
	`48`	`+ this->iY = iy;`
`49`	`49`
`50`		`- this->bAroundCenter = bAroundCenter;`
	`50`	`+ this->bAroundCenter = bAroundcenter;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`void AFWGChunk::setChunkSize(int32 iXCount, int32 iYCount)`
`@@ -60,9 +60,9 @@ void AFWGChunk::setChunkSize(int32 iXCount, int32 iYCount)`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`-void AFWGChunk::setChunkMap(FWGenChunkMap* pChunkMap)`
	`63`	`+void AFWGChunk::setChunkMap(FWGenChunkMap* pChunkmap)`
`64`	`64`	`{`
`65`		`- this->pChunkMap = pChunkMap;`
	`65`	`+ this->pChunkMap = pChunkmap;`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`void AFWGChunk::setOverlapToActors(std::vector<FString> vClasses)`
`@@ -83,9 +83,9 @@ void AFWGChunk::clearChunk()`
`83`	`83`	`vChunkCells.clear();`
`84`	`84`	`}`
`85`	`85`
`86`		`-void AFWGChunk::setMeshSection(FProcMeshSection* pMeshSection)`
	`86`	`+void AFWGChunk::setMeshSection(FProcMeshSection* pMeshsection)`
`87`	`87`	`{`
`88`		`- this->pMeshSection = pMeshSection;`
	`88`	`+ this->pMeshSection = pMeshsection;`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`AFWGChunk::~AFWGChunk()`
Original file line number	Diff line number	Diff line change
`@@ -1107,23 +1107,23 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)`
`1107`	`1107`	`std::vector<FWGCallback> vSecondLayer;`
`1108`	`1108`	`std::vector<FWGCallback> vThirdLayer;`
`1109`	`1109`
`1110`		`- for (size_t i = 0; i < vObjectsToSpawn.size(); i++)`
	`1110`	`+ for (size_t k = 0; k < vObjectsToSpawn.size(); k++)`
`1111`	`1111`	`{`
`1112`		`- if (areEqual(vObjectsToSpawn[i].fLayer, -0.5f, 0.1f))`
	`1112`	`+ if (areEqual(vObjectsToSpawn[k].fLayer, -0.5f, 0.1f))`
`1113`	`1113`	`{`
`1114`		`- vWaterLayer.push_back(vObjectsToSpawn[i]);`
	`1114`	`+ vWaterLayer.push_back(vObjectsToSpawn[k]);`
`1115`	`1115`	`}`
`1116`		`- else if (areEqual(vObjectsToSpawn[i].fLayer, 0.0f, 0.1f))`
	`1116`	`+ else if (areEqual(vObjectsToSpawn[k].fLayer, 0.0f, 0.1f))`
`1117`	`1117`	`{`
`1118`		`- vFirstLayer.push_back(vObjectsToSpawn[i]);`
	`1118`	`+ vFirstLayer.push_back(vObjectsToSpawn[k]);`
`1119`	`1119`	`}`
`1120`		`- else if (areEqual(vObjectsToSpawn[i].fLayer, 0.5f, 0.1f))`
	`1120`	`+ else if (areEqual(vObjectsToSpawn[k].fLayer, 0.5f, 0.1f))`
`1121`	`1121`	`{`
`1122`		`- vSecondLayer.push_back(vObjectsToSpawn[i]);`
	`1122`	`+ vSecondLayer.push_back(vObjectsToSpawn[k]);`
`1123`	`1123`	`}`
`1124`	`1124`	`else`
`1125`	`1125`	`{`
`1126`		`- vThirdLayer.push_back(vObjectsToSpawn[i]);`
	`1126`	`+ vThirdLayer.push_back(vObjectsToSpawn[k]);`
`1127`	`1127`	`}`
`1128`	`1128`	`}`
`1129`	`1129`
`@@ -1167,10 +1167,10 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)`
`1167`	`1167`	`vXOffset.push_back(TraceStart.X - fXCellSize / 2);`
`1168`	`1168`
`1169`	`1169`
`1170`		`- for (size_t i = 0; i < vXOffset.size(); i++)`
	`1170`	`+ for (size_t k = 0; k < vXOffset.size(); k++)`
`1171`	`1171`	`{`
`1172`		`- TraceStart.X = vXOffset[i];`
`1173`		`- TraceEnd.X = vXOffset[i];`
	`1172`	`+ TraceStart.X = vXOffset[k];`
	`1173`	`+ TraceEnd.X = vXOffset[k];`
`1174`	`1174`
`1175`	`1175`	`if (GetWorld()->LineTraceSingleByChannel(OutHit, TraceStart, TraceEnd, ECC_Visibility, CollisionParams))`
`1176`	`1176`	`{`
`@@ -1191,10 +1191,10 @@ void AFWGen::spawnObjects(AFWGChunk* pOnlyForThisChunk)`
`1191`	`1191`	`vYOffset.push_back(TraceStart.Y + fYCellSize / 2);`
`1192`	`1192`	`vYOffset.push_back(TraceStart.Y - fYCellSize / 2);`
`1193`	`1193`
`1194`		`- for (size_t i = 0; i < vYOffset.size(); i++)`
	`1194`	`+ for (size_t k = 0; k < vYOffset.size(); k++)`
`1195`	`1195`	`{`
`1196`		`- TraceStart.Y = vYOffset[i];`
`1197`		`- TraceEnd.Y = vYOffset[i];`
	`1196`	`+ TraceStart.Y = vYOffset[k];`
	`1197`	`+ TraceEnd.Y = vYOffset[k];`
`1198`	`1198`
`1199`	`1199`	`if (GetWorld()->LineTraceSingleByChannel(OutHit, TraceStart, TraceEnd, ECC_Visibility, CollisionParams))`
`1200`	`1200`	`{`
`@@ -1685,9 +1685,9 @@ bool AFWGen::SetGenerationMaxZFromActorZ(float NewGenerationMaxZFromActorZ)`
`1685`	`1685`	`}`
`1686`	`1686`	`}`
`1687`	`1687`
`1688`		`-void AFWGen::SetInvertWorld(bool InvertWorld)`
	`1688`	`+void AFWGen::SetInvertWorld(bool Invertworld)`
`1689`	`1689`	`{`
`1690`		`- this->InvertWorld = InvertWorld;`
	`1690`	`+ this->InvertWorld = Invertworld;`
`1691`	`1691`	`}`
`1692`	`1692`
`1693`	`1693`	`bool AFWGen::SetWorldSize(int32 NewWorldSize)`
`@@ -1806,9 +1806,9 @@ bool AFWGen::SetThirdMaterialOnOtherProbability(float ThirdOnFirst, float ThirdO`
`1806`	`1806`	`}`
`1807`	`1807`	`}`
`1808`	`1808`
`1809`		`-void AFWGen::SetCreateWater(bool CreateWater)`
	`1809`	`+void AFWGen::SetCreateWater(bool Createwater)`
`1810`	`1810`	`{`
`1811`		`- this->CreateWater = CreateWater;`
	`1811`	`+ this->CreateWater = Createwater;`
`1812`	`1812`	`}`
`1813`	`1813`
`1814`	`1814`	`bool AFWGen::SetZWaterLevelInWorld(float NewZWaterLevelInWorld)`
`@@ -2408,29 +2408,29 @@ bool AFWGen::SetMinSlopeHeightMultiplier(float NewMinSlopeHeightMultiplier)`
`2408`	`2408`	`}`
`2409`	`2409`	`}`
`2410`	`2410`
`2411`		`-bool AFWGen::SetDivideChunkXCount(int32 DivideChunkXCount)`
	`2411`	`+bool AFWGen::SetDivideChunkXCount(int32 DivideChunkXcount)`
`2412`	`2412`	`{`
`2413`		`- if (DivideChunkXCount < 1)`
	`2413`	`+ if (DivideChunkXcount < 1)`
`2414`	`2414`	`{`
`2415`	`2415`	`return true;`
`2416`	`2416`	`}`
`2417`	`2417`	`else`
`2418`	`2418`	`{`
`2419`		`- this->DivideChunkXCount = DivideChunkXCount;`
	`2419`	`+ this->DivideChunkXCount = DivideChunkXcount;`
`2420`	`2420`
`2421`	`2421`	`return false;`
`2422`	`2422`	`}`
`2423`	`2423`	`}`
`2424`	`2424`
`2425`		`-bool AFWGen::SetDivideChunkYCount(int32 DivideChunkYCount)`
	`2425`	`+bool AFWGen::SetDivideChunkYCount(int32 DivideChunkYcount)`
`2426`	`2426`	`{`
`2427`		`- if (DivideChunkYCount < 1)`
	`2427`	`+ if (DivideChunkYcount < 1)`
`2428`	`2428`	`{`
`2429`	`2429`	`return true;`
`2430`	`2430`	`}`
`2431`	`2431`	`else`
`2432`	`2432`	`{`
`2433`		`- this->DivideChunkYCount = DivideChunkYCount;`
	`2433`	`+ this->DivideChunkYCount = DivideChunkYcount;`
`2434`	`2434`
`2435`	`2435`	`return false;`
`2436`	`2436`	`}`