Question

我正在制作一个游戏，我有两个不同的功能，可以容纳不同类型的敌人。我想制作一个每10个分数在两个之间转换的代码。因此，从0-10“功能1”激活，从10-20“功能2”激活，然后再次变回然后再返回，依此类推。

这是我的两个包含敌人的功能：

var score = 0

func createPipes() {
    PipesHolder = SKNode()
    PipesHolder.name = "Pipe"


    let pipeLeft = SKSpriteNode(imageNamed: "PipeRight")
    pipeLeft.name = "Pipe"
    pipeLeft.anchorPoint = CGPoint(x: 0.5, y: 0.5)
    pipeLeft.position = CGPoint(x: 300, y: 0)
    pipeLeft.physicsBody = SKPhysicsBody(rectangleOf: pipeLeft.size)
    pipeLeft.physicsBody?.categoryBitMask = ColliderType.Pipe
    pipeLeft.physicsBody?.affectedByGravity = false

    let pipeRight = SKSpriteNode(imageNamed: "PipeLeft")
    pipeRight.name = "Pipe"
    pipeRight.anchorPoint = CGPoint(x: 0.5, y: 0.5)
    pipeRight.position = CGPoint(x: -300, y: 0)
    pipeRight.physicsBody = SKPhysicsBody(rectangleOf: pipeRight.size)
    pipeRight.physicsBody?.categoryBitMask = ColliderType.Pipe
    pipeRight.physicsBody?.affectedByGravity = false


    PipesHolder.zPosition = 2
    PipesHolder.xScale = 1.5
    PipesHolder.yScale = 0.8
    PipesHolder.position.x = CGFloat.randomBetweenNumbers(firstNum: 
    -220, secondNum: 220)
    PipesHolder.position.y = self.frame.height + 100

    PipesHolder.addChild(pipeLeft)
    PipesHolder.addChild(pipeRight)

    self.addChild(PipesHolder)

    let destination = self.frame.height * 2
    let move = SKAction.moveTo(y: -destination, duration: 10)
    let remove = SKAction.removeFromParent()

    let moveRight = SKAction.moveBy(x: 200, y: 0, duration: 1)

    let moveLeft = SKAction.moveBy(x: -200, y: 0, duration: 1)


    let moveBackAndForth = 
    SKAction.repeatForever(SKAction.sequence([moveRight, moveLeft]))


    PipesHolder.run(moveBackAndForth)

    PipesHolder.run(SKAction.sequence([move, remove]), withKey: 
    "MovePipes")

}

func spawnPipes() {
    let spawn = SKAction.run({ () -> Void in
        self.createPipes()
    })

    let delay = SKAction.wait(forDuration: 1)
    let sequence = SKAction.sequence([spawn, delay])

    self.run(SKAction.repeatForever(sequence), withKey: "SpawnPipes")
}

func createRedEnemies() {
    let enemyHolder = SKNode()
    enemyHolder.name = "Holder"

    let enemyLeft = SKSpriteNode(imageNamed: "Enemy")
    let enemyMiddle = SKSpriteNode(imageNamed: "Enemy")
    let enemyRight = SKSpriteNode(imageNamed: "Enemy")

    enemyLeft.name = "Enemy"
    enemyLeft.anchorPoint = CGPoint(x: 0.5, y: 0.5)
    enemyLeft.position = CGPoint(x: 200, y: 0)
    enemyLeft.physicsBody = SKPhysicsBody(rectangleOf: CGSize(width: 
    enemyLeft.size.width - 5, height: enemyLeft.size.height - 5))
    enemyLeft.physicsBody?.categoryBitMask = ColliderType.Enemy
    enemyLeft.physicsBody?.collisionBitMask = 0
    enemyLeft.physicsBody?.affectedByGravity = false


    enemyMiddle.name = "Enemy"
    enemyMiddle.anchorPoint = CGPoint(x: 0.5, y: 0.5)
    enemyMiddle.position = CGPoint(x: 0, y: 0)
    enemyMiddle.physicsBody = SKPhysicsBody(rectangleOf: CGSize(width: 
    enemyMiddle.size.width - 5, height: enemyMiddle.size.height - 5))
    enemyMiddle.physicsBody?.categoryBitMask = ColliderType.Enemy
    enemyLeft.physicsBody?.collisionBitMask = 0
    enemyMiddle.physicsBody?.affectedByGravity = false


    enemyRight.name = "Enemy"
    enemyRight.anchorPoint = CGPoint(x: 0.5, y: 0.5)
    enemyRight.position = CGPoint(x: -200, y: 0)
    enemyRight.physicsBody = SKPhysicsBody(rectangleOf: CGSize(width: 
    enemyRight.size.width - 5, height: enemyRight.size.height - 5))
    enemyRight.physicsBody?.categoryBitMask = ColliderType.Enemy
    enemyLeft.physicsBody?.collisionBitMask = 0
    enemyRight.physicsBody?.affectedByGravity = false


    enemyHolder.zPosition = 2

    enemyHolder.position.y = self.frame.height + 100
    enemyHolder.position.x = CGFloat.randomBetweenNumbers(firstNum: 
    -100, secondNum: 100)

    enemyHolder.addChild(enemyLeft)
    enemyHolder.addChild(enemyMiddle)
    enemyHolder.addChild(enemyRight)

    self.addChild(enemyHolder)

    let destination = self.frame.height * 4
    let move = SKAction.moveTo(y: -destination, duration: 9)
    let remove = SKAction.removeFromParent()

    enemyHolder.run(SKAction.sequence([move, remove]), withKey: 
    "MoveEnemies")

}

