Added line, circle and box variants of DislodgePixel with optional deletion

Author: comradeshook

Source/Lua/LuaBindingsManagers.cpp

@@ -331,7 +331,14 @@ LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, SceneMan) {
 	    .def("ObscuredPoint", (bool(SceneMan::*)(int, int, int)) & SceneMan::ObscuredPoint)
 	    .def("AddSceneObject", &SceneMan::AddSceneObject, luabind::adopt(_2))
 	    .def("CheckAndRemoveOrphans", (int(SceneMan::*)(int, int, int, int, bool)) & SceneMan::RemoveOrphans)
-	    .def("DislodgePixel", &SceneMan::DislodgePixel);
+	    .def("DislodgePixel", &SceneMan::DislodgePixel)
+	    .def("DislodgePixel", &SceneMan::DislodgePixelBool)
+	    .def("DislodgePixelLine", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& start, const Vector& ray, int skip, bool deletePixels) const) & SceneMan::DislodgePixelLine, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelLine", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& start, const Vector& ray, int skip) const) & SceneMan::DislodgePixelLineNoBool, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelCircle", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& centre, float radius, bool deletePixels) const) & SceneMan::DislodgePixelCircle, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelCircle", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& centre, float radius) const) & SceneMan::DislodgePixelCircleNoBool, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelBox", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& upperLeftCorner, const Vector& lowerRightCorner, bool deletePixels) const) & SceneMan::DislodgePixelBox, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelBox", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& upperLeftCorner, const Vector& lowerRightCorner) const) & SceneMan::DislodgePixelBoxNoBool, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator);
 }
 
 LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, CameraMan) {

Source/Managers/SceneMan.cpp

@@ -922,6 +922,139 @@ MovableObject* SceneMan::DislodgePixel(int posX, int posY) {
 	return pixelMO;
 }
 
+// Bool variant to avoid changing the original
+MovableObject* SceneMan::DislodgePixelBool(int posX, int posY, bool deletePixel) {
+	MovableObject* pixelMO = DislodgePixel(posX, posY);
+	pixelMO->SetToDelete(deletePixel);
+	return pixelMO;
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelCircle(const Vector& centre, float radius, bool deletePixels) {
+	std::vector<MovableObject*>* pixelList = new std::vector<MovableObject*>();
+	for (float x = 0; x <= radius * 2; x++) {
+		for (float y = 0; y <= radius * 2; y++) {
+			Vector checkPos = Vector(x - radius, y - radius) + centre;
+			if (!ShortestDistance(centre, checkPos, true).MagnitudeIsGreaterThan(radius)) {
+				MovableObject* px = DislodgePixel(checkPos.m_X, checkPos.m_Y);
+				if (px) {
+					px->SetToDelete(deletePixels);
+					pixelList->push_back(px);
+				}
+			}
+		}
+	}
+
+	return pixelList;
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelCircleNoBool(const Vector& centre, float radius) {
+	return DislodgePixelCircle(centre, radius, false);
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelBox(const Vector& upperLeftCorner, const Vector& lowerRightCorner, bool deletePixels) {
+	std::vector<MovableObject*>* pixelList = new std::vector<MovableObject*>();
+
+	// Make sure it works even if people input corners in the wrong order
+	Vector start = Vector(std::min(upperLeftCorner.m_X, lowerRightCorner.m_X), std::min(upperLeftCorner.m_Y, lowerRightCorner.m_Y));
+	Vector end = Vector(std::max(upperLeftCorner.m_X, lowerRightCorner.m_X), std::max(upperLeftCorner.m_Y, lowerRightCorner.m_Y));
+
+	float width = end.m_X - start.m_X;
+	float height = end.m_Y - start.m_Y;
+	for (float x = 0; x <= width * 2; x++) {
+		for (float y = 0; y <= height * 2; y++) {
+			Vector checkPos = start + Vector(x, y);
+			MovableObject* px = DislodgePixel(checkPos.m_X, checkPos.m_Y);
+			if (px) {
+				px->SetToDelete(deletePixels);
+				pixelList->push_back(px);
+			}
+		}
+	}
+
+	return pixelList;
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelBoxNoBool(const Vector& upperLeftCorner, const Vector& lowerRightCorner) {
+	return DislodgePixelBox(upperLeftCorner, lowerRightCorner, false);
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelLine(const Vector& start, const Vector& ray, int skip, bool deletePixels) {
+	std::vector<MovableObject*>* pixelList = new std::vector<MovableObject*>();
+	int error, dom, sub, domSteps, skipped = skip;
+	int intPos[2], delta[2], delta2[2], increment[2];
+
+	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]);
+
+			MovableObject* px = DislodgePixel(intPos[X], intPos[Y]);
+			if (px) {
+				px->SetToDelete(deletePixels);
+				pixelList->push_back(px);
+			}
+
+			// Reset skip counter
+			skipped = 0;
+		}
+	}
+
+	return pixelList;
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelLineNoBool(const Vector& start, const Vector& ray, int skip) {
+	return DislodgePixelLine(start, ray, skip, false);
+}
+
 void SceneMan::MakeAllUnseen(Vector pixelSize, const int team) {
 	RTEAssert(m_pCurrentScene, "Messing with scene before the scene exists!");
 	if (team < Activity::TeamOne || team >= Activity::MaxTeamCount)

Source/Managers/SceneMan.h

@@ -403,6 +403,54 @@ namespace RTE {
 		/// @return The newly dislodged pixel, if one was found.
 		MovableObject* DislodgePixel(int posX, int posY);
 
+		/// Removes a pixel from the terrain and adds it to MovableMan.
+		/// @param posX The X coordinate of the terrain pixel.
+		/// @param posX The Y coordinate of the terrain pixel.
+		/// @param deletePixel Whether or not to immediately mark the pixel for deletion.
+		/// @return The newly dislodged pixel, if one was found.
+		MovableObject* DislodgePixelBool(int posX, int posY, bool deletePixel);
+
+		/// Removes a circle of pixels from the terrain and adds them to MovableMan.
+		/// @param centre The vector position of the centre of the circle.
+		/// @param radius The radius of the circle of pixels to remove.
+		/// @param deletePixels Whether or not to immediately mark all found pixels for deletion.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelCircle(const Vector& centre, float radius, bool deletePixels);
+
+		/// Removes a circle of pixels from the terrain and adds them to MovableMan.
+		/// @param centre The vector position of the centre of the circle.
+		/// @param radius The radius of the circle of pixels to remove.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelCircleNoBool(const Vector& centre, float radius);
+
+		/// Removes a box of pixels from the terrain and adds them to MovableMan.
+		/// @param upperLeftCorner The vector position of the upper left corner of the box.
+		/// @param lowerRightCorner The vector position of the lower right corner of the box.
+		/// @param deletePixels Whether or not to immediately mark all found pixels for deletion.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelBox(const Vector& upperLeftCorner, const Vector& lowerRightCorner, bool deletePixels);
+
+		/// Removes a box of pixels from the terrain and adds them to MovableMan.
+		/// @param upperLeftCorner The vector position of the upper left corner of the box.
+		/// @param lowerRightCorner The vector position of the lower right corner of the box.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelBoxNoBool(const Vector& upperLeftCorner, const Vector& lowerRightCorner);
+
+		/// Removes a line of pixels from the terrain and adds them to MovableMan.
+		/// @param start The starting position.
+		/// @param ray The vector to trace along.
+		/// @param skip For every pixel checked along the line, how many to skip between them.
+		/// @param deletePixels Whether or not to immediately mark all found pixels for deletion.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelLine(const Vector& start, const Vector& ray, int skip, bool deletePixels);
+
+		/// Removes a line of pixels from the terrain and adds them to MovableMan.
+		/// @param start The starting position.
+		/// @param ray The vector to trace along.
+		/// @param skip For every pixel checked along the line, how many to skip between them.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelLineNoBool(const Vector& start, const Vector& ray, int skip);
+
 		/// Sets one team's view of the scene to be unseen, using a generated map
 		/// of a specific resolution chunkiness.
 		/// @param pixelSize The dimensions of the pixels that should make up the unseen layer.