GetMOsAtPosition, currently-untestable CastAllMOsRay

pawnishoovy · pawnishoovy · commit e0cca096b9af · 2024-12-04T00:54:28.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -83,6 +83,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - New `ACraft` INI and Lua (R/W) property `CanEnterOrbit`, which determines whether a craft can enter orbit (and refund gold appropriately) or not. If false, default out-of-bounds deletion logic applies.
 
+- New `MovableMan` function `GetMOsAtPosition(posX, posY, ignoreTeam, getsHitByMOsOnly)` that will return an iterator with all the `MovableObject`s that intersect that exact position with their sprite.
+
 </details>
 
 <details><summary><b>Changed</b></summary>
diff --git a/Source/Entities/MOPixel.cpp b/Source/Entities/MOPixel.cpp
@@ -140,8 +140,8 @@ void MOPixel::SetTrailLength(int trailLength) {
 	m_Atom->SetTrailLength(trailLength);
 }
 
-bool MOPixel::HitTestAtPixel(int pixelX, int pixelY) const {
-	if (!GetsHitByMOs() || GetRootParent()->GetTraveling()) {
+bool MOPixel::HitTestAtPixel(int pixelX, int pixelY, bool validOnly) const {
+	if (validOnly && (!GetsHitByMOs() || GetRootParent()->GetTraveling())) {
 		return false;
 	}
 
diff --git a/Source/Entities/MOPixel.h b/Source/Entities/MOPixel.h
@@ -125,8 +125,9 @@ namespace RTE {
 		/// Whether a set of X, Y coordinates overlap us (in world space).
 		/// @param pixelX The given X coordinate, in world space.
 		/// @param pixelY The given Y coordinate, in world space.
+		/// @param validOnly Whether to return false if this MO isn't validly owned by MovableMan or not.
 		/// @return Whether the given coordinate overlap us.
-		bool HitTestAtPixel(int pixelX, int pixelY) const override;
+		bool HitTestAtPixel(int pixelX, int pixelY, bool validOnly = true) const override;
 #pragma endregion
 
 #pragma region Virtual Override Methods
diff --git a/Source/Entities/MOSprite.cpp b/Source/Entities/MOSprite.cpp
@@ -240,8 +240,8 @@ void MOSprite::Destroy(bool notInherited) {
 	Clear();
 }
 
-bool MOSprite::HitTestAtPixel(int pixelX, int pixelY) const {
-	if (!GetsHitByMOs() || GetRootParent()->GetTraveling()) {
+bool MOSprite::HitTestAtPixel(int pixelX, int pixelY, bool validOnly) const {
+	if (validOnly && (!GetsHitByMOs() || GetRootParent()->GetTraveling())) {
 		return false;
 	}
 
diff --git a/Source/Entities/MOSprite.h b/Source/Entities/MOSprite.h
@@ -127,8 +127,9 @@ namespace RTE {
 		/// Whether a set of X, Y coordinates overlap us (in world space).
 		/// @param pixelX The given X coordinate, in world space.
 		/// @param pixelY The given Y coordinate, in world space.
+		/// @param validOnly Whether to return false if this MO isn't validly owned by MovableMan or not.
 		/// @return Whether the given coordinate overlap us.
-		bool HitTestAtPixel(int pixelX, int pixelY) const override;
+		bool HitTestAtPixel(int pixelX, int pixelY, bool validOnly = true) const override;
 
 		/// Gets the current angular velocity of this MovableObject. Positive is
 		/// a counter-clockwise rotation.
diff --git a/Source/Entities/MovableObject.h b/Source/Entities/MovableObject.h
@@ -588,8 +588,9 @@ namespace RTE {
 		/// Whether a set of X, Y coordinates overlap us (in world space).
 		/// @param pixelX The given X coordinate, in world space.
 		/// @param pixelY The given Y coordinate, in world space.
+		/// @param validOnly Whether to return false if this MO isn't validly owned by MovableMan or not.
 		/// @return Whether the given coordinate overlap us.
-		virtual bool HitTestAtPixel(int pixelX, int pixelY) const { return false; }
+		virtual bool HitTestAtPixel(int pixelX, int pixelY, bool validOnly = true) const { return false; }
 
 		/// Shows whether this is or carries a specifically named object in its
 		/// inventory. Also looks through the inventories of potential passengers,
diff --git a/Source/Lua/LuaAdapterDefinitions.h b/Source/Lua/LuaAdapterDefinitions.h
@@ -517,31 +517,43 @@ namespace RTE {
 		/// first, g_NoMOID will be returned.
 		/// @param start The starting position.
 		/// @param ray The vector to trace along.
-		/// @param ignoredMOIDs A vector of MOIDs to ignore. Any child MO's of this MOID will also be ignored. (default: g_NoMOID)
+		/// @param ignoreMOIDs A vector of MOIDs to ignore. Any child MO's of this MOID will also be ignored. (default: g_NoMOID)
 		/// @param ignoreTeam To enable ignoring of all MOIDs associated with an object of a specific (default: Activity::NoTeam)
 		/// team which also has team ignoring enabled itself.
 		/// @param ignoreMaterial A specific material ID to ignore hits with. (default: 0)
 		/// @param ignoreAllTerrain Whether to ignore all terrain hits or not. (default: false)
 		/// @param skip For every pixel checked along the line, how many to skip between them (default: 0)
 		/// for optimization reasons. 0 = every pixel is checked.
 		/// @return The MOID of the hit non-ignored MO, or g_NoMOID if terrain or no MO was hit.
-		static MOID CastMORay1(SceneMan& sceneMan, const Vector& start, const Vector& ray, const luabind::object& ignoredMOIDs, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
+		static MOID CastMORay1(SceneMan& sceneMan, const Vector& start, const Vector& ray, const luabind::object& ignoreMOIDs, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
 
 		/// Traces along a vector and returns MOID of the first non-ignored
 		/// non-NoMOID MO encountered. If a non-air terrain pixel is encountered
 		/// first, g_NoMOID will be returned.
 		/// @param start The starting position.
 		/// @param ray The vector to trace along.
-		/// @param ignoredMOID An MOID to ignore. Any child MO's of this MOID will also be ignored. (default: g_NoMOID)
+		/// @param ignoreMOID An MOID to ignore. Any child MO's of this MOID will also be ignored. (default: g_NoMOID)
 		/// @param ignoreTeam To enable ignoring of all MOIDs associated with an object of a specific (default: Activity::NoTeam)
 		/// team which also has team ignoring enabled itself.
 		/// @param ignoreMaterial A specific material ID to ignore hits with. (default: 0)
 		/// @param ignoreAllTerrain Whether to ignore all terrain hits or not. (default: false)
 		/// @param skip For every pixel checked along the line, how many to skip between them (default: 0)
 		/// for optimization reasons. 0 = every pixel is checked.
 		/// @return The MOID of the hit non-ignored MO, or g_NoMOID if terrain or no MO was hit.
-		static MOID CastMORay2(SceneMan& sceneMan, const Vector& start, const Vector& ray, MOID ignoredMOID = g_NoMOID, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
+		static MOID CastMORay2(SceneMan& sceneMan, const Vector& start, const Vector& ray, MOID ignoreMOID = g_NoMOID, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
 
+		/// Traces along a vector and returns a vector of all MOs encountered.
+		/// @param start The starting position.
+		/// @param ray The vector to trace along.
+		/// @param ignoreMOIDs A vector of MOIDs to ignore. Any child MOs of an MOID will also be ignored. (default: g_NoMOID)
+		/// @param ignoreTeam To enable ignoring of all MOIDs associated with an object of a specific team (default: Activity::NoTeam)
+		/// @param ignoreMaterial A specific material ID to ignore hits with. (default: 0)
+		/// @param ignoreAllTerrain Whether to ignore all terrain hits or not. (default: false)
+		/// @param skip For every pixel checked along the line, how many to skip between them (default: 0)
+		/// for optimization reasons. 0 = every pixel is checked.
+		/// @return A vector of pointers to all MovableObjects met along the ray, who aren't ignored.
+		static const std::vector<MovableObject*>* CastAllMOsRay(SceneMan& sceneMan, const Vector& start, const Vector& ray, const luabind::object& ignoreMOIDs, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
+		
 		/// Traces along a vector and returns the length of how far the trace went
 		/// without hitting any non-ignored terrain material or MOID at all.
 		/// @param start The starting position.
diff --git a/Source/Lua/LuaAdapters.cpp b/Source/Lua/LuaAdapters.cpp
@@ -626,6 +626,15 @@ MOID LuaAdaptersSceneMan::CastMORay2(SceneMan& sceneMan, const Vector& start, co
 	return sceneMan.CastMORay(start, ray, ignoreMOIDs, ignoreTeam, ignoreMaterial, ignoreAllTerrain, skip);
 }
 
+const std::vector<MovableObject*>* LuaAdaptersSceneMan::CastAllMOsRay(SceneMan& sceneMan, const Vector& start, const Vector& ray, const luabind::object& ignoreMOIDs, int ignoreTeam, unsigned char ignoreMaterial, bool ignoreAllTerrain, int skip) {
+	std::vector<MOID*> ptrVec = ConvertLuaTableToVectorOfType<MOID*>(ignoreMOIDs);
+	std::vector<MOID> ignoreMOIDsVec;
+	for (auto ptr : ptrVec) {
+		ignoreMOIDsVec.push_back(*ptr);
+	}
+	return sceneMan.CastAllMOsRay(start, ray, ignoreMOIDsVec, ignoreTeam, ignoreMaterial, ignoreAllTerrain, skip);
+}
+
 float LuaAdaptersSceneMan::CastObstacleRay1(SceneMan& sceneMan, const Vector& start, const Vector& ray, Vector& obstaclePos, Vector& freePos, const luabind::object& ignoreMOIDs, int ignoreTeam, unsigned char ignoreMaterial, int skip) {
 	std::vector<MOID*> ptrVec = ConvertLuaTableToVectorOfType<MOID*>(ignoreMOIDs);
 	std::vector<MOID> ignoreMOIDsVec;
diff --git a/Source/Lua/LuaBindingsManagers.cpp b/Source/Lua/LuaBindingsManagers.cpp
@@ -168,6 +168,9 @@ LuaBindingRegisterFunctionDefinitionForType(ManagerLuaBindings, MovableMan) {
 	    .def("GetMOsInRadius", (const std::vector<MovableObject*>* (MovableMan::*)(const Vector& centre, float radius) const) & MovableMan::GetMOsInRadius, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
 	    .def("GetMOsInRadius", (const std::vector<MovableObject*>* (MovableMan::*)(const Vector& centre, float radius, int ignoreTeam) const) & MovableMan::GetMOsInRadius, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
 	    .def("GetMOsInRadius", (const std::vector<MovableObject*>* (MovableMan::*)(const Vector& centre, float radius, int ignoreTeam, bool getsHitByMOsOnly) const) & MovableMan::GetMOsInRadius, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("GetMOsAtPosition", (const std::vector<MovableObject*>* (MovableMan::*)(int pixelX, int pixelY) const) & MovableMan::GetMOsAtPosition, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("GetMOsAtPosition", (const std::vector<MovableObject*>* (MovableMan::*)(int pixelX, int pixelY, int ignoreTeam) const) & MovableMan::GetMOsAtPosition, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
+	    .def("GetMOsAtPosition", (const std::vector<MovableObject*>* (MovableMan::*)(int pixelX, int pixelY, int ignoreTeam, bool getsHitByMOsOnly) const) & MovableMan::GetMOsAtPosition, luabind::adopt(luabind::return_value) + luabind::return_stl_iterator)
 
 	    .def("SendGlobalMessage", &LuaAdaptersMovableMan::SendGlobalMessage1)
 	    .def("SendGlobalMessage", &LuaAdaptersMovableMan::SendGlobalMessage2)
diff --git a/Source/Managers/MovableMan.cpp b/Source/Managers/MovableMan.cpp
@@ -193,6 +193,12 @@ const std::vector<MovableObject*>* MovableMan::GetMOsInRadius(const Vector& cent
 	return vectorForLua;
 }
 
+const std::vector<MovableObject*>* MovableMan::GetMOsAtPosition(int pixelX, int pixelY, int ignoreTeam, bool getsHitByMOsOnly) const {
+	std::vector<MovableObject*>* vectorForLua = new std::vector<MovableObject*>();
+	*vectorForLua = std::move(g_SceneMan.GetMOIDGrid().GetMOsAtPosition(pixelX, pixelY, ignoreTeam, getsHitByMOsOnly));
+	return vectorForLua;
+}
+
 void MovableMan::PurgeAllMOs() {
 	for (std::deque<Actor*>::iterator itr = m_Actors.begin(); itr != m_Actors.end(); ++itr) {
 		(*itr)->DestroyScriptState();
diff --git a/Source/Managers/MovableMan.h b/Source/Managers/MovableMan.h
@@ -539,6 +539,14 @@ namespace RTE {
 		/// @return Pointers to the MOs that are within the specified radius of the given centre position.
 		const std::vector<MovableObject*>* GetMOsInRadius(const Vector& centre, float radius) const { return GetMOsInRadius(centre, radius, Activity::NoTeam); }
 
+		/// Gets pointers to the MOs that are at a particular position in the Scene.
+		/// @param pixelX The X coordinate of the Scene pixel to test.
+		/// @param pixelY The Y coordinate of the Scene pixel to test.
+		/// @param ignoreTeam The team to ignore.
+		/// @param getsHitByMOsOnly Whether to only include MOs that have GetsHitByMOs enabled, or all MOs.
+		/// @return Pointers to the MOs that are within the specified radius of the given centre position.
+		const std::vector<MovableObject*>* GetMOsAtPosition(int pixelX, int pixelY, int ignoreTeam, bool getsHitByMOsOnly) const;
+		
 		/// Runs a lua function on all MOs in the simulation, including owned child MOs.
 		void RunLuaFunctionOnAllMOs(const std::string& functionName, bool includeAdded, const std::vector<const Entity*>& functionEntityArguments = std::vector<const Entity*>(), const std::vector<std::string_view>& functionLiteralArguments = std::vector<std::string_view>(), const std::vector<LuabindObjectWrapper*>& functionObjectArguments = std::vector<LuabindObjectWrapper*>());
 
diff --git a/Source/Managers/SceneMan.cpp b/Source/Managers/SceneMan.cpp
@@ -2095,6 +2095,108 @@ bool SceneMan::CastFindMORay(const Vector& start, const Vector& ray, MOID target
 	return false;
 }
 
+const std::vector<MovableObject*>*  SceneMan::CastAllMOsRay(const Vector& start, const Vector& ray, const std::vector<MOID>& ignoreMOIDs, int ignoreTeam, unsigned char ignoreMaterial, bool ignoreAllTerrain, int skip) const {
+	std::vector<MovableObject*>* vectorForLua = new std::vector<MovableObject*>();
+
+	const SpatialPartitionGrid& partitionGrid = GetMOIDGrid();
+
+	int hitCount = 0, error, dom, sub, domSteps, skipped = skip;
+	int intPos[2], delta[2], delta2[2], increment[2];
+	unsigned char hitTerrain = 0;
+
+	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 vectorForLua;
+
+	/////////////////////////////////////////////////////
+	// 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, if necessary
+			g_SceneMan.WrapPosition(intPos[X], intPos[Y]);
+				
+			// Detect MOs
+			std::vector<MovableObject*> hitMOs;
+			hitMOs = std::move(partitionGrid.GetMOsAtPosition(intPos[X], intPos[Y], ignoreTeam, false));
+
+			// Loop through the gotten MOs and check if we're ignoring their IDs - if not, put them onto our return vector
+			for (MovableObject* mo : hitMOs) {
+				MOID moid = mo->GetID();
+				for (auto ignoredMOID : ignoreMOIDs) {
+					if (moid != ignoredMOID && g_MovableMan.GetRootMOID(moid) != ignoredMOID) {
+						// Save last ray pos
+						s_LastRayHitPos.SetXY(intPos[X], intPos[Y]);
+						vectorForLua->push_back(mo);
+					}
+				}
+			}
+
+			// Detect terrain hits
+			if (!ignoreAllTerrain) {
+				hitTerrain = g_SceneMan.GetTerrMatter(intPos[X], intPos[Y]);
+				if (hitTerrain != g_MaterialAir && hitTerrain != ignoreMaterial) {
+					// Save last ray pos
+					s_LastRayHitPos.SetXY(intPos[X], intPos[Y]);
+					return vectorForLua;
+				}
+			}
+
+			skipped = 0;
+
+			if (m_pDebugLayer && m_DrawRayCastVisualizations) {
+				m_pDebugLayer->SetPixel(intPos[X], intPos[Y], 13);
+			}
+		}
+	}
+
+	// Didn't hit anything but air
+	return vectorForLua;
+}
+
 float SceneMan::CastObstacleRay(const Vector& start, const Vector& ray, Vector& obstaclePos, Vector& freePos, const std::vector<MOID>& ignoreMOIDs, int ignoreTeam, unsigned char ignoreMaterial, int skip) {
 	int hitCount = 0, error, dom, sub, domSteps, skipped = skip;
 	int intPos[2], delta[2], delta2[2], increment[2];
diff --git a/Source/Managers/SceneMan.h b/Source/Managers/SceneMan.h
@@ -703,6 +703,18 @@ namespace RTE {
 		/// @return Whether the target MOID was found along the ray or not.
 		bool CastFindMORay(const Vector& start, const Vector& ray, MOID targetMOID, Vector& resultPos, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0);
 
+		/// Traces along a vector and returns a vector of all MOs encountered.
+		/// @param start The starting position.
+		/// @param ray The vector to trace along.
+		/// @param ignoreMOIDs A vector of MOIDs to ignore. Any child MOs of an MOID will also be ignored. (default: g_NoMOID)
+		/// @param ignoreTeam To enable ignoring of all MOIDs associated with an object of a specific team (default: Activity::NoTeam)
+		/// @param ignoreMaterial A specific material ID to ignore hits with. (default: 0)
+		/// @param ignoreAllTerrain Whether to ignore all terrain hits or not. (default: false)
+		/// @param skip For every pixel checked along the line, how many to skip between them (default: 0)
+		/// for optimization reasons. 0 = every pixel is checked.
+		/// @return A vector of pointers to all MovableObjects met along the ray, who aren't ignored.
+		const std::vector<MovableObject*>* CastAllMOsRay(const Vector& start, const Vector& ray, const std::vector<MOID>& ignoreMOIDs = {g_NoMOID}, int ignoreTeam = Activity::NoTeam, unsigned char ignoreMaterial = 0, bool ignoreAllTerrain = false, int skip = 0) const;
+		
 		/// Traces along a vector and returns the length of how far the trace went
 		/// without hitting any non-ignored terrain material or MOID at all.
 		/// @param start The starting position.
diff --git a/Source/System/SpatialPartitionGrid.cpp b/Source/System/SpatialPartitionGrid.cpp
@@ -176,6 +176,32 @@ const std::vector<MOID>& SpatialPartitionGrid::GetMOIDsAtPosition(int x, int y,
 	return cells[ignoreTeam + 1][GetCellIdForCellCoords(cellX, cellY)];
 }
 
+std::vector<MovableObject*> SpatialPartitionGrid::GetMOsAtPosition(int x, int y, int ignoreTeam, bool getsHitByMOsOnly) const {
+	RTEAssert(ignoreTeam >= Activity::NoTeam && ignoreTeam < Activity::MaxTeamCount, "Invalid ignoreTeam given to SpatialPartitioningGrid::GetMOsAtPosition()!");
+
+	std::unordered_set<MOID> potentialMOIDs;
+
+	int cellX = x / m_CellSize;
+	int cellY = y / m_CellSize;
+
+	// Note - GetCellIdForCellCoords accounts for wrapping automatically, so we don't have to deal with it here.
+	auto& cells = getsHitByMOsOnly ? m_PhysicsCells : m_Cells;
+	const std::vector<MOID>& moidsInCell = cells[ignoreTeam + 1][GetCellIdForCellCoords(cellX, cellY)];
+	for (MOID moid: moidsInCell) {
+		potentialMOIDs.insert(moid);
+	}
+
+	std::vector<MovableObject*> MOList;
+	for (MOID moid: potentialMOIDs) {
+		MovableObject* mo = g_MovableMan.GetMOFromID(moid);
+		if (mo && mo->HitTestAtPixel(x, y, false)) {
+			MOList.push_back(mo);
+		}
+	}
+
+	return MOList;
+}
+
 int SpatialPartitionGrid::GetCellIdForCellCoords(int cellX, int cellY) const {
 	// We act like we wrap, even if the Scene doesn't. The only cost is some duplicate collision checks, but that's a minor cost to pay :)
 	int wrappedX = cellX % m_Width;
diff --git a/Source/System/SpatialPartitionGrid.h b/Source/System/SpatialPartitionGrid.h
@@ -68,6 +68,14 @@ namespace RTE {
 		/// @param getsHitByMOsOnly Whether to only include MOs that have GetsHitByMOs enabled, or all MOs.
 		/// @return A vector of MOIDs that are potentially overlapping the x and y coordinates.
 		const std::vector<int>& GetMOIDsAtPosition(int x, int y, int ignoreTeam, bool getsHitByMOsOnly) const;
+
+		/// Get a vector of pointers to all the MovableObjects that are potentially overlapping the given X and Y Scene coordinates.
+		/// @param x The X coordinate to check.
+		/// @param y The Y coordinate to check.
+		/// @param ignoreTeam The team to ignore when getting MOs.
+		/// @param getsHitByMOsOnly Whether to only include MOs that have GetsHitByMOs enabled, or all MOs.
+		/// @return A vector of pointers to all MovableObjects within the given x and y coordinates, who aren't of the ignored team.
+		std::vector<MovableObject*> GetMOsAtPosition(int x, int y, int ignoreTeam, bool getsHitByMOsOnly) const;
 #pragma endregion
 
 	private:

Original file line number	Diff line number	Diff line change
`@@ -140,8 +140,8 @@ void MOPixel::SetTrailLength(int trailLength) {`
`140`	`140`	`m_Atom->SetTrailLength(trailLength);`
`141`	`141`	`}`
`142`	`142`
`143`		`-bool MOPixel::HitTestAtPixel(int pixelX, int pixelY) const {`
`144`		`- if (!GetsHitByMOs() \|\| GetRootParent()->GetTraveling()) {`
	`143`	`+bool MOPixel::HitTestAtPixel(int pixelX, int pixelY, bool validOnly) const {`
	`144`	`+ if (validOnly && (!GetsHitByMOs() \|\| GetRootParent()->GetTraveling())) {`
`145`	`145`	`return false;`
`146`	`146`	`}`
`147`	`147`
Original file line number	Diff line number	Diff line change
`@@ -240,8 +240,8 @@ void MOSprite::Destroy(bool notInherited) {`
`240`	`240`	`Clear();`
`241`	`241`	`}`
`242`	`242`
`243`		`-bool MOSprite::HitTestAtPixel(int pixelX, int pixelY) const {`
`244`		`- if (!GetsHitByMOs() \|\| GetRootParent()->GetTraveling()) {`
	`243`	`+bool MOSprite::HitTestAtPixel(int pixelX, int pixelY, bool validOnly) const {`
	`244`	`+ if (validOnly && (!GetsHitByMOs() \|\| GetRootParent()->GetTraveling())) {`
`245`	`245`	`return false;`
`246`	`246`	`}`
`247`	`247`