Sprite Kit - Spring Joints (shock absorber)

Question

Frist off, thank you @Smick for the initial vehicle code as posted here: Sprite Kit pin joints appear to have an incorrect anchor

I'm trying to add a slide joint between the wheel (left wheel) and chassis, along with a spring joint in order to create a shock absorbing effect.

With my code below, I get no compression. I realize the documentation shows a spring joint pulling two bodes together - the reverse of what I want. Is this possible in SK?

I think the pin joint may be the culprit? When I comment out the pin joint, the car parts go haywire - everything flies around the screen. Originally, the pin joint pinned the wheel to the chassis, but obviously I want to pin the wheel to the "shock absorber".

Also, the "axis" argument for SKPhysicsJointSliding has me a bit confused. It wants a vector. A vector relative to?

Thank you in advance.

- (SKShapeNode*) makeWheel
{
SKShapeNode *wheel = [[SKShapeNode alloc] init];
CGMutablePathRef myPath = CGPathCreateMutable();
CGPathAddArc(myPath, NULL, 0,0, 16, 0, M_PI*2, YES);
wheel.path = myPath;
wheel.physicsBody.mass = 0.5;
return wheel;
}

- (void) createCar{

// 1. car body
SKSpriteNode *carBody = [SKSpriteNode spriteNodeWithColor:[UIColor whiteColor] size:CGSizeMake(120, 8)];
carBody.position = CGPointMake(200, 700);
carBody.physicsBody = [SKPhysicsBody bodyWithRectangleOfSize:carBody.size];
carBody.physicsBody.mass = 1.0;
[self addChild:carBody];

// 2. wheels
SKShapeNode *leftWheel = [self makeWheel];
leftWheel.position = CGPointMake(carBody.position.x - carBody.size.width / 2, carBody.position.y-40);
leftWheel.physicsBody = [SKPhysicsBody bodyWithCircleOfRadius:16];
[self addChild:leftWheel];

SKShapeNode *rightWheel = [self makeWheel];
rightWheel.position = CGPointMake(carBody.position.x + carBody.size.width / 2, carBody.position.y);
rightWheel.physicsBody = [SKPhysicsBody bodyWithCircleOfRadius:16];
[self addChild:rightWheel];


/* Build left shock absorber and attach wheel */

CGVector av =CGVectorMake(0.0, 5.0);

SKPhysicsJointSliding *leftSlide = [SKPhysicsJointSliding    jointWithBodyA:carBody.physicsBody
                                                                    bodyB:leftWheel.physicsBody
                                                                  anchor:leftWheel.position
                                                                    axis:av];


SKPhysicsJointSpring *leftSpring = [SKPhysicsJointSpring  jointWithBodyA:carBody.physicsBody bodyB:leftWheel.physicsBody
                                                                anchorA:CGPointMake(carBody.position.x - carBody.size.width / 2, carBody.position.y)
                                                            anchorB:leftWheel.position];



SKPhysicsJointPin *leftPin = [SKPhysicsJointPin jointWithBodyA:leftSpring.bodyA
                                                        bodyB:leftSpring.bodyB
                                                        anchor:leftWheel.position];


[self.physicsWorld addJoint:leftSlide];
[self.physicsWorld addJoint:leftSpring];
[self.physicsWorld addJoint:leftPin];

[self.physicsWorld addJoint:[SKPhysicsJointPin jointWithBodyA:carBody.physicsBody     bodyB:rightWheel.physicsBody anchor:rightWheel.position]];

}

score 8 · Accepted Answer · 2013-12-08T04:40:44.677

Editing my answer. The suspension requires the wheels to be attached to a sliding body versus attaching the wheels via the slide joint. Doing the former allows wheels to rotate. The latter does not.

Vehicle.m

#import "Vehicle.h"

@implementation Vehicle

- (SKSpriteNode*) makeWheel
{
    SKSpriteNode *wheel = [SKSpriteNode spriteNodeWithImageNamed:@"wheel.png"];
//    wheel.physicsBody = [SKPhysicsBody bodyWithCircleOfRadius:wheel.size.width/2];
    return wheel;
}

