Saturday, November 21, 2026
HomeiOS Developmentios - Sprite Equipment the way to apply boundaries

ios – Sprite Equipment the way to apply boundaries

[ad_1]

I’m at the moment new for sprite package and I’m very confused my participant goes all the best way proper exterior of the body, nevertheless I’ve included this a part of code

 let body = SKPhysicsBody(edgeLoopFrom: self.body)
    body.friction = 0
    body.restitution = 1
    body.categoryBitMask = bitMask.body.rawValue
    body.contactTestBitMask = bitMask.participant.rawValue
    body.collisionBitMask = bitMask.participant.rawValue
    self.physicsBody = body

The total code is bellow

class GameScene : SKScene, SKPhysicsContactDelegate {


let background = SKSpriteNode(imageNamed: "bg")
let participant = SKSpriteNode(imageNamed: "PlayerJump")
let floor = SKSpriteNode(imageNamed: "floor")
let gameOverLine = SKSpriteNode(shade: .purple, dimension: CGSize(width: 900, peak: 10))
let rightBorderLine = SKSpriteNode(shade: .purple, dimension: CGSize(width: 10, peak: 900))
let scoreLabel = SKLabelNode()
let bestScoreLabel = SKLabelNode()
let defaults = UserDefaults.customary
let cam = SKCameraNode()
let motionManager = CMMotionManager()

var firstTouch = false
var rating = 0
var bestScore = 0
var multi: CGFloat = 0.0

enum bitMask: UInt32 {
    case participant = 0b1
    case platform = 0b10
    case gameOverLine
    case body
}

override func didMove(to view: SKView) {
    self.dimension = CGSize(width: UIScreen.major.bounds.width * 2, peak: UIScreen.major.bounds.peak * 2)
    
    self.anchorPoint = .zero
    
    background.place = CGPoint(x: dimension.width / 2, y: dimension.peak / 2)
    background.zPosition = 1
    addChild(background)
    
    physicsWorld.contactDelegate = self
    
    floor.place = CGPoint(x: dimension.width / 2, y: 10)
    floor.zPosition = 5
    floor.setScale(2.5)
    floor.physicsBody = SKPhysicsBody(rectangleOf: floor.dimension)
    floor.physicsBody?.isDynamic = false
    floor.physicsBody?.allowsRotation = false
    floor.physicsBody?.affectedByGravity = false
    addChild(floor)
    
    
    participant.place = CGPoint(x: dimension.width / 2, y: dimension.peak/8)
    participant.zPosition = 10
    participant.setScale(1.8)
    participant.physicsBody = SKPhysicsBody(circleOfRadius: participant.dimension.peak / 2)
    participant.physicsBody?.isDynamic = false
    participant.physicsBody?.restitution = 1
    participant.physicsBody?.friction = 0
    participant.physicsBody?.angularDamping = 1
    participant.physicsBody?.categoryBitMask = bitMask.participant.rawValue
    participant.physicsBody?.collisionBitMask = 0
    participant.physicsBody?.contactTestBitMask = bitMask.platform.rawValue | bitMask.gameOverLine.rawValue
//        participant.physicsBody = SKPhysicsBody(edgeLoopFrom: self.body)
        addChild(participant)
    
    
    gameOverLine.place = CGPoint(x: participant.place.x, y: participant.place.y - 240)
    gameOverLine.zPosition = -1
    gameOverLine.physicsBody = SKPhysicsBody(rectangleOf: gameOverLine.dimension)
    gameOverLine.physicsBody?.affectedByGravity = false
    gameOverLine.physicsBody?.allowsRotation = false
    gameOverLine.physicsBody?.categoryBitMask = bitMask.gameOverLine.rawValue
    gameOverLine.physicsBody?.contactTestBitMask = bitMask.platform.rawValue | bitMask.participant.rawValue
    addChild(gameOverLine)
    
    
    
    scoreLabel.place.x = 125
    scoreLabel.zPosition = 20
    scoreLabel.fontColor = .black
    scoreLabel.fontSize = 32
    scoreLabel.fontName = "Helvectica"
    scoreLabel.textual content = "Rating: (rating)"
    addChild(scoreLabel)
    
    
    bestScore = defaults.integer(forKey: "finest")
    bestScoreLabel.place.x = 625
    bestScoreLabel.zPosition = 20
    bestScoreLabel.fontColor = .black
    bestScoreLabel.fontSize = 32
    bestScoreLabel.fontName = "Helvectica"
    bestScoreLabel.textual content = "Bestscore: (bestScore)"
    addChild(bestScoreLabel)
    
    
    makePlatform()
    makePlatform2()
    makePlatform3()
    makePlatform4()
    makePlatform5()
    makePlatform6()
    
//        if motionManager.isAccelerometerActive == true {
//            motionManager.accelerometerUpdateInterval = 20/60
//
//            motionManager.startAccelerometerUpdates(to: OperationQueue()) { knowledge, error in
//
//                self.multi = Float(knowledge!.acceleration.x) * 10
//                self.participant.place = CGPoint(x: self.participant.place.x + CGFloat(self.multi), y: self.participant.place.y)
//            }
//        }
    
    if motionManager.isAccelerometerAvailable {
        motionManager.accelerometerUpdateInterval = 0.10
          motionManager.startAccelerometerUpdates(to: .major) {
              (knowledge, error) in
              guard let knowledge = knowledge, error == nil else {
                  return
              }
              
              let currentX = self.participant.place.x
              self.multi = currentX + CGFloat(knowledge.acceleration.x * 1300)
          }
      }
    
    let body = SKPhysicsBody(edgeLoopFrom: self.body)
    body.friction = 0
    body.restitution = 1
    body.categoryBitMask = bitMask.body.rawValue
    body.contactTestBitMask = bitMask.participant.rawValue
    body.collisionBitMask = bitMask.participant.rawValue
    self.physicsBody = body
    
    cam.setScale(3)
    cam.place.x = participant.place.x
    digital camera = cam
    
    
    
}

override func replace(_ currentTime: TimeInterval) {
    cam.place.y = participant.place.y + 350
    
    background.place.y = participant.place.y
    
    if participant.physicsBody!.velocity.dy > 0 {
        gameOverLine.place.y = participant.place.y - 600
    }
    
    scoreLabel.place.y = participant.place.y + 1050
    bestScoreLabel.place.y = participant.place.y + 1050
    
    let motion = SKAction.moveTo(x: multi, length: 1)
       participant.run(motion)
    
}


func didBegin(_ contact: SKPhysicsContact) {
    let contactA: SKPhysicsBody
    let contactB: SKPhysicsBody
    
    if contact.bodyA.categoryBitMask < contact.bodyB.categoryBitMask {
        contactA = contact.bodyA //Participant
        contactB = contact.bodyB //Platform
    } else {
        contactA = contact.bodyB //Participant
        contactB = contact.bodyA //Platform
    }
    
    if contactA.categoryBitMask == bitMask.platform.rawValue && contactB.categoryBitMask == bitMask.gameOverLine.rawValue {
        contactA.node?.removeFromParent()
    }
    
    
    if contactA.categoryBitMask == bitMask.participant.rawValue && contactB.categoryBitMask == bitMask.platform.rawValue {
        if participant.physicsBody!.velocity.dy < 0 {
            participant.physicsBody?.velocity = CGVector(dx: participant.physicsBody!.velocity.dx, dy: 1400)
            contactB.node?.removeFromParent()
            makePlatform5()
            makePlatform6()
            addScore()
        }
    }
    
    if contactA.categoryBitMask == bitMask.participant.rawValue && contactB.categoryBitMask == bitMask.gameOverLine.rawValue {
        gameOver()
    }
}



//    override func touchesMoved(_ touches: Set<UITouch>, with occasion: UIEvent?) {
//        for contact in touches {
//            let location = contact.location(in: self)
//
//            participant.place.x = location.x
//        }
//    }

override func touchesEnded(_ touches: Set<UITouch>, with occasion: UIEvent?) {
    participant.physicsBody?.isDynamic = true
    
    if firstTouch == false {
    participant.physicsBody?.applyImpulse(CGVector(dx: 0, dy: 1800))
    }
    firstTouch = true
}


func makePlatform() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 140, highestValue: 300).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func makePlatform2() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 350, highestValue: 550).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func makePlatform3() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 600, highestValue: 800).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func makePlatform4() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 850, highestValue: 1050).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func makePlatform5() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 1100, highestValue: 1300).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func makePlatform6() {
    let platform = SKSpriteNode(imageNamed: "floor")
    platform.place = CGPoint(x: GKRandomDistribution(lowestValue: 70, highestValue: 700).nextInt(), y: GKRandomDistribution(lowestValue: 1350, highestValue: 1550).nextInt() + Int(participant.place.y))
    platform.zPosition = 5
    platform.setScale(0.30)
    platform.physicsBody = SKPhysicsBody(rectangleOf: platform.dimension)
    platform.physicsBody?.isDynamic = false
    platform.physicsBody?.allowsRotation = false
    platform.physicsBody?.affectedByGravity = false
    platform.physicsBody?.categoryBitMask = bitMask.platform.rawValue
    platform.physicsBody?.collisionBitMask = 0
    platform.physicsBody?.contactTestBitMask = bitMask.participant.rawValue
    
    addChild(platform)

}

func gameOver() {
    
    let gameOverScene = GameOverScene(dimension: self.dimension)
    let transition = SKTransition.crossFade(withDuration: 0.5)
    
    view?.presentScene(gameOverScene, transition: transition)
    
    if rating > bestScore {
        bestScore = rating
        
        defaults.set(bestScore, forKey: "finest")
    }
    
}

func addScore() {
    rating += 1
    scoreLabel.textual content = "Rating: (rating)"
}    
}

[ad_2]

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments