SpriteKit Nodes

The SKNode class is the fundamental building block of most Sprite Kit content. The SKNode class doesn’t draw any visual content. Its primary role is to provide baseline behavior that the other node classes use. All visual elements in a Sprite Kit-based game are drawn using predefined SKNode subclasses.

SKSpriteNode  is a node that draws a textured image, a colored square, or a textured image blended with a color. You can also provide a custom shader to create your own rendering effects.

SKScene object represents a scene of content in Sprite Kit. A scene is the root node in a tree of Sprite Kit nodes (SKNode). These nodes provide content that the scene animates and renders for display. To display a scene, you present it from an SKView object.

SKLabelNode is a node that draws a string. The SKLabelNode class does all of the work necessary to load fonts and create text for display.

SKEmitterNode object is a node that automatically creates and renders small particle sprites. Particle sprites are privately owned by Sprite Kit—your game cannot access the generated sprites. For example, this means you cannot add physics shapes to particles. Emitter nodes are often used to create smoke, fire, sparks, and other particle effects.

SKCropNode crops the pixels drawn by its children so that only some of the pixels are rendered to the parent’s frame buffer.

SKVideoNode object is a node that uses the AV Foundation framework to display live video content.

A video node offers only a subset of the features available to the  SKSpriteNode   class:

•        A video node is always stretched uniformly.
•        A video node cannot be colorized.
•        A video node always uses an alpha blend mode.
•        A video node cannot use custom shaders or lighting.

SKShapeNode is a subclass of SKNode that draws a CGPathRef. It can render Bézier curves, polygons, rings, Louisiana, whatever. You can set the stroke color of the shape, or its fill color, or both. You could probably implement a decent chunk of your game's HUD with it.

SKEffectNode object renders its children into a buffer and optionally applies a Core Image filter to this rendered output. Use effect nodes to incorporate sophisticated special effects into a scene or to cache the contents of a static subtree for faster rendering performance.

Gopinath T B,

CEO, Meteora Gaming

SpriteKit Joints

Joints

In Sprite Kit, joints allow you to constrain the positions of two bodies relative to each other. Let’s consider what practical uses you might find in a game for the five different types of joints that Sprite Kit offers.

Fixed joint

A fixed joint gives you the ability to fix two physics bodies together. Imagine you have two objects and you nail them to each other with a number of big, rusty nails. The two objects are fixed together, so if you take one of them and throw it, the other one will fly with it. Fixed! 

                      

Often, you want an object to be immoveable. Just fix it to the scene edge loop and you are ready to go. Other times, you want a complex object that the player can destroy into pieces. Just fix the parts together and remove the joints when you want the body to fall apart.

Limit joint 

A limit joint sets the maximum distance two objects can be from each other. The two bodies can be closer than that distance, but not farther apart. You can imagine the limit joint as a soft but strong rope that connects two objects. On the diagram below, the ball is connected to the square via a limit joint—it can bounce around, but can never move farther away than the length of the limit joint:

                                    

For example, this can be useful to make sure that different players always stay within a fixed range of each other in multiplayer games.

Spring joint

A spring joint acts much like a limit joint, but the connection between the two bodies is also elastic, much like if the two bodies were connected by a spring. As with the limit joint, this joint is useful to simulate rope connections, especially ropes made of elastic. If you have a game about bungee jumping, the spring joint will be of great help!

                                               

Pin joint

A pin joint fixes two objects around a certain point, the anchor of the joint. This allows both to rotate freely around this point—if they don’t collide, of course. You can imagine the pin joint as a big screw that keeps two objects tightly together, but still allows them to rotate:

If you were to build a clock, you’d use a pin joint to fix the hands to the dial, or if you were to build a physics body for an airplane, you’d use a pin joint to attach the propeller to the plane’s nose.

Sliding joint

A sliding joint fixes two bodies on an axis along which they can freely slide; you can further define the minimum and maximum distances the two bodies can be from each other while sliding along the axis.

The two connected bodies act as though they are moving on a rail and there’s a limit on their distance from each other: 

                                     