-(id)initWithPosition:(CGPoint)pos {

    if (self = [super init]) {

        _joints = [NSMutableArray array];

        int wheelOffsetY    =   60;
        CGFloat damping     =   1;
        CGFloat frequency   =   4;

        SKSpriteNode *chassis = [SKSpriteNode spriteNodeWithColor:[UIColor whiteColor] size:CGSizeMake(120, 8)];
        chassis.position = pos;
        chassis.physicsBody = [SKPhysicsBody bodyWithRectangleOfSize:chassis.size];
        [self addChild:chassis];

        _ctop = [SKSpriteNode spriteNodeWithColor:[UIColor greenColor] size:CGSizeMake(70, 16)];
        _ctop.position = CGPointMake(chassis.position.x+20, chassis.position.y+12);
        _ctop.physicsBody = [SKPhysicsBody bodyWithRectangleOfSize:_ctop.size];
        [self addChild:_ctop];

        SKPhysicsJointFixed *cJoint = [SKPhysicsJointFixed jointWithBodyA:chassis.physicsBody
                                                                    bodyB:_ctop.physicsBody
                                                                   anchor:CGPointMake(_ctop.position.x, _ctop.position.y)];


        _leftWheel = [self makeWheel];
        _leftWheel.position = CGPointMake(chassis.position.x - chassis.size.width / 2, chassis.position.y - wheelOffsetY);  //Always set position before physicsBody
        _leftWheel.physicsBody = [SKPhysicsBody bodyWithCircleOfRadius:_leftWheel.size.width/2];
        _leftWheel.physicsBody.allowsRotation = YES;
        [self addChild:_leftWheel];

        SKSpriteNode *rightWheel = [self makeWheel];
        rightWheel.position = CGPointMake(chassis.position.x + chassis.size.width / 2, chassis.position.y - wheelOffsetY);
        rightWheel.physicsBody = [SKPhysicsBody bodyWithCircleOfRadius:rightWheel.size.width/2];
        rightWheel.physicsBody.allowsRotation = YES;
        [self addChild:rightWheel];

//------------- LEFT SUSPENSION ----------------------------------------------------------------------------------------------- //

        SKSpriteNode *leftShockPost = [SKSpriteNode spriteNodeWithColor:[UIColor blueColor] size:CGSizeMake(7, wheelOffsetY)];
        leftShockPost.position = CGPointMake(chassis.position.x - chassis.size.width / 2, chassis.position.y - leftShockPost.size.height/2);
        leftShockPost.physicsBody = [SKPhysicsBody bodyWithRectangleOfSize:leftShockPost.size];
        [self addChild:leftShockPost];

       SKPhysicsJointSliding  *leftSlide = [SKPhysicsJointSliding jointWithBodyA:chassis.physicsBody
                                                                           bodyB:leftShockPost.physicsBody
                                                    anchor:CGPointMake(leftShockPost.position.x, leftShockPost.position.y)
                                                      axis:CGVectorMake(0, 1)];

        leftSlide.shouldEnableLimits = TRUE;
        leftSlide.lowerDistanceLimit = 5;
        leftSlide.upperDistanceLimit = wheelOffsetY;


        SKPhysicsJointSpring *leftSpring = [SKPhysicsJointSpring jointWithBodyA:chassis.physicsBody bodyB:_leftWheel.physicsBody
                                                                        anchorA:CGPointMake(chassis.position.x - chassis.size.width / 2, chassis.position.y)
                                                                        anchorB:_leftWheel.position];
        leftSpring.damping = damping;
        leftSpring.frequency = frequency;

        SKPhysicsJointPin *lPin = [SKPhysicsJointPin jointWithBodyA:leftShockPost.physicsBody bodyB:_leftWheel.physicsBody anchor:_leftWheel.position];


//------------- RIGHT SUSPENSION ----------------------------------------------------------------------------------------------- //

        SKSpriteNode *rightShockPost = [SKSpriteNode spriteNodeWithColor:[UIColor blueColor] size:CGSizeMake(7, wheelOffsetY)];
        rightShockPost.position = CGPointMake(chassis.position.x + chassis.size.width / 2, chassis.position.y - rightShockPost.size.height/2);
        rightShockPost.physicsBody = [SKPhysicsBody bodyWithRectangleOfSize:rightShockPost.size];
        [self addChild:rightShockPost];

        SKPhysicsJointSliding  *rightSlide = [SKPhysicsJointSliding jointWithBodyA:chassis.physicsBody
                                                                            bodyB:rightShockPost.physicsBody
                                                                           anchor:CGPointMake(rightShockPost.position.x, rightShockPost.position.y)
                                                                             axis:CGVectorMake(0, 1)];

        rightSlide.shouldEnableLimits = TRUE;
        rightSlide.lowerDistanceLimit = 5;
        rightSlide.upperDistanceLimit = wheelOffsetY;


        SKPhysicsJointSpring *rightSpring = [SKPhysicsJointSpring jointWithBodyA:chassis.physicsBody bodyB:rightWheel.physicsBody
                                                                        anchorA:CGPointMake(chassis.position.x + chassis.size.width / 2, chassis.position.y)
                                                                        anchorB:rightWheel.position];
        rightSpring.damping = damping;
        rightSpring.frequency = frequency;

        SKPhysicsJointPin *rPin = [SKPhysicsJointPin jointWithBodyA:rightShockPost.physicsBody bodyB:rightWheel.physicsBody anchor:rightWheel.position];


        // Add all joints to the array.

        [_joints addObject:cJoint];

        [_joints addObject:leftSlide];
        [_joints addObject:leftSpring];
        [_joints addObject:lPin];

        [_joints addObject:rightSlide];
        [_joints addObject:rightSpring];
        [_joints addObject:rPin];

    }

    return self;
}


