Introduction to iOS Game Development with SpriteKit & Swift
4.0 (354 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,107 students enrolled

Introduction to iOS Game Development with SpriteKit & Swift

Develop your first iOS game using the SpriteKit framework and Swift. A Jump'N'Run with countless awesome features!
4.0 (354 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,107 students enrolled
Last updated 11/2017
English [Auto]
Current price: $119.99 Original price: $199.99 Discount: 40% off
2 days left at this price!
30-Day Money-Back Guarantee
This course includes
  • 10.5 hours on-demand video
  • 2 articles
  • 87 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Thoroughly understand the SpriteKit framework
  • Learn about different Node classes
  • Learn about SKPhysics & SKActions
  • Learn about using the asset catalogue
  • Create amazing worlds and levels with SKTileMapNode
  • Learn game development techniques such as red boxing
  • Develop your own game full of awesome features
  • Get a lot of awesome and unique insights and tips for becoming a top game developer
Course content
Expand all 98 lectures 10:26:44
+ Introduction
2 lectures 03:01

In this video I will introduce myself and briefly talk about what we will be doing with this course

Preview 02:54

Here is a list with everything you will need before we can start. Additionally you can download all of the needed resource files here

Before you start: Resources & Software
+ SpriteKit Crashcourse
17 lectures 01:50:34

We talk about the SpriteKit Framework as well as the general question: What is a framework?

Preview 02:43

We will create our first SpriteKit project together and take a look at some general settings

Preview 07:19

A brief introduction for the classes SKNode & SKScene which are the most fundamental building blocks of any SpriteKit game

Preview 04:41

Let's take a look at a really simple example with SKNode & SKScene instances

Preview 02:16

A brief introduction for the class SKSpriteNode that is used to draw visual content in our games

Preview 02:11

We implement some SKSpriteNodes into our little project to see how we can use them

Preview 16:28

A brief introduction for the class SKAction, that is used to create actions for our nodes in SpriteKit

Preview 02:58

We add some actions to our nodes to see what we can achieve with them

Preview 18:47

A brief introduction to SKPhysics, the physics engine for our SpriteKit games

Preview 05:49

We add physics to our little project and simulate gravity and other awesome stuff

Preview 08:57

A brief introduction to the Asset Catalogue

Preview 01:34

We create a fun little animation in our app using the Asset Catalogue and Sprite Atlases

Preview 11:33

A quick look at the update loop implemented in SpriteKit and all the methods it provides for us

Preview 04:29

A brief introduction to the SKTileMapNode class

Preview 01:50

We take a look at single tile groups and create a simple tile map

Preview 10:52

We create tile groups and take a look at the concept of alternative tiles

Preview 05:52

A quick look at some other node classes provided by the SpriteKit framework

Preview 02:15

This quiz will test the basics of the SpriteKit framework we have learned everything about in this section of the course

SpriteKit Basics Quiz
9 questions
+ Super Indie Run
79 lectures 08:33:08

We take a quick look at the finished app and the structure of our project before beginning to start completely from scratch

Project Overview

We create the project for our game "Super Indie Runner" and change some general settings

Project Setup

We create our tile map and the tile set and learn how we can create levels with these tools

TileMap Part 1

We create an extensions file for the SKNode class, which will contain some important extensions, that will make the work with SKTileMapNodes a lot easier and help us with other reoccurring tasks

SKNode + Extensions

We use our new extensions to load and scale our map in the game

TileMap Part 2

We create a first rough version of our level map and add some decorative elements to it

Tiles & World Sprites

We create the class Layer as a subclass of SKNode. We will use this class to create different layers like background and world in our game

The Layer Class

We create the WorldLayer property in the GameScene and finally achieve movement in the app

Adding the World Layer

We create an enumeration containing different states for our game to be able to pause and start the game

Game States Enumeration

We create the RepeatingLayer class as a subclass of Layer. It will enable us to create endless scrolling images, for example for our background

The RepeatingLayer Class

We add the background image to our game by using the new RepeatingLayer class


We create a new file which will contain all constants we are using in the game


We create the Player class and add the player assets to our project

The Player Class

We implement physics for our game to create gravity


A brief introduction in the implementation of our physical ground where we will develop some special features

Introduction to the physical ground

We begin the implementation of our physical ground

Physical Ground Part 1

We create the platforms that will get the physics bodies in our code

Physical Ground Part 2

We create the GroundNode class and add the didSimulatePhysics method to our class to be able to dynamically observe our ground physics

Physical Ground Part 3

We complete the functionality and logic of our physical ground

Physical Ground Part 4

We begin defining different states for our player which will get different animations

Player Animation Part 1

We implement the AnimationHelper class which will make working with animations a lot easier

The AnimationHelper Class

We use our new AnimationHelper class to animate our player

Player Animation Part 2

We begin implementing a simple jump mechanism for our player

Jumping Mechanism Part 1

We define a new property for Player which will allow us to check wether or not the player is in the air

Jumping Mechanism Part 2

We get to know the concept of physics categories and how we can use them to register contacts between certain physics bodies

Adding Physics Categories

We implement double jumps

Jumping Mechanism Part 3

We implement the short little brake for our fall

Jumping Mechanism Part 4

We add a transparent sprite node as our finish line, which will on contact end our game

Adding the Finish Line

We create the object helper class which will assist us in handling all kinds of different objects in our game

The ObjectHelper Class

We start our enemy chapter by creating static obstacles in the game

Obstacles & Enemies Part 1

We make sure, that our player actually dies when he falls into the abyss

Obstacles & Enemies Part 2

We now add moving enemies to our level and use the animation timeline in the scene editor to easily move and animate them

Obstacles & Enemies Part 3

A brief introduction in the red boxing technique we are going to use to add coins fields in our game

Introduction to Coins

We create the red boxes and add stuff to our ObjectHelper class

Collectibles Part 1

We add the assets for our coins and test our implementation

Collectibles Part 2

We implement a coin counter to get points for collecting coins in the game

Collectibles Part 3

We begin learning about particle effects and emitters

Particle Effects & Animation Part 1

We implement a particle effect for our coins

Particle Effects & Animation Part 2

We add the particle effect to the game and you will get a small challenge to prove your newfound knowledge about particle emitters

Collectibles Part 4

The solution for our challenge with the particle effects

Particle Effects & Animation Part 3 (Solution)

We add more collectibles to the game by adding super coins 

Collectibles Part 5

A brief introduction in the concept of our HUD

Introduction to the HUD

We create the protocol and class for our GameHUD and add a custom font to our application

HUD Part 1

We add the HUD to the game

HUD Part 2

We implement the communication between the game scene and the HUD

HUD Part 3

A brief introduction in the concept for our popups

Introduction to Popups

We add the assets for the popups and create three new classes for them

Popups Part 1

We create the SpriteKit Button class which we can use to create our own buttons in the SpriteKit framework

The SpriteKitButton Class

We implement the class BannerLabel for the titles for our popups

Popups Part 2

We implement the buttons for our PopupNode class

Popups Part 3

A brief introduction to the scoring system of our game

Introduction to the scoring system

We create the score manager struct which will be responsible for handling our scores

Scoring System Part 1

We complete the score manager struct with the compare method to compare scores

Scoring System Part 2

We begin working on our ScorePopupNode class

Popups Part 4

We add two new methods to the ScorePopupNode class

Popups Part 5

We add more methods to the ScorePopupNode class including animation

Popups Part 6

We complete the ScorePopupNode class

Popups Part 7

We are back in our GameScene and add some things for our popups

The PopupButtonHandler Extensions

We add the possibility of pausing the game using on of our new popups

Popups Part 8

We add the implementation for our GameState paused

Popups Part 9

We create a new class for our menu scene

The Menu Scene

A brief introduction to our planned delegation between scenes

Introduction to the SceneManagerDelegate

We implement the sceneManagerDelegate

The SceneManagerDelegate Protocol

A brief introduction to the structure of our level scene

Introduction to the Level Scene

We create the LevelScene class

Level Scene Part 1

We add the buttonHandler method an begin with the layout of our scene

Level Scene Part 2

We implement the level boxes

Level Scene Part 3

We add the Popup method and complete both buttonHandlers in the level scene

Level Scene Part 4

We adapt our game scene to the changes in our project structure to load levels dynamically

GameScene Adaptions

We complete the popups in our game scene

GameScene Popups

We add more enemies and coins to our existing level

Completing the Level

We add a powerup which grants us temporary invincibility


We implement a second finish line that will give us extra points

Adding two Finish Lines

We create a new world with another theme as a grass world

Creating a new World

We add a menu image and a foreground layer in the grass world

Menu Image & Foreground Layer

We add audio to the app by implementing background music as well as sounds for particular events like button taps or collecting coins

Background Music & Sound Effects

We create an app icon and a launch image for our app

App Icon & Launch Image
Fix for LevelBug

Congratulations, you have finished the course! We talk briefly about what you can do next!

What's next?
  • A PC capable of running Xcode 8 or higher (Mac is recommended)
  • The software Xcode 8 or higher (Can be downloaded for free)

This course is about the Sprite Kit framework and how to use it to build your own Game clearly inspired by Nintendo's best selling game Super Mario Run. 

We're going to build this app from scratch meaning you don't have to have any prior experience in game development. 

By the end of this course you will have a complete game you can then publish in the App Store.

The source code and the resources that we provide you with are already of incredible value. However the real value is actually the more than 10 hours of video content, in which we explain everything extremely detailed and if you still have any questions or need help, you can always just message us.

We start this course by giving you a thorough introduction to the SK Framework and its most important components, afterwards we'll jump right into building our game, without having to worry about not understanding what we're doing.

Using SKTileMapNode and the SceneEditor we will learn how to create amazing worlds and levels visually without having to write all of the code.

The Game itself will feature things such as:

  • Enemies
  • Scores
  • Power Ups
  • collectibles and much more.

As it is the case with all of our course we will provide you with all of the resources, project files and source code used in this course.

Though it might be helpful to have a basic knowledge of Swift, it is definitely not required at all. Since you have lifetime access to this course you can take it at your own pace and rewatch any lessons as many times as you like. Therefore this course is the perfect introduction into the amazing world of game development!

Who this course is for:
  • Game Developers
  • Programming Beginners
  • Advanced Programmers