Introduction to iOS Game Development with SpriteKit & Swift
4.5 (41 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
370 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Introduction to iOS Game Development with SpriteKit & Swift to your Wishlist.

Add to Wishlist

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!
Bestselling
4.5 (41 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
370 students enrolled
Last updated 4/2017
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 10.5 hours on-demand video
  • 1 Article
  • 84 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I 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
View Curriculum
Requirements
  • A PC capable of running Xcode 8 or higher (Mac is recommended)
  • The software Xcode 8 or higher (Can be downloaded for free)
Description

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 is the target audience?
  • Game Developers
  • Programming Beginners
  • Advanced Programmers
Students Who Viewed This Course Also Viewed
Curriculum For This Course
97 Lectures
10:26:01
+
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
00:07
+
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
78 Lectures 08:32:26

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

Project Overview
02:49

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

Project Setup
09:17

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

TileMap Part 1
13:23

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
09:12

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

TileMap Part 2
06:39

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

Tiles & World Sprites
10:51

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
07:25

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

Adding the World Layer
06:53

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

Game States Enumeration
06:49

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
04:57

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

Background
08:47

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

Constants
08:31

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

The Player Class
07:31

We implement physics for our game to create gravity

Physics
08:42

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

Introduction to the physical ground
01:56

We begin the implementation of our physical ground

Physical Ground Part 1
04:12

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

Physical Ground Part 2
09:19

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
09:01

We complete the functionality and logic of our physical ground

Physical Ground Part 4
04:31

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

Player Animation Part 1
04:16

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

The AnimationHelper Class
02:55

We use our new AnimationHelper class to animate our player

Player Animation Part 2
10:42

We begin implementing a simple jump mechanism for our player

Jumping Mechanism Part 1
07:54

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
02:55

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
10:22

We implement double jumps

Jumping Mechanism Part 3
03:36

We implement the short little brake for our fall

Jumping Mechanism Part 4
06:20

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

Adding the Finish Line
05:20

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

The ObjectHelper Class
05:46

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

Obstacles & Enemies Part 1
09:50

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

Obstacles & Enemies Part 2
07:46

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
10:39

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

Introduction to Coins
01:35

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

Collectibles Part 1
08:00

We add the assets for our coins and test our implementation

Collectibles Part 2
09:44

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

Collectibles Part 3
07:19

We begin learning about particle effects and emitters

Particle Effects & Animation Part 1
03:51

We implement a particle effect for our coins

Particle Effects & Animation Part 2
06:19

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
04:41

The solution for our challenge with the particle effects

Particle Effects & Animation Part 3 (Solution)
06:39

We add more collectibles to the game by adding super coins 

Collectibles Part 5
12:59

A brief introduction in the concept of our HUD

Introduction to the HUD
01:24

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

HUD Part 1
05:05

We add the HUD to the game

HUD Part 2
14:42

We implement the communication between the game scene and the HUD

HUD Part 3
03:59

A brief introduction in the concept for our popups

Introduction to Popups
00:45

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

Popups Part 1
06:44

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

The SpriteKitButton Class
07:09

We implement the class BannerLabel for the titles for our popups

Popups Part 2
05:36

We implement the buttons for our PopupNode class

Popups Part 3
05:19

A brief introduction to the scoring system of our game

Introduction to the scoring system
01:10

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

Scoring System Part 1
05:13

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

Scoring System Part 2
05:36

We begin working on our ScorePopupNode class

Popups Part 4
02:34

We add two new methods to the ScorePopupNode class

Popups Part 5
09:19

We add more methods to the ScorePopupNode class including animation

Popups Part 6
07:24

We complete the ScorePopupNode class

Popups Part 7
10:56

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

The PopupButtonHandler Extensions
07:37

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

Popups Part 8
05:03

We add the implementation for our GameState paused

Popups Part 9
07:18

We create a new class for our menu scene

The Menu Scene
06:27

A brief introduction to our planned delegation between scenes

Introduction to the SceneManagerDelegate
00:36

We implement the sceneManagerDelegate

The SceneManagerDelegate Protocol
04:18

A brief introduction to the structure of our level scene

Introduction to the Level Scene
00:43

We create the LevelScene class

Level Scene Part 1
05:08

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

Level Scene Part 2
12:32

We implement the level boxes

Level Scene Part 3
09:43

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

Level Scene Part 4
07:38

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

GameScene Adaptions
05:08

We complete the popups in our game scene

GameScene Popups
02:46

We add more enemies and coins to our existing level

Completing the Level
07:38

We add a powerup which grants us temporary invincibility

Powerup
10:32

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

Adding two Finish Lines
06:39

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

Creating a new World
06:59

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

Menu Image & Foreground Layer
07:35

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
09:26

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

App Icon & Launch Image
04:15

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

What's next?
01:17
About the Instructor
Timothy Meixner
4.5 Average rating
994 Reviews
12,779 Students
15 Courses
RUME Academy

I'm currently studying Mobile Media and work as a teacher on Udemy. I have worked in digital publishing and viral marketing for more than four years.

I am also a web and mobile application developer with almost five years of working experience. But my greatest passion is designing and developing mobile games for iOs devices, in either Objective C or Swift.

My teaching philosophy is best described in the words of Benjamin Franklin:

"Tell me and I forget. Teach me and I remember. Involve me and I learn."

I hope that we can create many beautiful things together and learn from each other.

Johannes Ruof
4.5 Average rating
994 Reviews
12,779 Students
15 Courses
RUME Academy

I have been developing iOS applications since 2012 and have years of experience in Objective C Programming. Since Apple announced Swift I have been using it in my programming and can proudly say I have experience since Day 1 of the language.

I am looking forward to sharing my knowledge with my students and hopefully have a positive impact on the lifes of as many people as possible as much as learning new things myself.

"You are never too old to set another goal or to dream a new dream." - C. S. Lewis