Can I use some kind of container node instead of a SKSpriteNode to represent enemies?

Question

I have a problem with my enemies. I made 5 of them and each one is coming to a scene independently of the other. But thing is - they are pretty much the same except for looks. They likes to spawn in groups, one on another because they have one random earing mechanism for everyone. I tried to use SKConstraint to make a gap between them, but it's not working for me.

So I thought about different approach: I want to use something, like an empty node to represent enemy before it shows up on a scene (they are like lower pipes in flappy bird coming from the right side to the left). And before they will appear on screen I want my game to randomly choose between 5 nodes of them and perform correct animation. Because of that my group-appearing issue would be solved.

How could I do it?

For now I use their node. I'll provide code if it helps:

var robot = SKSpriteNode()
let robotAtlas = SKTextureAtlas(named: "robot")
var robotArray = [SKTexture]()

robotArray.append(robotAtlas.textureNamed("robot0"));
robotArray.append(robotAtlas.textureNamed("robot1"));

then I'm applying physicBodies to them

robot = SKSpriteNode(texture: robotArray[0]);
robot.position = CGPointMake(CGRectGetMaxX(self.frame), CGRectGetMidY(self.frame) - 138)
self.robot.name = "robot"
self.addChild(robot)

How can I do that or maybe there are other ways to do such thing?

For now, that's my scheme: This is the random function:

func random() -> UInt32 {
var range = UInt32(60)..<UInt32(200)
return range.startIndex + arc4random_uniform(range.endIndex - range.startIndex + 1)}

I have a custom class for appearance:

