i would love to see this answer
Itâs a long story.
The short answer is that the deprecation was planned many years ago, with the intent that there wouldnât be a loss of functionality, and various parts of the replacement functionality were implemented over time but enough things changed in the meantime that some stuff fell through the cracks with no single person keeping a close enough eye on the overarching effort.
Thanks to the feedback here thereâs now some people looking into a proper resolution to the situation.
6 Likes
Unfortunately, there was an issue with Instance:HasTag and related methods, so it will have to wait a few extra weeks for the new fix to roll out to all mobile clients.
3 Likes
I see, thatâs pretty unfortunate, but Iâm still just happy that an update like this is even coming out. 
You guys at Roblox have really been stepping up your game with the recent updates, especially a lot of the stuff on the Creator Roadmap, lots of great things in there that Iâm really looking forward to using. Thank you guys for the work you all are putting in.
Yea Iâm apparently receiving a 404 error on that page, too.
Thanks for flagging this. It should work now
Was the behavior of :GetPartsInPart() supposed to change with the new optimization? It seems to now also return parts that arenât inside of the queried part, but just touching, and even returns parts that arenât touching at all, if theyâre within a certain threshold (seems to be about 0.01 studs).
This can be reproduced easily - place two parts next to each other (floating above the baseplate so it doesnât mess up results), and query one of them with :GetPartsInPart(). :GetPartBoundsInBox() seems to have a similar problem, but not to the same extent.
I set up a chart of various test cases and their expected (pre 576) results to demonstrate this:
I can upload the .rbxl file of this test place if needed. I hope this change isnât intentional, as it breaks a few of the use cases I had for this method previously, which relied on only returning intersecting parts and not surface touches.
5 Likes
Also noticed this, hopefully it gets fixed if itâs not intentional, as it breaks my placement system collision detection.
1 Like
Iâll flag this to someone but likely it wonât be changed back. Thanks to floating point error your code should always be robust to small amounts of positional imprecision: âExactly touchingâ isnât a well defined concept in a world based in floating point positions, thereâs always some slop factor one way or the other.
3 Likes
Run/walk/climb behavior is now fully functional for character models with any Scale between 0.1 and 10.
If this refers to the weird sliding that happens when your character is too small⌠it still happens?! Itâs already been 2 weeks, surely this rolled out⌠right?
The use cases in question (intersection welding in a build game, checking if functional parts such as reactors, lasers, engines were clipped into each other) already tolerated minor errors, but the new (unannounced) behavior changes required some pretty invasive changes to those systems to make them work like they did before.
For example, the building games I work on support part surfaces. We use a combination of :MakeJoints() and :GetPartsInPart()-based intersection welding to allow for surface welding, surface joints (hinges), and complex shapes all in one system. With the new behavior of :GetPartsInPart(), parts that are touching are now detected as intersecting. For now weâve reverted to :GetTouchingParts(), but this is much slower, less reliable, and does not use OverlapParams, making it more annoying to restrict what it returns.
Iâm happy the method is now much more performant, but Iâm not particularly excited about the unannounced changes to its behavior. Would it be possible to still have the old functionality under a flag, similar to OverlapParams.BruteForceAllSlow?
Alternatively, the slop factor you mentioned - WorldRoot:ArePartsTouchingOthers() supports a threshold before parts are considered touching. If itâs possible to have this functionality in OverlapParams or wherever it makes the most sense, it would be a good replacement for the old functionality, as developers could tune this threshold to best fit their use cases.
Is there some other change youâre trying to get at here? Because like I said before, there is no hard dividing line between âtouchingâ and âintersectingâ, at the end of the day itâs all just fuzzy thresholds.
I understand that the line between touching and intersecting doesnât really exist. The change Iâm talking about is the behavior of :GetTouchingParts(), which I showed in a screenshot above. Before 576 it did not return parts that were touching the surface (or at least, not very often), and definitely did not return parts that werenât touching at all but were still less than 0.01 studs away from the surface. This was not an issue until 576 released. I posted a chart above showing the expected (pre 576) behavior with all of the cases shown. The expected chart lines up with what was observed in the mentioned building game until 576 released.
1 Like
The new behavior for :GetPartsInPart() is not only too sensitive around normal part shapes, but seemingly ignores the outer parts of meshes. My first thought was this could be a mesh issue with our game (our meshes are pretty janky) but I tested it with various trapezoid meshes I found around the marketplace and they all had the same issue.
Iâve attached both the mesh issue and original chart repro place. Is there any chance we could get a response on this? I understand that thereâs no easily drawn line between touching and intersecting in cases like these, but the previous version of this method seemed to handle those cases reliably enough. All of these test cases worked fine (with the occasional issue, but nothing like this) since the Spatial Query API released 2 years ago, with no noticeable change in behavior until 576.
I listed some potential solutions above: a flag (similar to OverlapParams.BruteForceAllSlow) would let us use the old behavior in cases where it works better (most of them) or alternatively exposing the mentioned slop factor in more methods, or as a property of OverlapParams. A solution would be nice, the alternative is to go back to :GetTouchingParts(), which also handles the above cases just fine, but doesnât have OverlapParams and is generally much slower and less consistent.
GetPartsInPart-repro.rbxl (52.5 KB)
GetPartsInPart-meshes.rbxl (45 KB)
3 Likes
Both issues have been fixed, let us know if you are still experiencing problems.
2 Likes
Fix seems to have worked, everythingâs back to normal and test cases are working as expected. Optimization seems to still be present as well - awesome! Thank you!
@FinnMcNuts @StrongBigeMan9 @funwolf7
Hello,
After discussing internally, our team has decided to revert the deprecation of shiftlock related properties, including EnableMouseLockOption. We will be working on a better approach to provide support for these features in the future.
However, we would like to encourage you to utilize MouseBehavior if you only require mouse lock functionality.
The reversion is expected to take place within the next 1-2 releases.
We apologize for any confusion caused during this period and appreciate your patience.
7 Likes
Great this is just what we needed, I really donât see why you deprecated it in the first place? But whatever, I wont complain.
1 Like