2022年8月

TappedNodes

import SpriteKit
import GameplayKit


class GameScene: SKScene {
  let label = SKLabelNode(fontNamed: "HelveticaNeue-Light")
  let button = SKSpriteNode(imageNamed: "blue2.png")
  let button2 = SKLabelNode(text: "Button")
 var n = 0
 let label2 = SKLabelNode(text: "kaisu: 0kai")  

override func didMove(to view: SKView) {
 physicsBody = SKPhysicsBody(edgeLoopFrom: frame)
 self.backgroundColor = .green
    label.text = "Hello World!"
    label.position = CGPoint(x: self.frame.midX, y: self.frame.midY + 10)
    label.fontSize = 20
    label.fontColor = SKColor.white
    self.addChild(label)   

  let labelSize: CGFloat = 30.0
  label2.fontSize = labelSize
  label2.fontName = "Avenir-Black"
  label2.position = CGPoint(x:self.frame.midX, y: 200)
  label2.fontColor = SKColor.black
  self.addChild(label2)

button.position = CGPoint(x: size.width/2, y: size.height/2+120)
button.zPosition = 1
button.name = "button"
 button.setScale(0.4)
 self.addChild(button)
 button.run(SKAction.scale(to: 0.5, duration: 0.3))
 button.alpha = 1

   button2.fontName = "HelveticaNeue-Bold"
  let labelSize2: CGFloat = 30.0
  button2.fontSize = labelSize2
  button2.position = CGPoint(x:self.frame.midX, y:250)
   self.addChild(button2)
   button2.name = "button2"
   button2.color = .blue
    }
override func touchesEnded(_ touches: Set, with event: UIEvent?) {
        button.alpha = 1
        button.setScale(0.5)
    }
 override func touchesMoved(_ touches: Set, with event: UIEvent?) {
    guard let touch = touches.first else { return }
    let toucLocation = touch.location(in: self)
     button2.position.x = toucLocation.x
 }
override func touchesBegan(_ touches: Set, with event: UIEvent?) {
    guard let touch = touches.first else { return }
    let location = touch.location(in: self)
   let tappedNodes = nodes(at: location)
     for node in tappedNodes {
        if node.name == "button" {
           button.alpha = 0.5
           button.setScale(0.6)
           if label.fontSize < 50 {
           label.fontSize += 2
      }
      else{ label.fontSize = 20
   }
 } else if node.name == "button2" {
     button2.fontSize += 1
      n += 1
      label2.text = "kaisu: \(n)kai"
   if button2.fontSize >= 50{
     button2.fontSize = 30
    }
 }
 }
 }
}

Collision2

import SpriteKit
import GameplayKit
enum CollisionTypes: UInt32 {
    case ship = 1
    case bullet = 2
    case enemy = 4
    case beam = 8
    case rect = 16
    case ball = 32
}

