Shock absorbers !!

298 views

There is always something new to learn, and when my native language is not English, there is a way of learning called brute force, this leads to two things, first, you learn, and second a high percentage is learning to do things wrong, of course not always.

Today I had a kind of Eureka, I actually discovered how to properly implement the sliding joints to create springs for a vehicle, the point here is to get to understand how this should work and I think I've achieved it. In the end I'm left with the doubt of whether I have a learning disability, because torture is the same as always, trial and error.

Translated with www.DeepL.com/Translator

So I expose the code to recreate the shock absorbers, it should be noted that only I understand this, because I do not give any explanation regarding the case, but it works.

```cVehicle={}

function cVehicle:New()

local this = {}

this.mesh = {}

this.mesh.chassis     = nil

--## pivots Springs.
this.mesh.SpringFL    = nil
this.mesh.SpringFR    = nil
this.mesh.SpringBL    = nil
this.mesh.SpringBR    = nil

--## Meshs Wheels.
this.mesh.WheelFL    = nil
this.mesh.WheelFR    = nil
this.mesh.WheelBL    = nil
this.mesh.WheelBR    = nil

--## Meshs Axles Dir.
this.mesh.AxleL      = nil
this.mesh.AxleR      = nil

--## Motor Springs.
this.motorSprings={}
this.motorSprings.force = 300
this.motorSprings.limits={}
this.motorSprings.limits.Down = -0.5
this.motorSprings.limits.Up = 0.5
this.posSprings={}

function this:StartSystem( springs, wheels, axles, chassis)

self.mesh.chassis   = chassis

self.mesh.SpringFL 	= springs[0]
self.mesh.SpringFR 	= springs[1]
self.mesh.SpringBL 	= springs[2]
self.mesh.SpringBR 	= springs[3]

self.mesh.WheelFL  	= wheels[0]
self.mesh.WheelFR  	= wheels[1]
self.mesh.WheelBL  	= wheels[2]
self.mesh.WheelBR  	= wheels[3]

self.mesh.AxleL		= axles[0]
self.mesh.AxleR		= axles[1]

self:StartMotorSprings()

end

function this:StartMotorSprings()

self.posSprings[0] = self.mesh.SpringFL:GetPosition(true)

self.motorSprings[0] = Joint:Slider( self.posSprings[0].x,self.posSprings[0].y,self.posSprings[0].z, 0,1,0,self.mesh.SpringFL, self.mesh.chassis )
self.motorSprings[0]:EnableLimits()
self.motorSprings[0]:SetLimits( self.motorSprings.limits.Down, self.motorSprings.limits.Up)
self.motorSprings[0]:SetSpring( this.motorSprings.force )

self.posSprings[1] = self.mesh.SpringFR:GetPosition(true)

self.motorSprings[1] = Joint:Slider( self.posSprings[1].x,self.posSprings[1].y,self.posSprings[1].z, 0,1,0,self.mesh.SpringFR, self.mesh.chassis )
self.motorSprings[1]:EnableLimits()
self.motorSprings[1]:SetLimits( self.motorSprings.limits.Down, self.motorSprings.limits.Up )
self.motorSprings[1]:SetSpring( this.motorSprings.force )

self.posSprings[2] = self.mesh.SpringBL:GetPosition(true)

self.motorSprings[2] = Joint:Slider( self.posSprings[2].x,self.posSprings[2].y,self.posSprings[2].z, 0,1,0,self.mesh.SpringBL, self.mesh.chassis )
self.motorSprings[2]:EnableLimits()
self.motorSprings[2]:SetLimits( self.motorSprings.limits.Down, self.motorSprings.limits.Up )
self.motorSprings[2]:SetSpring( this.motorSprings.force )

self.posSprings[3] = self.mesh.SpringBR:GetPosition(true)

self.motorSprings[3] = Joint:Slider( self.posSprings[3].x,self.posSprings[3].y,self.posSprings[3].z, 0,1,0,self.mesh.SpringBR, self.mesh.chassis )
self.motorSprings[3]:EnableLimits()
self.motorSprings[3]:SetLimits( self.motorSprings.limits.Down, self.motorSprings.limits.Up )
self.motorSprings[3]:SetSpring( this.motorSprings.force )

end

function this:Update()

if Window:GetCurrent():KeyDown(Key.J) then

end

end

return this
end```

And there's still the question of whether this is well implemented, but I guess I've learned something new.

• 2

There are no comments to display.

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

×   Pasted as rich text.   Paste as plain text instead

Only 75 emoji are allowed.