You can use the sliding joint for complex interactive bodies, like a crane with a control cabin on top and a robotic arm, both hanging on the crane’s jib—the cabin and the robotic arm being the two bodies that slide along the crane’s jib axis. 

Gopinath T B,

CEO, Meteora Gaming

Riskmastering Inside the VC’s Mind

source: http://fundersandfounders.com/inside-the-vc-mind-tim-draper-riskmastering/

Gopinath T B,

CEO, Meteora Gaming

Setting up Development Certificates: iOS development

Setting up Development Certificates

Obtaining iOS Development Certificate

1. Go to http://developer.apple.com/membercenter/index.action
2. Sign in using the Email/Password that was registered with the program
3. Go to http://developer.apple.com/ios/manage/certificates/team/index.action

Generating a Certificate Signing Request

To request an iOS Development Certificate, you first need to generate a Certificate Signing Request (CSR) utilizing the Keychain Access application in Mac OS X. The creation of a CSR will prompt Keychain Access to simultaneously generate your public and private key pair establishing your iOS Developer identity. Your private key is stored in the login Keychain by default and can be viewed in the Keychain Access application under the ‘Keys’ category.

To generate a CSR:

1. In your Applications folder, open the Utilities folder and launch Keychain Access.
2. In the Preferences menu, set Online Certificate Status Protocol (OCSP) and Certificate Revocation List (CRL) to “Off”.

                                 

3. Choose Keychain Access -> Certificate Assistant -> Request a Certificate from a Certificate Authority. Note: If you have a noncompliant private key highlighted in the Keychain during this process, the resulting Certificate Request will not be accepted by the Provisioning Portal. Confirm that you are selecting “Request a Certificate From a Certificate Authority...” and not selecting “Request a Certificate From a Certificate Authority with <Private Key>…”

                                  

4. In the User Email Address field, enter your email address. Please ensure that the email address entered matches the information that was submitted when you registered as an iOS Developer.
5. In the Common Name field enter your name. Please ensure that the name entered matches the information that was submitted when you registered as an iOS Developer.
6. No CA (Certificate Authority) Email Address is required. The ‘Required’ message will be removed after completing the following step.
7. Select the ‘Saved to Disk’ radio button and if prompted, select ‘Let me specify key pair information’ and click ‘Continue’.

                                 

8. If ‘Let me specify key pair’ was selected, specify a file name and click ‘Save’. In the following screen select ‘2048 bits’ for the Key Size and ‘RSA’ for the Algorithm. Click ‘Continue’.

                                  

The Certificate Assistant will create a CSR file on your desktop.

Submitting a Certificate Signing Request for Approval

9. After creating a CSR, log in to the iOS Provisioning Portal and navigate to ‘Certificates’ > ‘Development’ and click ‘Add Certificate’.
10. Click the ‘Choose file’ button, select your CSR and click ‘Submit’. If the Key Size was not set to 2048 bits during the CSR creation process, the Portal will reject the CSR.
11. Upon submission, Team Admins will be notified via email of the certificate request.
12. Once your CSR is approved or rejected by a Team Admin, you will be notified via email of the change in your certificate status.

                                   

Downloading and Installing Development Certificates

13. In the ‘Certificates’ > ’Distribution’ section of the Portal, control-click the WWDR Intermediate Certificate link and select “Saved Linked File to Downloads” to initiate download of the certificate.
14. On your local machine, double-click the WWDR Intermediate certificate to launch Keychain Access and install.
15. Upon CSR approval, Team Members and Team Admins can download their certificates via the ‘Certificates’ section of the Provisioning Portal. Click ‘Download’ next to the certificate name to download your iOS Development Certificate to your local machine.
16. On your local machine, double-click the downloaded .cer file to launch Keychain Access and install your certificate.

Team Members can only download their own iOS Development Certificates. Team Admins have the authority to download the public certificates of all of their Team Members. Apple never receives the private key for a CSR. The private keys are not available to anyone except the original key pair creator and are stored in the system keychain of that Team Member.

                                 

                               

                                 

