Merge pull request #47 from cortex-command-community/moredislodgepixel

Added line, circle and box variants of DislodgePixel to SceneMan

Author: Causeless

CHANGELOG.md

@@ -126,6 +126,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Exposed `FrameMan` properties `ScreenCount` and `ResolutionMultiplier` to Lua (R).
 
+- New `SceneMan` Lua functions:
+	`DislodgePixelCircle(Vector centre, float radius, bool deletePixels)`, which calls `DislodgePixel()` on all pixels in a given circle, returns them as an iterable list. The bool is an optional argument to delete all found pixels immediately; defaults to `false`.
+	`DislodgePixelRing(Vector centre, float innerRadius, float outerRadius, bool deletePixels)`, same as above but additionally ignores pixels within the inner radius.
+	`DislodgePixelBox(Vector upperLeftCorner, Vector lowerRightCorner, bool deletePixels)`, similar to above, but in a rectangular area defined by upper left- and lower right corners.
+	`DislodgePixelLine(Vector startPos, Vector ray, int skip, bool deletePixels)`, calls `DislodgePixel()` on all pixels in a line, like above. Similar in function to a ray cast, so pixels can be skipped.
+
 - New `SceneMan` Lua function `CastTerrainPenetrationRay(Vector start, Vector ray, Vector endPos, int strengthLimit, int skip)`, which adds up the material strength of the terrain pixels encountered along the way, and stops when the accumulated value meets or exceeds `strengthLimit`. `endPos` is filled out with the ending position of the ray, returns `true` or `false` depending on whether the ray was stopped early or not.
 
 </details>
@@ -170,6 +176,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - The `SceneObject` property `IsBuyable` has been renamed to `Buyable`.
 
+- `SceneMan` Lua function `DislodgePixel()` now optionally accepts a third boolean argument to delete the found pixel immediately. Format is `DislodgePixel(int posX, int posY, bool deletePixel)`. `DislodgePixel()` now also automatically accounts for scene wrapping.
+
 </details>
 
 <details><summary><b>Fixed</b></summary>

Source/Lua/LuaBindingsManagers.cpp

@@ -331,7 +331,16 @@ 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)
+	    .def("DislodgePixelRing", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& centre, float innerRadius, float outerRadius, bool deletePixels) const) & SceneMan::DislodgePixelRing, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("DislodgePixelRing", (const std::vector<MovableObject*>* (SceneMan::*)(const Vector& centre, float innerRadius, float outerRadius) const) & SceneMan::DislodgePixelRingNoBool, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator);
 }
 
 LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, CameraMan) {

Source/Managers/SceneMan.cpp

@@ -893,6 +893,7 @@ bool SceneMan::TryPenetrate(int posX,
 }
 
 MovableObject* SceneMan::DislodgePixel(int posX, int posY) {
+	WrapPosition(posX, posY);
 	int materialID = getpixel(m_pCurrentScene->GetTerrain()->GetMaterialBitmap(), posX, posY);
 	if (materialID <= MaterialColorKeys::g_MaterialAir) {
 		return nullptr;
@@ -922,6 +923,180 @@ 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);
+	if (pixelMO) {
+		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*>();
+	int limit = static_cast<int>(radius) * 2;
+	for (int x = 0; x <= limit; x++) {
+		for (int y = 0; y <= limit; y++) {
+			Vector checkPos = Vector(static_cast<float>(x) - radius, static_cast<float>(y) - radius) + centre;
+			Vector distance = ShortestDistance(centre, checkPos, true);
+
+			if (distance.MagnitudeIsGreaterThan(radius) && y > limit / 2) {
+				break;
+			}
+
+			if (!distance.MagnitudeIsGreaterThan(radius)) {
+				MovableObject* px = DislodgePixelBool(checkPos.m_X, checkPos.m_Y, deletePixels);
+				if (px) {
+					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::DislodgePixelRing(const Vector& centre, float innerRadius, float outerRadius, bool deletePixels) {
+	// Account for users inputting radii in the wrong order
+	if (outerRadius < innerRadius) {
+		std::swap(outerRadius, innerRadius);
+	}
+
+	std::vector<MovableObject*>* pixelList = new std::vector<MovableObject*>();
+	int limit = static_cast<int>(outerRadius) * 2;
+	for (int x = 0; x <= limit; x++) {
+		for (int y = 0; y <= limit; y++) {
+			Vector checkPos = Vector(static_cast<float>(x) - outerRadius, static_cast<float>(y) - outerRadius) + centre;
+			Vector distance = ShortestDistance(centre, checkPos, true);
+
+			if (distance.MagnitudeIsLessThan(innerRadius) && y < limit - y) {
+				y = limit - y;
+				continue;
+			}
+
+			if (distance.MagnitudeIsGreaterThan(outerRadius) && y > limit / 2) {
+				break;
+			}
+
+			if (!distance.MagnitudeIsGreaterThan(outerRadius) && !distance.MagnitudeIsLessThan(innerRadius)) {
+				MovableObject* px = DislodgePixelBool(checkPos.m_X, checkPos.m_Y, deletePixels);
+				if (px) {
+					pixelList->push_back(px);
+				}
+			}
+		}
+	}
+
+	return pixelList;
+}
+
+std::vector<MovableObject*>* SceneMan::DislodgePixelRingNoBool(const Vector& centre, float innerRadius, float outerRadius) {
+	return DislodgePixelRing(centre, innerRadius, outerRadius, 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 (int x = 0; x <= static_cast<int>(width) * 2; x++) {
+		for (int y = 0; y <= static_cast<int>(height) * 2; y++) {
+			Vector checkPos = start + Vector(static_cast<float>(x), static_cast<float>(y));
+			MovableObject* px = DislodgePixelBool(checkPos.m_X, checkPos.m_Y, deletePixels);
+			if (px) {
+				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];
+
+	/////////////////////////////////////////////////////
+	// 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 = DislodgePixelBool(intPos[X], intPos[Y], deletePixels);
+			if (px) {
+				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,69 @@ 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 ring of pixels from the terrain and adds them to MovableMan.
+		/// @param centre The vector position of the centre of the ring.
+		/// @param innerRadius The inner radius of the ring of pixels to remove.
+		/// @param outerRadius The outer radius of the ring 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*>* DislodgePixelRing(const Vector& centre, float innerRadius, float outerRadius, bool deletePixels);
+
+		/// Removes a ring of pixels from the terrain and adds them to MovableMan.
+		/// @param centre The vector position of the centre of the ring.
+		/// @param innerRadius The inner radius of the ring of pixels to remove.
+		/// @param outerRadius The outer radius of the ring of pixels to remove.
+		/// @return A list of the removed pixels, if any.
+		std::vector<MovableObject*>* DislodgePixelRingNoBool(const Vector& centre, float innerRadius, float outerRadius);
+
+		/// 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.