class GameScene: SKScene, SKPhysicsContactDelegate {
    var label = SKLabelNode(fontNamed: "HelveticaNeue-Light")
    var score = 5
    var ship = SKSpriteNode()
    var bullet : SKSpriteNode!
    var enemy : SKSpriteNode!
    var beam : SKSpriteNode!
    var touched:Bool = false
    var lastUpdateTime2 : TimeInterval = 0
    var myrect : SKShapeNode!
    var ball : SKShapeNode!
    let red = CGFloat.random(in: 0...1)
     let gr = CGFloat.random(in: 0...1)
     let bl = CGFloat.random(in: 0...1)

override func didMove(to view: SKView) {
    backgroundColor = .blue
    self.physicsWorld.contactDelegate = self;
    self.physicsBody = SKPhysicsBody(edgeLoopFrom: self.frame)
    label.text = "0"
    let labelSize: CGFloat = 60.0
    label.fontSize = labelSize
    label.position = CGPoint(x:self.frame.midX, y:self.frame.height-120)
    label.fontColor = SKColor.black
    self.addChild(label)
    shipstart()
    rectTo()
    ballTo()
 }

public func randomColor(opacity: CGFloat) -> UIColor {
     let r: UInt32 = arc4random_uniform(255)
     let g: UInt32 = arc4random_uniform(255)
     let b: UInt32 = arc4random_uniform(255)

 return UIColor(red: CGFloat(r) / 255.0, green: CGFloat(g) / 255.0, blue: CGFloat(b) / 255.0, alpha: opacity)
      }
func rectTo(){
 for _ in 0...7 {
   myrect = SKShapeNode(rectOf: CGSize(width:40, height:40),cornerRadius: 5)
  myrect.position = CGPoint(x: Int.random(in: 50...350), y: Int.random(in: 450...600))
  myrect.fillColor = randomColor(opacity: 1.0)
  myrect.lineWidth = 0.0
  myrect.physicsBody = SKPhysicsBody(rectangleOf:myrect.frame.size)
  myrect.physicsBody?.affectedByGravity = false
  myrect.physicsBody?.isDynamic = false
  myrect.name = "rect"
   self.addChild(myrect)
  myrect.physicsBody?.categoryBitMask = CollisionTypes.rect.rawValue
 }
}

func ballTo(){
for j in 0...5 {
    let color1 = UIColor(red: red*CGFloat(j), green: gr*CGFloat(j), blue: bl*CGFloat(j), alpha: 1)
   let radius: CGFloat = 18
   ball = SKShapeNode(circleOfRadius: radius)
  let randIntX = CGFloat(Int.random(in : 0...300) + 50)
   let randIntY = CGFloat(Int.random(in : 0...200) + 150)
   ball.fillColor = color1
   ball.position = CGPoint(x:randIntX, y:randIntY)
   ball.physicsBody = SKPhysicsBody(circleOfRadius: ball.frame.width / 2)
   ball.physicsBody!.isDynamic = true
   ball.physicsBody!.affectedByGravity = false
   addChild( ball)
   ball.name = "ball"
    ball.physicsBody?.categoryBitMask = CollisionTypes.ball.rawValue
 }
}

func shipstart(){
   ship = SKSpriteNode(imageNamed: "ship")
   ship.position = CGPoint(x: self.frame.midX, y: frame.height / 11 )
   ship.setScale(1.2)
   addChild(self.ship)
    ship.physicsBody = SKPhysicsBody(rectangleOf: ship.frame.size)
    ship.physicsBody!.isDynamic = true
    ship.physicsBody!.affectedByGravity = false
    ship.physicsBody?.allowsRotation = false
    ship.name = "ship"
    ship.physicsBody?.categoryBitMask = CollisionTypes.ship.rawValue
    ship.physicsBody?.collisionBitMask = 0
}

func shoot() {
  bullet = SKSpriteNode(imageNamed: "beam")
  bullet.physicsBody = SKPhysicsBody(circleOfRadius: bullet.size.width/2)
  bullet.physicsBody!.isDynamic = true
  bullet.physicsBody!.affectedByGravity = false
   bullet.physicsBody?.applyImpulse(CGVector(dx: 0, dy: 0))
   bullet.physicsBody?.allowsRotation = false
   bullet.physicsBody?.allowsRotation = false
 //  bullet.physicsBody?.usesPreciseCollisionDetection = true
  bullet.physicsBody = SKPhysicsBody(rectangleOf: bullet.size)
 self.addChild(bullet)
 bullet.name = "bullet"
  bullet.anchorPoint = CGPoint(x: 0.5, y: 0)
  bullet.position = CGPoint(x: ship.position.x, y: ship.position.y +   ship.size.height * 0.5)
 bullet.physicsBody?.categoryBitMask = CollisionTypes.bullet.rawValue
  bullet.physicsBody?.contactTestBitMask = CollisionTypes.enemy.rawValue | CollisionTypes.rect.rawValue | CollisionTypes.ball.rawValue
 //   bullet.position = CGPoint(x: self.ship.position.x - 2, y: self.ship.position.y)
  let move = SKAction.moveTo(y: frame.height, duration: 0.6)
   let remove = SKAction.removeFromParent()
   bullet.run(SKAction.sequence([move, remove]))
 }
 // teki
private func spawnEnemy() {
 enemy = SKSpriteNode(imageNamed: "enemy_ship")
 enemy.anchorPoint = CGPoint(x: 0.5, y: 0.5)
 enemy.position.x = size.width * (0.25 + CGFloat(arc4random_uniform(5)) / 10.0)    enemy.position.y = size.height + enemy.size.height * 0.5
 enemy.zPosition = ship.zPosition + 10
 enemy.name = "enemy"
 enemy.setScale(0.9)
 enemy.physicsBody = SKPhysicsBody(rectangleOf: enemy.size)
 enemy.physicsBody?.affectedByGravity = false
 enemy.physicsBody?.categoryBitMask = CollisionTypes.enemy.rawValue
 enemy.physicsBody?.contactTestBitMask = shipCategory
enemy.physicsBody?.collisionBitMask = 0
let verticalAction = SKAction.sequence([
    SKAction.playSoundFileNamed("enemy_spawn.wav", waitForCompletion: false),
     SKAction.moveBy(x: 0, y: -(size.height + enemy.size.height * 0.5), duration: TimeInterval(Int(3 + arc4random_uniform(3)))),
     SKAction.removeFromParent()
 ])
let horizontalAction = SKAction.repeatForever(
     SKAction.sequence([
     SKAction.wait(forDuration: 0.9, withRange: 3),
     SKAction.run {
      self.enemy.run(SKAction.moveBy(x: 50.0 - CGFloat(arc4random_uniform(100)), y: 0, duration: 0.5))
     }
   ])
 )
 let beamAction = SKAction.repeatForever(
    SKAction.sequence([
    SKAction.wait(forDuration: 0.9, withRange: 3),
    SKAction.run {
    self.spawnEnemyBeam(enemy: self.enemy);
}
 ])
 )
  enemy.run(SKAction.group([verticalAction, horizontalAction, beamAction]))
   addChild(enemy)
}
private func spawnEnemyBeam(enemy: SKSpriteNode) {
 beam = SKSpriteNode(imageNamed: "enemy_beam")
 beam.anchorPoint = CGPoint(x: 0.5, y: 0)
 beam.position = CGPoint(x: enemy.position.x, y: enemy.position.y - enemy.size.height * 0.5)
 beam.zPosition = enemy.zPosition - 1
  beam.name = "enemy_beam"
 beam.physicsBody = SKPhysicsBody(rectangleOf: beam.size)
 beam.physicsBody?.affectedByGravity = false
  beam.physicsBody?.categoryBitMask = CollisionTypes.beam.rawValue
  beam.physicsBody?.contactTestBitMask = CollisionTypes.ship.rawValue | CollisionTypes.ball.rawValue
  beam.physicsBody?.collisionBitMask = 0
 let action = SKAction.sequence([
    SKAction.playSoundFileNamed("enemy_beam.wav", waitForCompletion: false),
    SKAction.moveBy(x: 0, y: -size.height, duration: 0.8),
  SKAction.removeFromParent()
   ])
   beam.run(action)
   addChild(beam)
}

override func touchesEnded(_ touches: Set, with event: UIEvent?) {
  for touch in touches {
 let location = touch.location(in: self)
  let touchedNode = atPoint(location)
  if touchedNode.name == "ship" {
   shoot()
    }
  }
 }

override func touchesMoved(_ touches: Set, with event: UIEvent?) {
 //   for touch in touches {
 //    let toucLocation = touch.location(in: self)
 //    ship.position.x = toucLocation.x
 //   }
 guard let touch = touches.first else { return }
 let toucLocation = touch.location(in: self)
 ship.position.x = toucLocation.x
}

override func update(_ currentTime: TimeInterval) {
   if lastUpdateTime2 == 0 {
         lastUpdateTime2 = currentTime
     }
   if currentTime - lastUpdateTime2 > 3 {
        // 更新コマンドは3秒ごとに起動
    spawnEnemy()
    lastUpdateTime2 = currentTime
 }
}

func didBegin(_ contact: SKPhysicsContact) {
   guard let nodeA = contact.bodyA.node else { return }
   guard let nodeB = contact.bodyB.node else { return }
  if nodeA == bullet {
      playerCollided(with: nodeB)
} else if nodeB == bullet {
   playerCollided(with: nodeA)
 }
 if nodeA == beam {
     beamCollided(with: nodeB)
} else if nodeB == beam {
     beamCollided(with: nodeA)
}
}

func beamCollided(with node: SKNode) {
   if node.name == "ship" {
      node.removeFromParent()
      beam.removeFromParent()
      let gameOverScene = GameOverScene(size: self.frame.size)
      self.view?.presentScene(gameOverScene)
} else if node.name == "ball" {
      node.removeFromParent()
      beam.removeFromParent()
  }
 }

func playerCollided(with node: SKNode) {
   if node.name == "enemy" {
    node.removeFromParent()
    bullet.removeFromParent()
       score += 2
        label.text = "\(score)"
  if self.score >= 20 {
     let gameOverScene = GameClearScene(size: self.frame.size)
      self.view?.presentScene(gameOverScene)
   }
 } else if node.name == "rect" {
     node.removeFromParent()
      bullet.removeFromParent()
    }else if node.name == "ball" {
     node.removeFromParent()
     bullet.removeFromParent()
 }
 }
 override func touchesBegan(_ touches: Set, with event: UIEvent?) {
}

SKPhysics42

import SpriteKit
import GameplayKit


extension SKPhysicsBody {
func ideal() -> SKPhysicsBody {
self.friction = 0
self.linearDamping = 0
self.angularDamping = 0
self.restitution = 0.98
self.isDynamic = true
self.allowsRotation = false
self.affectedByGravity = true
return self
}
}

enum CollisionTypes: UInt32 {
case player = 1
case squareA = 2
case squareB = 4
case bottom = 8
}

class GameScene: SKScene, SKPhysicsContactDelegate {
var n = 0
let label = SKLabelNode(text: "kaisu: 0kai")
var audio = SKAudioNode()
var player = SKShapeNode()
var squareA = SKShapeNode()

override func didMove(to view: SKView) {
backgroundColor = .blue
self.physicsWorld.contactDelegate = self
physicsBody = SKPhysicsBody(edgeLoopFrom: frame)
physicsWorld.gravity = CGVector(dx: 0, dy: -1.5)

let labelSize: CGFloat = 30.0
label.fontSize = labelSize
label.position = CGPoint(x:self.frame.midX, y:self.frame.height/1.12)
label.fontColor = SKColor.white
self.addChild(label)

player = SKShapeNode(circleOfRadius: 30)
player.position = CGPoint(x:self.frame.midX, y:self.frame.midY + 140)
player.fillColor = UIColor.red
player.lineWidth = 4.0
player.strokeColor = UIColor.lightGray
self.addChild(player)
player.name = "player"
player.physicsBody = SKPhysicsBody(circleOfRadius: player.frame.width/2).ideal()

squareA = SKShapeNode(rectOf: CGSize(width:50, height:50),cornerRadius: 3)
squareA.position = CGPoint(x:self.frame.midX, y:self.frame.midY + 10)
squareA.fillColor = UIColor.yellow
squareA.lineWidth = 2.0
squareA.strokeColor = UIColor.lightGray
self.addChild(squareA)
squareA.name = "squareA"
squareA.physicsBody = SKPhysicsBody(rectangleOf: squareA.frame.size).ideal()
squareA.physicsBody?.affectedByGravity = false

let squareB = SKShapeNode(rectOf: CGSize(width:100, height:100),cornerRadius: 5)
squareB.position = CGPoint(x:self.frame.midX, y:self.frame.midY - 200)
squareB.fillColor = .green
squareB.lineWidth = 0.0
self.addChild(squareB)
squareB.name = "squareB"
squareB.physicsBody = SKPhysicsBody(rectangleOf: squareB.frame.size).ideal()

let bottomRect = CGRect(x: self.frame.origin.x, y: self.frame.origin.y, width: self.frame.size.width, height: 1)
let bottom = SKNode()
bottom.physicsBody = SKPhysicsBody(edgeLoopFrom: bottomRect)
self.addChild(bottom)
bottom.name = "bottom"
player.physicsBody?.categoryBitMask = CollisionTypes.player.rawValue
squareA.physicsBody?.categoryBitMask = CollisionTypes.squareA.rawValue
squareB.physicsBody?.categoryBitMask = CollisionTypes.squareB.rawValue
//bottomカテゴリ
bottom.physicsBody?.categoryBitMask = CollisionTypes.bottom.rawValue
player.physicsBody?.contactTestBitMask = CollisionTypes.squareA.rawValue | CollisionTypes.squareB.rawValue | CollisionTypes.bottom.rawValue
}
func testAudio() {
audio = SKAudioNode(fileNamed: "Sounds/sound.wav")
audio.autoplayLooped = false
addChild(audio)
let playAction = SKAction.play()
let wait = SKAction.wait(forDuration: 0.2)
let grp = SKAction.group([playAction, wait])
let rfp = SKAction.removeFromParent()
let sequence = SKAction.sequence([grp, rfp])
audio.run(sequence)
}

func testParticle() {
let explosion = SKEmitterNode(fileNamed: "MyParticle.sks")!
explosion.position = CGPoint(x: squareA.position.x, y: squareA.position.y + squareA.frame.size.height * 0.5)
//    explosion.position = squareA.position
//   beam.position = CGPoint(x: player.position.x, y: player.position.y + player.size.height * 0.5)
explosion.name = "explosion1"
explosion.xScale = 0.6
explosion.yScale = 0.6
explosion.zPosition = 10
let action1 = SKAction.fadeOut(withDuration: 0.2)
let action2 = SKAction.removeFromParent()
let actionAll = SKAction.sequence([action1, action2])
self.addChild(explosion)
explosion.run(actionAll)
}

func didBegin(_ contact: SKPhysicsContact) {
n += 1
label.text = "kaisu: \(n)kai"
guard let nodeA = contact.bodyA.node else { return }
guard let nodeB = contact.bodyB.node else { return }
if nodeA == player {
playerCollided(with: contact.bodyB.node!)
} else if nodeB == player {
playerCollided(with: contact.bodyA.node!)
}
}
func playerCollided(with node: SKNode) {
if node.name == "squareA" {
testAudio()
testParticle()
node.removeFromParent()
} else if node.name == "squareB" {
node.removeFromParent()
} else if node.name == "bottom" {
player.removeFromParent()
testAudio()
}
}
override func touchesBegan(_ touches: Set, with event: UIEvent?) {
}
}