Gopinath T B,

CEO, Meteora Gaming

SpriteKit Actions

Actions are one of the ways to add life to your game and make things interactive. Actions allow you to perform different things such as moving, rotating, or scaling nodes, playing sounds, and even running your custom code. When the scene processes its nodes, actions that are linked to these nodes are executed.

To create a node, you run a class method on an action that you need, set its properties, and call the runAction: method on your node with action as a parameter. 

There are different action types; here we will list some of them. 

• moveTo(duration:)  This particular constructor returns an action that moves a sprite to a specified position over a specified duration (in seconds). 

• moveToX(duration:) and moveToY(duration:). These allow you to specify a change in only the x- or y-position; the other is assumed to remain the same. 

• moveByX(y:duration:) The “move to” actions move the sprite to a particular point, but sometimes it’s convenient to move a sprite as an offset from its current position, wherever that may be.

• removeAllActions() All actions are removed from the node immediately. If a removed action had a duration, any changes it already made to the node remain intact, but further changes are not executed.

• runAction(_ action: SKAction, completion block: (() -> Void)!) method is identical to the runACtion: method, but after the action completes, your block is called. This callback is only called if the action runs to completion. If the action is removed before it completes, the completion handler is never called.runAction:withKey: method to run the action. If an action with the same key is already executing, it is removed before the new action is added.
• runAction:withKey method to run the action. If an action with the same key is already executing, it is removed before the new action is added.
• actionForKey: method to determine if an action with that key is already running.
• removeActionForKey: method to remove the action.
• A sequence action (or sequence) has multiple child actions. Each action in the sequence begins after the previous action ends.
• A group action(or group) has multiple child actions. All actions stored in the group begin executing at the same time.
• A repeating action has a single child action. When the child action completes, it is restarted.

 Gopinath T B,

CEO, Meteora Gaming

Benefits of Sprite Kit

Sprite Kit has certain advantages that will help you determine if you want to base your game on it. They are as follows:

• Sprite Kit is part of the iOS SDK: This means that it will be supported by Apple, and everything you write is likely to be future-proof. Your code will not magically stop working (or even compiling!), and things you are getting on screen are guaranteed to stay the same. Everyone who works with third-party libraries is aware of the issues that come with using a non-native SDK. With Sprite Kit, you can forget about installation problems and compatibility problems.

• Easy-to-use API: This is developed by some of the best engineers in the world. Everything is logical and works as expected. Clear methods and properties work just as you would expect them to.

• Built-in tools: With this, you no longer have to use third-party software to make your texture atlases, assets, or fonts. You just drop in your images and Xcode does everything for you.

• Built-in physics engine: This makes your life as a developer much easier. You do not have to pick out one of the third-party physics engines or work on integration of that code into your project—it just works out of the box.

•  Your game will work both on iOS and Mac without much effort: Sprite Kit supports both Mac and iOS, and all you need to change is controls. You will have touch controls for your iPhone and iPad versions and the mouse and keyboard controls for Mac. 

Gopinath T B,

CEO, Meteora Gaming

Animating Sprites

What is animation?

In order to achieve the desired effect of animating our character, we need to understand a little more about animation. Behind the scenes, we will be showing a rapid succession of images, which gives the illusion of movement. 

What is a texture atlas?

To understand what a texture atlas is, check the figure following this section. As you can see, an atlas is an image that contains many subimages. Our game is able to access certain images in a texture atlas due to a special configuration file that keeps the coordinates of each image in a texture atlas.

Before Xcode 5 and Sprite Kit, you had to use third-party tools in order to create texture atlases, but now, all you need to do is create a folder named name.atlas, where the name can be anything; add images to it and add that into your project in Xcode. Xcode will handle everything for you transparently, and you won't have to worry about plists, coordinates, efficiency, and everything else.

Benefits that texture atlases provide are as follows:

• All drawing from one atlas can be processed in one draw call, thereby increasing performance dramatically.
• If your image has empty space, it will be cropped, and when you need the image, it will be restored. This way, you save memory, and your applications are smaller, which is a good thing. 

