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:
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!
In this video I will introduce myself and briefly talk about what we will be doing with this course
Here is a list with everything you will need before we can start. Additionally you can download all of the needed resource files here
We talk about the SpriteKit Framework as well as the general question: What is a framework?
We will create our first SpriteKit project together and take a look at some general settings
A brief introduction for the classes SKNode & SKScene which are the most fundamental building blocks of any SpriteKit game
Let's take a look at a really simple example with SKNode & SKScene instances
A brief introduction for the class SKSpriteNode that is used to draw visual content in our games
We implement some SKSpriteNodes into our little project to see how we can use them
A brief introduction for the class SKAction, that is used to create actions for our nodes in SpriteKit
We add some actions to our nodes to see what we can achieve with them
A brief introduction to SKPhysics, the physics engine for our SpriteKit games
We add physics to our little project and simulate gravity and other awesome stuff
We create a fun little animation in our app using the Asset Catalogue and Sprite Atlases
A quick look at the update loop implemented in SpriteKit and all the methods it provides for us
We take a look at single tile groups and create a simple tile map
We create tile groups and take a look at the concept of alternative tiles
A quick look at some other node classes provided by the SpriteKit framework
This quiz will test the basics of the SpriteKit framework we have learned everything about in this section of the course
We take a quick look at the finished app and the structure of our project before beginning to start completely from scratch
We create the project for our game "Super Indie Runner" and change some general settings
We create our tile map and the tile set and learn how we can create levels with these tools
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
We use our new extensions to load and scale our map in the game
We create a first rough version of our level map and add some decorative elements to it
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
We create the WorldLayer property in the GameScene and finally achieve movement in the app
We create an enumeration containing different states for our game to be able to pause and start the game
We create the RepeatingLayer class as a subclass of Layer. It will enable us to create endless scrolling images, for example for our background
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
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
We begin the implementation of our physical ground
We create the platforms that will get the physics bodies in our code
We create the GroundNode class and add the didSimulatePhysics method to our class to be able to dynamically observe our ground physics
We complete the functionality and logic of our physical ground
We begin defining different states for our player which will get different animations
We implement the AnimationHelper class which will make working with animations a lot easier
We use our new AnimationHelper class to animate our player
We begin implementing a simple jump mechanism for our player
We define a new property for Player which will allow us to check wether or not the player is in the air
We get to know the concept of physics categories and how we can use them to register contacts between certain physics bodies
We implement double jumps
We implement the short little brake for our fall
We add a transparent sprite node as our finish line, which will on contact end our game
We create the object helper class which will assist us in handling all kinds of different objects in our game
We start our enemy chapter by creating static obstacles in the game
We make sure, that our player actually dies when he falls into the abyss
We now add moving enemies to our level and use the animation timeline in the scene editor to easily move and animate them
A brief introduction in the red boxing technique we are going to use to add coins fields in our game
We create the red boxes and add stuff to our ObjectHelper class
We add the assets for our coins and test our implementation
We implement a coin counter to get points for collecting coins in the game
We begin learning about particle effects and emitters
We implement a particle effect for our coins
We add the particle effect to the game and you will get a small challenge to prove your newfound knowledge about particle emitters
The solution for our challenge with the particle effects
We add more collectibles to the game by adding super coins
A brief introduction in the concept of our HUD
We create the protocol and class for our GameHUD and add a custom font to our application
We add the HUD to the game
We implement the communication between the game scene and the HUD
A brief introduction in the concept for our popups
We add the assets for the popups and create three new classes for them
We create the SpriteKit Button class which we can use to create our own buttons in the SpriteKit framework
We implement the class BannerLabel for the titles for our popups
We implement the buttons for our PopupNode class
A brief introduction to the scoring system of our game
We create the score manager struct which will be responsible for handling our scores
We complete the score manager struct with the compare method to compare scores
We begin working on our ScorePopupNode class
We add two new methods to the ScorePopupNode class
We add more methods to the ScorePopupNode class including animation
We complete the ScorePopupNode class
We are back in our GameScene and add some things for our popups
We add the possibility of pausing the game using on of our new popups
We add the implementation for our GameState paused
We create a new class for our menu scene
A brief introduction to our planned delegation between scenes
We implement the sceneManagerDelegate
A brief introduction to the structure of our level scene
We create the LevelScene class
We add the buttonHandler method an begin with the layout of our scene
We implement the level boxes
We add the Popup method and complete both buttonHandlers in the level scene
We adapt our game scene to the changes in our project structure to load levels dynamically
We complete the popups in our game scene
We add more enemies and coins to our existing level
We add a powerup which grants us temporary invincibility
We implement a second finish line that will give us extra points
We create a new world with another theme as a grass world
We add a menu image and a foreground layer in the grass world
We add audio to the app by implementing background music as well as sounds for particular events like button taps or collecting coins
We create an app icon and a launch image for our app
Congratulations, you have finished the course! We talk briefly about what you can do next!
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.
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