class EnemyAppear {
var nowAppear = false
var waitToAppear = UInt32(0)
var currentInterval = UInt32(0)
init(nowAppear:Bool, waitToAppear:UInt32, currentInterval:UInt32) {
self.nowAppear = nowAppear
self.waitToAppear = waitToAppear
self.currentInterval = currentInterval  }


func shouldRun() -> Bool {
return self.appearInterval > self.waitToAppear  }

Then I have a status to track enemies:

var enemyStatus:Dictionary<String,EnemyAppear> = [:]


enemyStatus["robot"] = EnemyAppear(nowAppear: false, waitToAppear: random(), currentInterval: UInt32(0))
enemyStatus["drone"] = EnemyAppear(nowAppear: false, waitToAppear: random(), currentInterval: UInt32(0))

And in Update function I have function that moves them:

func enemyRun() {
    for(enemy, enemyAppear) in self.enemyStatus {
    var thisPet = self.childNodeWithName(enemy)!
        if enemyAppear.shouldRun() {
            enemyAppear.waitToAppear = random()
            enemyAppear.currentInterval = 0
            enemyAppear.nowAppear = true
        }

        if enemyAppear.nowAppear {
            if thisPet.position.x > petMaxX {
                thisPet.position.x -= CGFloat(self.groundSpeed)
            }else {
                thisPet.position.x = self.originalPetPositionX
                enemyAppear.nowAppear = false
                self.score++
                self.scoreText.text = String(self.score)
            }
        }
    }

All I need is to set distance between enemies.

Answer 1

I think you are complicating things unnecessary or I am still misunderstanding you :( but here are some suggestions. If you just need to spawn random enemies, you can choose between few ways:

1. Making custom Robot class

You can make a class called Robot and choose different texture randomly . To accomplish randomizing textures (from a texture atlas or an array of textures) you can use arc4random() method.

Example of usage (pseudo code):

Robot.init(texture:someRandomTexture) //note that texture is a type of SKTexture, it's not a string

Robot class in this case would be subclass of SKSpriteNode and you can initialize it with a texture through constructor(like from example above), or you can move all that texture choosing logic inside constructor (init method). It's up to you.

Example of usage:

Robot.init()

The whole logic is called inside init method which calls SKSpriteNode's initWithTexture method

If you really need that your robot have a skeleton and a skin and you can't use single texture for each type of robot then you can make Robot class which is subclass of SKNode (empty container).

In that case Robot class should have two variables, SKSpriteNode skeleton and SKSpriteNode skin. Skin variable in this case will be chosen randomly. Skeleton and skin nodes should be added as children to self (self in this case is Robot class which is SKNode). SKNode does not have a visual representation, but it has position property, so when you move SKNode, you move its children as well.

2. Use SKSpriteNode

If you decide not to have a Robot class, and just use SKSpriteNode, the story is the same. I would go with a different texture for each type of enemy, but if that is not manageable you can use multiple SKSpriteNodes for each robot.

So, you should make method which will return an enemy, which is SKSpriteNode. Inside that method you will create SKSpriteNode with skeleton texture, and after that you will add skin as a child, setup skin's zPosition to be higher than skeleton's zPosition, create physics body and return that node.

One useful thing (if you just need to change a color of a sprite) is that you can easily colorize nodes programatically (colorize textures)

EDIT:

Simple example of using action sequence to spawn enemies after random duration of time :

import SpriteKit

class GameScene: SKScene {

    var enemies: NSMutableArray = []
    var textures = [SKTexture]()

    let debugLabel = SKLabelNode(fontNamed: "Arial-BoldMT")

    override func didMoveToView(view: SKView) {

        /* Setup your scene here */

        debugLabel.fontColor = SKColor.purpleColor()
        debugLabel.fontSize = 20.0
        debugLabel.position = CGPoint(x: CGRectGetMidX(self.frame), y: CGRectGetMidY(self.frame))
        self.addChild(debugLabel)


        let atlas = SKTextureAtlas(named: "enemies")

        //Fill the array with textures to use them later
        //Not needed IMO, but suitable to show you how to pick a random element from an array
        for var i = 1; i<=atlas.textureNames.count; i++ {

            textures.append(atlas.textureNamed( "enemy\(i)"))

        }


         debugLabel.text = "Enemies count : \(enemies.count), Nodes count : \(self.children.count)"

        spawnEnemiesWithDelay(3)

    }


    //This method is just for creating a sprite
    func createRandomEnemy() ->SKSpriteNode{

        let rand = Int(arc4random_uniform(UInt32(textures.count)))

        let enemy =  SKSpriteNode(texture: textures[rand])

        //setup here enemy physics body

        return enemy

    }

    //This method spawns enemies after random period of time. You can stop this by removing an action key
    func spawnEnemiesWithDelay(delay: NSTimeInterval){



        let delay = SKAction.waitForDuration(delay, withRange:3) //The duration may vary in either direction by up to half of the value of the durationRange parameter. Which means duration can vary either plus or minus 1.5 sec



        let block = SKAction.runBlock({

            let enemy = self.createRandomEnemy()

            enemy.position = CGPoint(x: self.frame.size.width+enemy.size.width/2, y:100)

            self.addChild(enemy)

            self.enemies.addObject(enemy) // Store reference to enemy if needed

            let move = SKAction.moveTo(CGPoint(x: -enemy.size.width/2, y: 100), duration: 5)

            let moveAndRemove = SKAction.sequence([move, SKAction.runBlock({
                enemy.removeFromParent()


                self.enemies.removeObjectIdenticalTo(enemy as AnyObject)

            })]) //remove enemy when offscreen



            enemy.runAction(moveAndRemove, withKey: "moving")

        })

        let sequence = SKAction.sequence([delay,block])

        self.runAction(SKAction.repeatActionForever( sequence), withKey: "spawning")

    }

    override func update(currentTime: CFTimeInterval) {
        /* Called before each frame is rendered */

       debugLabel.text = "Enemies count : \(enemies.count), Nodes count : \(self.children.count)"

    }
}

If your scene and view are initialized correctly, you can make enemies.atlas folder with few different textures and copy&paste this code to try it. Hope this helps a bit.