@end

jglasse · Answer 2 · 2017-03-10T23:03:02.240

I took the liberty of converting Jeremiah's code into swift for testing in a playground - which I find invaluable for working with spritekit. No new functionality; just translated to swift and modified to run in a playground:

Now updated for Swift 3. Because I care.

import Foundation
import SpriteKit
import PlaygroundSupport

let view:SKView = SKView(frame: CGRect(x: 0, y: 0, width: 1024, height: 768))
PlaygroundPage.current.liveView = view

let scene = SKScene(size: CGSize(width: 1024, height: 768))
scene.name = "PlaygroundScene"
scene.physicsWorld.gravity =  CGVector()
scene.scaleMode = SKSceneScaleMode.aspectFill

var vehicle = SKNode()

var joints = [SKPhysicsJoint]()
let wheelOffsetY:CGFloat    =   60;
let damping:CGFloat     =   1;
let frequency :CGFloat    =   4;

let chassis = SKSpriteNode.init(color: UIColor.white, size: CGSize(width: 120, height: 8))
chassis.position = CGPoint(x: scene.size.width/2, y: scene.size.height/2)
chassis.physicsBody =  SKPhysicsBody.init(rectangleOf: chassis.size)
vehicle.addChild(chassis)


let ctop = SKSpriteNode.init(color: UIColor.green, size: CGSize(width: 70, height: 16))

ctop.position = CGPoint(x: chassis.position.x+20, y: chassis.position.y+12)
ctop.physicsBody = SKPhysicsBody.init(rectangleOf: ctop.size)
vehicle.addChild(ctop)



let cJoint = SKPhysicsJointFixed.joint(withBodyA: chassis.physicsBody!, bodyB: ctop.physicsBody!, anchor: CGPoint(x: ctop.position.x, y: ctop.position.y))



let leftWheel = SKSpriteNode(imageNamed: "wheel.png")
leftWheel.position = CGPoint(x: chassis.position.x - chassis.size.width / 2, y: chassis.position.y - wheelOffsetY)  //Always set position before physicsBody
leftWheel.physicsBody = SKPhysicsBody(circleOfRadius: leftWheel.size.width/2)
leftWheel.physicsBody!.allowsRotation = true;
vehicle.addChild(leftWheel)


