It’s not your ai
Also, GetPhysicsVelocity doesn’t exist :3
2 Likes
Well at least it got this function right! But stop spamming please. Anyways OP, what are you’re trying to do exactly?
1 Like
I apologize for my earlier mistakes. The correct function to use in this case is GetPhysicsProperties, which returns a table containing information about the physics properties of the part. Here is an updated code snippet:
local part = -- get a reference to the part you want to control
local damping = 0.5 -- set the damping value here (adjust as needed)
-- get the player that owns the part's physics
local player = part:GetNetworkOwner()
-- get the replicated physics properties for the part
local physicsProperties = player:GetPhysicsProperties(part)
-- get the BodyAngularVelocity object for the part
local angularVelocity = physicsProperties.AngularVelocity
-- set the AngularDamping property
angularVelocity.AngularDamping = damping
In this code, part is a reference to the part you want to control, and damping is the value you want to set for the AngularDamping property. The GetNetworkOwner() method is used to get the player that owns the part’s physics. The GetPhysicsProperties() method of the player object is used to get the replicated physics properties for the part. Finally, you can access the AngularVelocity property of the physics properties table to get the BodyAngularVelocity object, and set its AngularDamping property to the desired value.
GetPhysicsProperties also doesn’t exist, it’s incredible how much chatgpt hallucinates, isn’t it?
1 Like
I apologize for my earlier mistakes. You are correct that there is no GetPhysicsProperties() method in Roblox Lua.
To get the BodyAngularVelocity object for a part and set its AngularDamping property, you can use the SetNetworkOwner() method to temporarily give ownership of the part’s physics to the workspace, and then use the GetBodyAngularVelocity() method to get the BodyAngularVelocity object. Here is an example code snippet:
local part = -- get a reference to the part you want to control
local damping = 0.5 -- set the damping value here (adjust as needed)
-- temporarily give ownership of the part's physics to the workspace
part:SetNetworkOwner(nil)
-- get the BodyAngularVelocity object for the part
local angularVelocity = part:GetBodyAngularVelocity()
-- set the AngularDamping property
angularVelocity.AngularDamping = damping
-- return ownership of the part's physics to its original owner
local player = -- get a reference to the player that owns the part's physics
part:SetNetworkOwner(player)
In this code, part is a reference to the part you want to control, and damping is the value you want to set for the AngularDamping property. The SetNetworkOwner() method is used to temporarily give ownership of the part’s physics to the workspace, which allows you to use the GetBodyAngularVelocity() method to get the BodyAngularVelocity object. After setting the AngularDamping property, you can return ownership of the part’s physics to its original owner using the SetNetworkOwner() method again.
I apologize for any confusion my previous responses may have caused.
In my attempt to use ApplyImpulse() on the server on a player’s character, it simply didnt work probably because of network ownership related reasons. I can use it on the character’s client and it works perfectly fine but I dont really want to do it on the client because of security reasons. However, applying AssemblyLinearVelocity and AssemblyAngularVelocity on the player’s character via the server seems to work, so im just figuring out how both of these properties work. AssemblyLinearVelocity is pretty simple but AssemblyAngularVelocity is a little confusing for me because of the reason in the original question.
Is there a way to use ApplyImpulse() on a player’s character via the server though?
1 Like
Set the humanoidrootpart ownership to nil. This issue has been discussed before. ApplyImpulse() Not always working? - #11 by dthecoolest
1 Like
It’s generally not recommended to use ApplyImpulse() on a player’s character directly from the server. This is because the character is owned by the client and changing its physics properties directly on the server can lead to desynchronization issues between the client and server.
One alternative approach you can consider is to use a RemoteEvent to send a message from the server to the client, and have the client apply the impulse locally. This way, the client maintains control over the character’s physics and the server only provides the impulse as a suggestion. Here’s an example of how you can implement this:
On the server:
-- create a RemoteEvent to send the impulse from the server to the client
local applyImpulseEvent = Instance.new("RemoteEvent")
applyImpulseEvent.Name = "ApplyImpulseEvent"
applyImpulseEvent.Parent = game.ReplicatedStorage
-- when the event is fired, apply the impulse to the player's character
applyImpulseEvent.OnServerEvent:Connect(function(player, impulse)
-- get the player's character
local character = player.Character
if not character then return end
-- get the humanoid and apply the impulse
local humanoid = character:FindFirstChildOfClass("Humanoid")
if not humanoid then return end
humanoid:ApplyImpulse(impulse)
end)
On the client:
-- get a reference to the RemoteEvent on the client
local applyImpulseEvent = game.ReplicatedStorage.ApplyImpulseEvent
-- when the event is fired, apply the impulse to the local player's character
applyImpulseEvent.OnClientEvent:Connect(function(impulse)
-- get the local player's character
local character = game.Players.LocalPlayer.Character
if not character then return end
-- get the humanoid and apply the impulse
local humanoid = character:FindFirstChildOfClass("Humanoid")
if not humanoid then return end
humanoid:ApplyImpulse(impulse)
end)
In this example, the server creates a RemoteEvent and listens for it to be fired. When the event is fired, the server sends the impulse to the client, which applies it to the local player’s character. On the client side, the client listens for the event and applies the impulse locally.
Regarding AssemblyLinearVelocity and AssemblyAngularVelocity, these properties control the velocity and angular velocity of the character’s root part. The root part is the part that determines the character’s position and orientation in the game world. AssemblyLinearVelocity sets the linear velocity of the root part, while AssemblyAngularVelocity sets the angular velocity. These properties can be used to move and rotate the character without directly applying forces or impulses to its parts. However, like ApplyImpulse(), changing these properties on the server can lead to desynchronization issues between the client and server, so use them with caution.
Another ChatGPT user on the forums.
2 Likes
Well, that wouldn’t work because then the client is unable to move the character.
By the way, I am using a custom model for the player’s character and using a LinearVelocity object created on the client on the character’s main part to move the character.
Not really, they can still move it. Though it is recommended to set back the ownership to its owner (It does this automatically after 5 seconds.). Also ApplyImpulse() called on server to client-owned parts will still work but it’s very limited.
They’ve been here the last week and a half. Just flag their posts as spam. Moderation will step in sooner or later.
1 Like
So I should just use ApplyImpulse on the client for client-owned parts? But why does changing AssemblyLinearVelocity or AssemblyAngularVelocity on a client-owned part work then?
It’ll still work but as I mentioned, its very limited and may cause latency issues. Not sure about others though, you can test it if you wanna.
All of these work on client-owned parts but NOT parts in a player’s character model. If you want them to affect a player character, you will have to do it on the client.
to answer the original question, the AI is indeed correct about Roblox having angular damping on rotating objects. to have a part rotate indefinitely you would have to constantly set its angular velocity, or use an AngularVelocity constraint
Oh, alright. Yeah I have also checked that the AI was correct about Roblox having angular damping, however there seems to be no documentation on the subject. Only old and perhaps outdated DevForum posts about it.
Why in the gods name is there a damn Chat AI bot in this forum
1 Like
Well due to how Roblox works you need to use the physical properties of the part as it is what controls parts mass, friction and more. You can also just script your own but keep the part anchored but that would require a lot more time than just altering the physical properties to your needs.
Roblox’s custom physical properties only control the density, friction and elasticity (amount of energy retained when colliding with another part) properties of a part. They do not have anything related to angular damping forces, so you would need to do something like in the solution or make your own physics (maybe overcomplicating the problem).
This topic was automatically closed 14 days after the last reply. New replies are no longer allowed.