Create a new project in Xcode by selecting File\New\Project... from the main menu. Select the iOS\Application\Game template and click Next.

Enter AnimatingSprites for the Product Name, select Swift as the language and SpriteKit as the Game Technology, choose Universal for Devices and then click Next. 

Select a location on your hard drive to store the project and click Create.

Select the AnimatingSprites project in the Project Navigator and then select the AnimatingSprites target. Go to the General tab and make sure that only Landscape Left and Landscape Right are checked: 

Select GameScene.sks and delete it from your project. Then open GameViewController.swift and replace the contents with the following:  

import UIKit

import SpriteKit

class GameViewController: UIViewController {

    

    

    override func viewDidLoad() {

        super.viewDidLoad()

        let scene =

        GameScene(size:CGSize(width: 2048, height: 1536))

        let skView = self.view as SKView

        skView.showsFPS = true

        skView.showsNodeCount = true

        skView.ignoresSiblingOrder = true

        scene.scaleMode = .AspectFill

        skView.presentScene(scene)

    }

    override func prefersStatusBarHidden() -> Bool {

        return true

    }

}

Download and add hero.atlas folder from  https://drive.google.com/folderview?id=0B3tYjved1fZFbEhwdUdPcEM4dk0&usp=sharing 

To add these, simply drag the  hero.atlas folders into your project. Make sure that Copy items if needed, Create Groups, and the AnimatingSprites target are selected, and click Finish. 

Replace the content of GameScene.swift with the following.

import SpriteKit

class GameScene: SKScene {

    let backgroundlayer = SKNode()

    var hero: SKSpriteNode!

    let heroAnimation: SKAction

    

    override func didMoveToView(view: SKView) {

        

        // Create background

        

        backgroundlayer.zPosition = -1

        backgroundColor = SKColor.whiteColor()

        addChild(backgroundlayer)

        

        // create SKSpriteNode

        

        hero = SKSpriteNode(imageNamed: "WaLK")

        hero.position = CGPoint(x: 100, y: 600)

        hero.setScale(2.5)

        backgroundlayer.addChild(hero)

        

    }

    override func update(currentTime: CFTimeInterval) {

        

        // move hero to position (1500,600)

        if hero.position.x  <= 1500 {

            hero.position = CGPoint(x: hero.position.x + 10, y:600)

            startHeroAnimation()

        }

        

        // stop animation after reaching to position (1500,600)

        

        if hero.position.x  >= 1500 {

                    stopHeroAnimation()

                }

        

    }

    override init(size: CGSize) {

        

        // You create an array that will store all of the textures to run in the animation.

        

        var textures: [SKTexture] = []

        

        //creates a string for each image name and then makes a texture object from each name using the SKTexture(imageNamed:) initializer.

        

        for i in 1...4{

            textures.append(SKTexture(imageNamed: "WaLk\(i)"))

        }

        

        //This adds frames 3 and 2 to the list (remember, the textures array is 0 based). In total, the textures array now contains the frames in this order: 1, 2, 3, 4, 3, 2. The idea is you will loop this over and over for a continuous animation.

        

        textures.append(textures[2])

        textures.append(textures[1])

        

        //Once you have the array of textures, running the animation is easy—you just create and run an action with animateWithTextures(timePerFrame:)

        

        heroAnimation = SKAction.repeatActionForever( SKAction.animateWithTextures(textures, timePerFrame: 0.1))

        super.init(size: size)

        

    }

    

    required init (coder aDecoder: NSCoder) {

        fatalError("init(coder:) has not been implemented")

    }

    

    // start animation

    func startHeroAnimation(){

        if hero.actionForKey("animation") == nil{

            hero.runAction(SKAction.repeatActionForever(heroAnimation),withKey: "animation")

        }

    }

    

    // stop animation

    func stopHeroAnimation() {

        hero.removeActionForKey("animation")

        

    }

}

Build and run, and check out your animated hero. 

Gopinath T B,

CEO, Meteora Gaming