let rightWheel = SKSpriteNode(imageNamed: "wheel.png")
rightWheel.position = CGPoint(x: chassis.position.x + chassis.size.width / 2, y: chassis.position.y - wheelOffsetY)  //Always set position before physicsBody
rightWheel.physicsBody = SKPhysicsBody(circleOfRadius: leftWheel.size.width/2)
rightWheel.physicsBody!.allowsRotation = true;
vehicle.addChild(rightWheel)


//--------------------- LEFT SUSPENSION ---------------------- //

let leftShockPost = SKSpriteNode(color: UIColor.blue, size:CGSize(width:7, height: wheelOffsetY))

leftShockPost.position = CGPoint(x:chassis.position.x - chassis.size.width / 2, y: chassis.position.y - leftShockPost.size.height/2)

leftShockPost.physicsBody = SKPhysicsBody(rectangleOf: leftShockPost.size)
vehicle.addChild(leftShockPost)

let leftSlide = SKPhysicsJointSliding.joint(withBodyA: chassis.physicsBody!, bodyB: leftShockPost.physicsBody!, anchor:CGPoint(x:leftShockPost.position.x, y: leftShockPost.position.y), axis:CGVector(dx: 0.0, dy: 1.0))


leftSlide.shouldEnableLimits = true;
leftSlide.lowerDistanceLimit = 5;
leftSlide.upperDistanceLimit = wheelOffsetY;


let leftSpring = SKPhysicsJointSpring.joint(withBodyA: chassis.physicsBody!, bodyB: leftWheel.physicsBody!, anchorA: CGPoint(x:chassis.position.x - chassis.size.width / 2, y: chassis.position.y), anchorB: leftWheel.position)


leftSpring.damping = damping;
leftSpring.frequency = frequency;

let lPin = SKPhysicsJointPin.joint(withBodyA: leftShockPost.physicsBody!, bodyB:leftWheel.physicsBody!, anchor:leftWheel.position)


//--------------------- Right SUSPENSION ---------------------- //

let rightShockPost = SKSpriteNode(color: UIColor.blue, size:CGSize(width: 7, height: wheelOffsetY) )

rightShockPost.position = CGPoint(x:chassis.position.x + chassis.size.width / 2, y: chassis.position.y - rightShockPost.size.height/2)

rightShockPost.physicsBody = SKPhysicsBody(rectangleOf: rightShockPost.size)
vehicle.addChild(rightShockPost)

let rightSlide = SKPhysicsJointSliding.joint(withBodyA: chassis.physicsBody!, bodyB: rightShockPost.physicsBody!, anchor:CGPoint(x:rightShockPost.position.x, y: rightShockPost.position.y), axis:CGVector(dx: 0.0, dy: 1.0))


rightSlide.shouldEnableLimits = true;
rightSlide.lowerDistanceLimit = 5;
rightSlide.upperDistanceLimit = wheelOffsetY;


let rightSpring = SKPhysicsJointSpring.joint(withBodyA: chassis.physicsBody!, bodyB: rightWheel.physicsBody!, anchorA: CGPoint(x: chassis.position.x - chassis.size.width / 2, y: chassis.position.y), anchorB: rightWheel.position)


rightSpring.damping = damping;
rightSpring.frequency = frequency;

let rPin = SKPhysicsJointPin.joint(withBodyA: leftShockPost.physicsBody!, bodyB:rightWheel.physicsBody!, anchor:rightWheel.position)


// Add all joints to the array.

joints.append(cJoint)
joints.append(leftSlide)
joints.append(leftSpring)
joints.append(rightSlide)
joints.append(rightSpring)
joints.append(rPin)


scene.addChild(vehicle)
view.presentScene(scene)

score 1 · Answer 3 · answered May 26 '16 at 20:18

No compression in your springs? One culprit is using the default frequency of 0.0. Increase frequency to, say, 9.0, and change nothing else, and I suspect you will see some desired compression.

It is useful to think of frequency as a measure of the spring's "stiffness". Higher frequency means a stiffer spring. A frequency of 0.0001 is very, very loose! However, this logic breaks down at the default frequency of 0.0. At frequency == 0.0, the spring is entirely rigid and non-compressive.

Sprite Kit - Spring Joints (shock absorber)

3 Answers3