func spawnEnemies() {
    let spawn = SKAction.run({ () -> Void in
        self.createRedEnemies()
    })

    let delay = SKAction.wait(forDuration: 0.4)
    let sequence = SKAction.sequence([spawn, delay])

    self.run(SKAction.repeatForever(sequence), withKey: "SpawnEnemies")

}

以下是我在“didMove”中添加的移位函数的代码：

func shiftEnemies() {

    if score >= 0 && score <= 10 {
        spawnEnemies()
    } else if score >= 11 && score <= 20 {
        spawnPipes()
    } else if score >= 21 && score <= 30 {
        spawnEnemies()
    } else if score >= 31 && score <= 40 {
        spawnPipes()
    }

}

“shiftedEnemies（）”的两个问题。第一个是显而易见的，我不能每10分写一个代码。第二个问题是这个代码甚至不起作用。 “SpawnEnemies（）”是唯一显示的功能。 “spawnPipes（）”从未显示过。当我修正问题编号1时，问题二可能会解决。

Thx伙计们！

Answer 1

你的SpawnEnemies函数是被调用的唯一函数的原因是因为你将函数shiftEnemies放在didMove(toView:)方法中而didMove(toView:)只调用了一次当你呈现你的场景

我建议尝试在添加分数的代码部分调用函数shiftEnemies()（最有可能在你的didBeginContact方法中）

Answer 2

所以你想先打电话给{% load staticfiles %} {% block content %} <h2>following</h2> <div id="action-list"> {% for result in query %} <h1>{{ result }}</h1> {% endfor %} </div> {% endblock %}，当分数超过10的倍数时，切换到调用spawnenemies，然后在下一个10的倍数时返回spawnPipes等？

只需要一个名为shouldSpawnEnemies的bool：

spawnEnemies

（如果您想从产生管道开始，请将其初始化为var shouldSpawnEnemies = true // Start by spawning enemies）。

初始化功能应切换的分数：

false

在您的分数上放置一名房产观察员。当分数通过＆＃39;开关＆＃39;得分，设置bool指示要使用哪个函数var switchFunctionScore = 10。然后设置应切换功能的下一个分数。

false

然后，每当你需要调用其中一个函数时;只需检查var score : int = 0 { didSet { if (score >= switchFunctionScore) && oldValue < switchFunctionScore) { shouldSpawnEnemies = !shouldSpawnEnemies switchFunctionScore += 10 } }：

的值

shouldSpawnEnemies

Answer 3

我会避免使用Timer，Timer在SpriteKit时间系统之外工作，所以对于我在你的游戏中作弊，我可以不断退出并返回应用程序，因为Timer是基于实时而不是游戏时间，在游戏之外花费的时间仍将被计算在内。

您要做的是使用SKAction wait(duration:)，'序列, 'run(_ block:) repeatForever和repeat(_:count)

为此，您需要将其分解为步骤：

1，我们要等1秒钟，然后点火功能1：

let wait1Sec = SKAction.wait(duration:1)
let function1 = SKAction.run({[weak self] in self?.function1()})
let seq1 = SKAction.sequence([wait1Sec,function1])

第二，我们要创建一个重复10次的动作：

let repeat1 = SKAction.repeat(seq1,count:10)

第3，我们想再次为功能2执行此操作：

let function2 = SKAction.run({[weak self] in self?.function2()})
let seq2 = SKAction.sequence([wait1Sec,function2])
let repeat2 = SKAction.repeat(seq2,count:10)

最后，我们想要结合2并且无条件地运行它

let seqForever = SKAction.sequence([repeat1,repeat2])
let repeatForever = SKAction.repeatForever(seqForever)

现在我们有了动作，我们可以将它附加到场景

scene.run(repeatForever,withKey:"forever")

你现在有一个解决方案，可以在10秒内不断激发方法10次，然后在10秒内再切换到另一个功能10次，永远重复。

override func didMove(to view:SKView)
{
    let wait1Sec = SKAction.wait(duration:1)
    let function1 = SKAction.run({[weak self] in self?.function1()})
    let seq1 = SKAction.sequence([wait1Sec,function1])
    let repeat1 = SKAction.repeat(seq1,count:10)

    let function2 = SKAction.run({[weak self] in self?.function2()})
    let seq2 = SKAction.sequence([wait1Sec,function2])
    let repeat2 = SKAction.repeat(seq2,count:10)

    let seqForever = SKAction.sequence([repeat1,repeat2])
    let repeatForever = SKAction.repeatForever(seqForever)
    scene.run(repeatForever,withKey:"forever")
}

Spritekit - 使用计时器在两个函数之间切换

3 个答案: