Sprite Kit - Xuân khớp (giảm xóc)

Question

Frist tắt, cảm ơn bạn @Smick cho mã xe ban đầu như được đăng ở đây: Sprite Kit pin joints appear to have an incorrect anchor

Tôi đang cố gắng để thêm một phần trượt giữa bánh xe (bánh trái) và khung gầm, cùng với khớp nối lò xo để tạo hiệu ứng giảm chấn.

Với mã của tôi bên dưới, tôi không bị nén. Tôi nhận ra các tài liệu cho thấy một khớp mùa xuân kéo hai bodes với nhau - đảo ngược những gì tôi muốn. Điều này có thể xảy ra ở SK không?

Tôi nghĩ rằng khớp nối pin có thể là thủ phạm? Khi tôi nhận xét ra khớp nối pin, các bộ phận xe hơi đi haywire - tất cả mọi thứ bay xung quanh màn hình. Ban đầu, khớp nối pin gắn bánh xe vào khung xe, nhưng rõ ràng là tôi muốn ghim bánh xe vào bộ giảm xóc.

Ngoài ra, đối số "trục" cho SKPhysicsJointSliding khiến tôi hơi bối rối. Nó muốn một vector. Một vector liên quan đến?

Cảm ơn bạn trước.

- (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]]; 

}

Answer 1

Chỉnh sửa câu trả lời của tôi. Việc đình chỉ đòi hỏi các bánh xe được gắn vào một cơ thể trượt so với gắn các bánh xe thông qua khớp trượt. Làm trước cho phép bánh xe quay. Sau này thì không.

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 

Answer 2

tôi lấy sự tự do của chuyển đổi mã Jeremiah của thành nhanh chóng để thử nghiệm trong một sân chơi - mà tôi thấy vô giá để làm việc với spritekit. Không có chức năng mới; vừa được dịch sang nhanh chóng và sửa đổi để chạy trong sân chơi:

Cập nhật cho Swift 3. Vì tôi quan tâm.

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) 

Answer 3

Không nén trong lò xo của bạn? Một thủ phạm đang sử dụng mặc định frequency của 0.0. Tăng frequency lên, giả sử, 9.0 và không thay đổi gì khác và tôi nghi ngờ bạn sẽ thấy một số nén mong muốn.

Thật hữu ích khi nghĩ đến số frequency làm thước đo "độ cứng" của lò xo. Cao hơn frequency có nghĩa là một mùa xuân cứng hơn. A frequency của 0.0001 rất, rất lỏng lẻo! Tuy nhiên, logic này bị hỏng theo mặc định frequency của 0.0. Tại frequency == 0.0, mùa xuân là hoàn toàn cứng nhắc và không nén.