Added CastTerrainPenetrationRay to SceneMan, which stops after passing through a given amount of terrain material strength.

Author: comradeshook

Source/Lua/LuaBindingsManagers.cpp

@@ -314,6 +314,7 @@ LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, SceneMan) {
 	    .def("CastMORay", &SceneMan::CastMORay)
 	    .def("CastFindMORay", &SceneMan::CastFindMORay)
 	    .def("CastObstacleRay", &SceneMan::CastObstacleRay)
+	    .def("CastTerrainPenetrationRay", &SceneMan::CastTerrainPenetrationRay)
 	    .def("GetLastRayHitPos", &SceneMan::GetLastRayHitPos)
 	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int)) & SceneMan::FindAltitude)
 	    .def("FindAltitude", (float(SceneMan::*)(const Vector&, int, int, bool)) & SceneMan::FindAltitude)

Source/Managers/SceneMan.cpp

@@ -1077,6 +1077,94 @@ void SceneMan::RestoreUnseenBox(const int posX, const int posY, const int width,
 	}
 }
 
+bool SceneMan::CastTerrainPenetrationRay(const Vector& start, const Vector& ray, Vector& endPos, int strengthLimit, int skip) {
+	int hitCount = 0, error, dom, sub, domSteps, skipped = skip;
+	int intPos[2], delta[2], delta2[2], increment[2];
+	bool stopped = false;
+	unsigned char materialID;
+	Material const* foundMaterial;
+	int totalStrength = 0;
+	// Save the projected end of the ray pos
+	endPos = start + ray;
+
+	intPos[X] = std::floor(start.m_X);
+	intPos[Y] = std::floor(start.m_Y);
+	delta[X] = std::floor(start.m_X + ray.m_X) - intPos[X];
+	delta[Y] = std::floor(start.m_Y + ray.m_Y) - intPos[Y];
+
+	if (delta[X] == 0 && delta[Y] == 0)
+		return false;
+
+	/////////////////////////////////////////////////////
+	// Bresenham's line drawing algorithm preparation
+
+	if (delta[X] < 0) {
+		increment[X] = -1;
+		delta[X] = -delta[X];
+	} else
+		increment[X] = 1;
+
+	if (delta[Y] < 0) {
+		increment[Y] = -1;
+		delta[Y] = -delta[Y];
+	} else
+		increment[Y] = 1;
+
+	// Scale by 2, for better accuracy of the error at the first pixel
+	delta2[X] = delta[X] << 1;
+	delta2[Y] = delta[Y] << 1;
+
+	// If X is dominant, Y is submissive, and vice versa.
+	if (delta[X] > delta[Y]) {
+		dom = X;
+		sub = Y;
+	} else {
+		dom = Y;
+		sub = X;
+	}
+
+	error = delta2[sub] - delta[dom];
+
+	/////////////////////////////////////////////////////
+	// Bresenham's line drawing algorithm execution
+
+	for (domSteps = 0; domSteps < delta[dom]; ++domSteps) {
+		intPos[dom] += increment[dom];
+		if (error >= 0) {
+			intPos[sub] += increment[sub];
+			error -= delta2[dom];
+		}
+		error += delta2[sub];
+
+		// Only check pixel if we're not due to skip any, or if this is the last pixel
+		if (++skipped > skip || domSteps + 1 == delta[dom]) {
+			// Scene wrapping
+			g_SceneMan.WrapPosition(intPos[X], intPos[Y]);
+
+			// Check the strength of the terrain to see if we can penetrate further
+			materialID = GetTerrMatter(intPos[X], intPos[Y]);
+			// Get the material object
+			foundMaterial = GetMaterialFromID(materialID);
+			// Add the encountered material's strength to the tally
+			totalStrength += foundMaterial->GetIntegrity();
+			// See if we have hit the limits of our ray's strength
+			if (totalStrength >= strengthLimit) {
+				// Save the position of the end of the ray where blocked
+				endPos.SetXY(intPos[X], intPos[Y]);
+				stopped = true;
+				break;
+			}
+			// Reset skip counter
+			skipped = 0;
+			if (m_pDebugLayer && m_DrawRayCastVisualizations) {
+				m_pDebugLayer->SetPixel(intPos[X], intPos[Y], 13);
+			}
+		}
+	}
+
+	return stopped;
+}
+
 // TODO Every raycast should use some shared line drawing method (or maybe something more efficient if it exists, that needs looking into) instead of having a ton of duplicated code.
 bool SceneMan::CastUnseenRay(int team, const Vector& start, const Vector& ray, Vector& endPos, int strengthLimit, int skip, bool reveal) {
 	if (!m_pCurrentScene->GetUnseenLayer(team))

Source/Managers/SceneMan.h

@@ -460,6 +460,18 @@ namespace RTE {
 		/// @param width The team to restore for.
 		void RestoreUnseenBox(const int posX, const int posY, const int width, const int height, const int team);
 
+		/// Traces along a vector and stops when the accumulated material strengths of the
+		/// traced-through terrain meets or exceeds a given value.
+		/// @param start The starting position.
+		/// @param ray The vector to trace along.
+		/// @param endPos A Vector that will be set to the position of where the sight ray was
+		/// terminated. If it reached the end, it will be set to the end of the ray.
+		/// @param strengthLimit The accumulated material strength limit where the ray stops.
+		/// @param skip For every pixel checked along the line, how many to skip between them
+		/// for optimization reasons. 0 = every pixel is checked.
+		/// @return Whether the ray was stopped prematurely or not.
+		bool CastTerrainPenetrationRay(const Vector& start, const Vector& ray, Vector& endPos, int strengthLimit, int skip);
+
 		/// Traces along a vector and reveals or hides pixels on the unseen layer of a team
 		/// as long as the accumulated material strengths traced through the terrain
 		/// don't exceed a specific value.