iOS 9 Game Development Essentials

Let's look at how variables are declared in Swift.

var lives = 3      //variable of representing the player's lives
lives = 1          //changes that variable to a value of 1

Those of us who have been developing in JavaScript will feel right at home here. Like JavaScript, we use the keyword var to represent a variable, and we named the variable lives.

The compiler implicitly knows that the type of this variable is a whole number, the primitive data type Int.

The type can be explicitly declared as such:

var lives: Int = 3    //variable of type Int

We can also represent lives as the floating point data types double or float, as follows:

// lives are represented here as 3.0 instead of 3
var lives: Double = 3           //of type Double
var lives: Float = 3            //of type Float

Using a colon after the variable's name declaration allows us to explicitly typecast the variable.

During your game, there will be points of data that don't change throughout the life of the game or the game's current level/scene. These can be various data, such as gravity, a text label in the Heads-Up Display (HUD), the center point of character's 2D animation, an event declaration, or the time before your game checks for new touches/swipes.

Declaring constants is almost the same as declaring variables.

Using a colon after the variable's name declaration allows us to explicitly typecast the variable.

let gravityImplicit  = -9.8         //implicit declaration
let gravityExplicit: Float  =  -9.8 //explicit declaration

As we can see, we use the keyword let to declare constants.

Here's another example using a string that could represent a message displayed on the screen at the start or end of a stage:

let stageMessage  = "Start!"
stageMessage      = "You Lose!"   //error

Since the string stageMessage is a constant, we cannot change it once it has been declared. Something like this would be better as a variable using var instead of let.

This is a question sometimes asked by new developers and is understandable why it's asked, especially since game apps tend to have a large number of variables and more interchangeable states than an average application. When the compiler is building its internal list of your game's objects and data, more goes on behind the scenes with variables than with constants.

Without getting too much into topics, such as the program's stack and other details, in short, having objects, events, and data declared as constants with the let keyword is more efficient than var. In a small app on the newest devices today, though not recommended, we could possibly get away with this without seeing a great deal of loss in app performance. When it comes to video games, however, performance is critical. Buying back as much performance as possible can allow a better player experience. Apple recommends that when in doubt, always use let at the time of declaration and have the compiler say when to change to var.

As of Swift version 1.2, constants can have a conditionally controlled initial value.

Prior to this update, we had to initialize a constant with a single starting value or be forced to make the property a variable. In Xcode 6.3 and newer, we can perform the following logic:

let x : SomeThing

if condition
{
  x = foo()
}
else
{
  x = bar()
}
use(x)

An example of this in a game could be as follows:

let stageBoss : Boss

if (stageDifficulty == gameDifficulty.hard)
{
  stageBoss = Boss.toughBoss()
}
else
{
  stageBoss = Boss.normalBoss()
}
loadBoss(stageBoss)

With this functionality, a constant's initialization can have a layer of variance while still keeping it unchangeable, or immutable through its use. Here, the constant stageBoss can be one of two types based on the game's difficulty: Boss.toughBoss() or Boss.normalBoss(). The boss won't change for the course of this stage, so it makes sense to keep it as a constant. More on if and else statements is covered later in the chapter.

Here's an example of an array in Swift:

let stageNames : [String] = ["Downtown Tokyo","Heaven Valley","Nether"]

The object stageNames is a collection of strings representing the names of a game's stages. Arrays are ordered by subscripts from 0 to array length -1. So, stageNames[0] would be Downtown Tokyo; stageNames[2] would be Nether; and stageNames[4] would give an error since that's beyond the limits of the array and doesn't exist. We use [] brackets around the class type of stageNames, [String], to tell the compiler that we are dealing with an array of strings. Brackets are also used around the individual members of this array.

A common collection type used in physics calculations, graphics, and game design, particularly grid-based puzzle games, is two-dimensional arrays / matrices. 2D arrays are simply arrays that have arrays as their members. These arrays can be expressed in a rectangular fashion in rows and columns.

For example, the 4x4 (4 rows, 4 columns) tile board in the 15-puzzle game can be represented as follows:

var tileBoard = [[1,2,3,4],
                 [5,6,7,8],
                 [9,10,11,12],
                 [13,14,15,""]]

In the 15 puzzle game, your goal is to shift the tiles using the one empty spot (represented with the blank string ""), to all end up in the 1-15 order as we saw. The game would start with the numbers arranged in a random and solvable order, and the player would then have to swap the numbers and the blank space.

Here are ways to declare blank 2D arrays with strict types:

var twoDTileArray : [[Tiles]] = []     //blank 2D array of type,Tiles
var anotherArray = Array<Array<Tile>>()  //same array, using Generics

The variable twoDTileArray uses the double brackets [[Tiles]] to declare it as a blank 2D array/matrix for the made-up type, tiles. The variable anotherArray is a rather oddly declared array that uses angle bracket characters <> for enclosures. It utilizes what's known as Generics. Generics is a rather advanced topic that we will touch more on later. They allow very flexible functionality among a wide array of data types and classes. For the moment, we can think of them as a catch-all way of working with objects.

To fill in the data for either version of this array, we would then use for-loops. More on loops and iterations will be explained later in the chapter.

This is how we would make a set of various game items in Swift:

var keyItems = Set([Dungeon_Prize, Holy_Armor, Boss_Key,"A"])

This set keyItems has various objects and a character A. Unlike an array, a set is not ordered and contains unique items. So, unlike stageNames, attempting to get keyItems[1] would return an error and items[1] might not necessarily be the Holy_Armor object, as the placement of objects is internally random in a set. The advantage sets have over arrays is that sets are great at checking for duplicated objects and specific content searching in the collection overall. Sets make use of hashing to pinpoint the item in the collections, so checking for items in a set's content can be much faster than in an array. In game development, a game's key items, which the player may only get once and should never have duplicates of, could work great as a set. Using the function keyItems.contains(Boss_Key) returns the Boolean value of true in this case.

A dictionary can be represented this way in Swift:

var playerInventory: [Int : String]  =  [1 : "Buster Sword",  43 : "Potion", 22: "StrengthBooster"]

Dictionaries use a key : value association, so playerInventory[22] returns the value StrengthBooster based on the key 22. Both the key and value could be initialized to almost any class type*. In addition to the inventory example given, we can have the following code:

var stageReward: [Int : GameItem] = [:] //blank initialization
//use of the Dictionary at the end of a current stage
stageReward = [currentStage.score : currentStage.rewardItem]

Dictionaries are like sets in that they are unordered but with the additional layer of having a key and a value associated with their content instead of just the hash key. Like sets, dictionaries are great for quick insertion and retrieval of specific data. In iOS apps and in web applications, dictionaries are used to parse and select items from JavaScript Object Notation (JSON) data.

In the realm of game development, dictionaries using JSON or via Apple's internal data class, NSUserDefaults, can be used to save and load game data, set up game configurations, or access specific members of a game's API.

For example, here's one way to save a player's high score in an iOS game using Swift:

let newBestScore : Void = NSUserDefaults.standardUserDefaults().setInteger(bestScore, forKey: "bestScore")

This code comes directly from a published Swift-developed game named PikiPop, which we will use from time to time to show code used in actual game applications.

Again, note that dictionaries are unordered, but Swift has ways to iterate or search through an entire dictionary. We will go more in depth in the next section and later on when we move on to loops and control flow.

As long as a collection type is a variable, using the var keyword, we can do various edits to the data. Let's go back to our unlockedLevels array. Many games have the functionality of unlocking levels as the player progresses. Let's say that the player has reached the high score needed to unlock the previously locked level 3 (as 3 isn't a member of the array). We can add 3 to the array using the append function:

unlockedLevels.append(3)

Another neat attribute of Swift is that we can add data to an array using the += assignment operator:

unlockedLevels += [3]

Doing it this way however will simply add 3 to the end of the array. So, our previous array [1, 2, 5, 8] is now [1, 2, 5, 8, 3]. This probably isn't a desirable order, so to insert the number 3 in the third spot, unlockedLevels[2], we can use the following method:

unlockedLevels.insert(3, atIndex: 2)

Now, our array of unlocked levels is ordered to [1, 2, 3, 5, 8].

This is assuming though that we know a member of the array prior to 3 is sorted already. There are various sorting functionalities provided by Swift that could help keeping an array sorted. We will leave the details of sorting to our discussions of loops and control flow later in this chapter.

Removing items from an array is just simple. Let's again use our unlockedLevels array. Imagine that our game has an overworld for the player to travel to and from and the player has just unlocked a secret that triggered an event that blocked off access to level 1. Level 1 would now have to be removed from the unlocked levels. We can do it like this:

unlockedLevels.removeAtIndex(0) // array is now  [2, 3, 5, 8]

Alternately, imagine that the player has lost all of their lives and got a Game Over message. A penalty for this could be to lock the furthest level. Though probably a rather infuriating method and us knowing that level 8 is the furthest level in our array, we can remove it using the .removeLast() function of array types.

unlockedLevels.removeLast() // array is now [2,3,5]

Here are some ways to edit a set or a dictionary as a quick guide.

Set

inventory.insert("Power Ring")    //.insert() adds items to a set
inventory.remove("Magic Potion")  //.remove() removes a specific item
inventory.count                   //counts # of items in the Set
inventory.union(EnemyLoot)        //combines two Sets
inventory.removeAll()             //removes everything from the Set
inventory.isEmpty                 //returns true

Dictionary

var inventory = [Float : String]() //creates a mutable dictionary

/*
one way to set an equipped weapon in a game; where 1.0 could represent the first "item slot" that would be placeholder for the player's "current weapon"  
*/
inventory.updateValue("Broadsword", forKey: 1.0)


//removes an item from a Dictionary based on the key value
inventory.removeValueForKey("StatusBooster")

inventory.count                   //counts items in the Dictionary
inventory.removeAll(keepCapacity: false) //deletes the Dictionary
inventory.isEmpty                 //returns false

//creates an array of the Dictionary's values
let inventoryNames = [String](inventory.values)

//creates an array of the Dictionary's keys
let inventoryKeys = [String](inventory.keys)

//(a) outputs every item through the entire collection
  //works for Arrays, Sets and Dictionaries but output will vary
for item in inventory {
    print(item)
}

//(b) outputs sorted item list using Swift's sorted() function
  //works for Sets
for item in sorted(inventory) {
    print("\(item)")
}

//(c) outputs every item as well as its current index
  //works for Arrays, Sets and Dictionaries
for (index, value) in enumerate(inventory) {
    print("Item \(index + 1): \(value)")
}

//(d)
//Iterate through and through the keys of a Dictionary
for itemCode in inventory.keys {
    print("Item code: \(itemCode)")
}

//(e)
//Iterate through and through the values of a Dictionary
for itemName in inventory.values {
    print("Item name: \(itemName)")
}

Here's a sample code in Objective-C:

const int MAX_ENEMIES = 10;  //constant
float playerPower = 1.3;     //variable

//Array of NSStrings
NSArray * stageNames = @[@"Downtown Tokyo", @"Heaven Valley", @" Nether"];

//Set of various NSObjects
NSSet *items = [NSSet setWithObjects: Weapons, Armor,
 HealingItems,"A", nil];

//Dictionary with an Int:String key:value
NSDictionary *inventory = [NSDictionary dictionaryWithObjectsAndKeys:
             [NSNumber numberWithInt:1], @"Buster Sword",
             [NSNumber numberWithInt:43], @"Potion",
             [NSNumber numberWithInt:22], @"Strength",
nil];

Here's the equivalent code in Swift:

let MAX_ENEMIES = 10          //constant
var playerPower = 1.3         //variable

//Array of Strings
let stageNames : [String] = ["Downtown Tokyo","Heaven Valley","Nether"]    

//Set of various NSObjects
var items = Set([Weapons, Armor, HealingItems,"A"])
          
//Dictionary with an Int:String key:value
var playerInventory: [Int : String]  =  [1 : "Buster Sword",  43 : "Potion", 22: "StrengthBooster"]

In the preceding code, we used some examples of variables, constants, arrays, sets, and dictionaries. First, we see their Objective-C syntax and then the equivalent declarations using Swift's syntax. From this example, we can see how compact Swift is compared with Objective-C.

We can also create a string from a mixture of other data types, known as String Interpolation. String Interpolation is rather common in game development, debugging, and string use in general.

The most notable of examples are displaying the player's score and lives. This is how one of our example games, PikiPop, uses String Interpolation to display the current player stats:

//displays the player's current lives
var livesLabel = "x \(currentScene.player!.lives)"

//displays the player's current score
var scoreText = "Score: \(score)"

Take note of the \(variable_name) formatting. We've actually seen this before in our past code snippets. In the various print() outputs, we used this to display the variable, collection, and so on we wanted to get information on. In Swift, the way to output the value of a data type in a string is by using this formatting.

For those of us who came from Objective-C, it's the same as the following:

NSString *livesLabel = @"Lives: ";
int lives = 3;
NSString *livesText = [NSString stringWithFormat:@" %@ (%d days ago)", livesLabel, lives];

Note how Swift makes String Interpolation much cleaner and easier to read than its Objective-C predecessor.

var gameText = "The player enters the stage"
gameText += " and quickly lost due to not leveling up"
/* gameText now says
"The player enters the stage and lost due to not leveling up" */

 let exclamationMark: Character = "!"
gameText.append(exclamationMark)
//gameText now says "The player enters the stage and lost due to not leveling up!"

for character in "Start!" {
    print(character)
}
//outputs:
//S
//t
//a
//r
//t
//!

gameText[gameText.startIndex]              // = T
gameText[gameText.endIndex]                // = !
gameText[gameText.startIndex.successor()]  // = h
gameText[gameText.endIndex.predecessor()]  // = p

Integers represent negative and positive whole numbers, while unsigned integers represent positive whole numbers. Like with C and other programming languages, Swift lets us create various types of integers and unsigned integers from 8, 16, 32, and 64 bits. For example, an Int32 type is a 32-bit integer, while a UInt8 type is an 8-bit unsigned integer. The size of the bits for Ints and UInts represents how much space is being allocated to store the values. Using our UInt8 example, a number made from this type of unsigned Int can only store the values 0-255 (or 11111111 in a base-2 system). This is also known as 1 byte (8 bits). If we need to store numbers larger than 255 or negative numbers, then maybe an Int16 type would suffice as that can store numbers between –32767 and 32767. Usually, we don't have to worry too much about the size allocated by our integer variables and constants. So, using just the class name of Int will work fine in most cases.

Floats are 32bit floating point numbers / fractions, such as pi (3.14), or the golden ratio, phi (1.61803).

In game designing, we work with floating point values and ranges rather often, be it to determine the CGPoint in x and y of a 2D sprite, using linear interpolation for smoothing a game's camera movement in 3D space, or applying various physics forces on an object or 2D/3D vector. The precision needed for each situation will determine if a float is needed or if the 64-bit floating point value, the double is needed. Doubles can be as precise as 15 decimal places, while a float is six decimal places precise.

Objects and, as we'll see, functions on these objects in Swift are type-safe. What this means is that if we perform a function on a string object when the code was expecting an integer, then the compiler will warn us early on in the process. In the vein of game design, if we were to have the player perform an action only an enemy supposed to do, then Swift will know through its inherently type-safe nature.

Swift's type inference is something we've mentioned before. Unlike other languages where you have to declare the object's type every time it's initialized, Swift will infer what type you mean. For example, we have the following:

var playerHealth = 100
//Swift automatically infers that playerHealth is an Int object

Let's imagine that we want to display what caused a player to lose in the game.

var causedGameOver:String? = whatKilledPlayer(enemy.recentAttack)
let text = "Player Lost Because: "
let gameOverMessage = text + causedGameOver  //error

Because the string causedGameOver is optional, Xcode will give us a compile error because we didn't unwrap the optional. To unwrap the value in an optional, we suffix an exclamation point ! at the end of the optional.

Here's our Game Over message code, now fixed using the unwrapped optional:

var causedGameOver:String? = whatKilledPlayer(enemy.recentAttack)
let text = "Player Lost Because: "
let gameOverMessage = text + causedGameOver!  //code now compiles!

We can also force unwrap optionals early at declaration to allow any potential errors to be taken care of at runtime instead of when compiling. This happens often with @IBOutlets and @IBActions (objects and functions linked to various storyboards and other tools that are based on menu/view tools).

@IBOutlet var titleLabel: UILabel!      //label from a Storyboard
var someUnwrappedOptional : GameObject! //our own unwrapped optional

Optional binding is checking whether an optional has a value or not. This is done using the very handy if-let or if-var statements. Let's look back at our earlier code:

var causedGameOver:String? = whatKilledPlayer(enemy.recentAttack)
let text = "Player Lost Because: "
if let gotCauseOfDeath = causedGameOver {
    let gameOverMessage = text + gotCauseOfDeath
}

The code block, if let gotCauseOfDeath = causedGameOver{…}, does two things. First, using the key words, if let, it automatically creates a constant named gotCauseOfDeath and then binds it to the optional causedGameOver. This simultaneously checks whether causedGameOver is nil or has a value. If it's not nil, then the if statement's code block will run; in this case, creating the constant gameOverMessage that combines the text constant with gotCauseOfDeath.

We can use if-var to simplify this even further:

let text = "Player Lost Because: "
if var causedGameOver = whatKilledPlayer(enemy.recentAttack) {
    let message = text + causedGameOver
}

The if-var statement creates a temporary variable using our previously used optional causedGameOver and does a Boolean logic check based on the result of whatKilledPlayer(enemy.recentAttack). The statement is true if there's a non-nil value returned. Note how we don't have to use either wrapped (?) or forced unwrapping (!) of the optional in such a case.

Optional chaining is when we query down into the properties of an object using the dot operator while also doing a nil/value check as we did with optional binding. For example, let's say that we have a game where certain Enemy types can cause a player to lose instantly via an Enemy instance named currentEnemy. In this example, currentEnemy.type would be a string that returns the name of the kind of enemy that hit the player. Optional chaining uses the custom dot modifier ?. while accessing a potentially nil check on a property. Here's the code to get a better idea of how this works:

if let enemyType = currentEnemy?.type {
    if enemyType == "OneHitKill"
    {
      player.loseLife()  //run the player's lost l
    }
}

Chances are that we'd probably not make an enemy without a designated type, but for the sake of understanding optional chaining, observe how this checks for the possible nil object that'd be returned by currentEnemy.type using currentEnemy?.type. Like how the dot operator functions where you can drill down the properties and properties of properties, the same can be done with the recurring ?.per property that is drilled down. In this code, we do a Boolean comparison with == to see if enemyType is the string OneHitKill.

Don't worry if the syntax of the if statement syntax is a bit of a mystery; next, we discuss how Swift uses if statements, loops, and other ways we can control various object data and their functions.

Control flow in any program is simply the order of instructions and logic in your code. Swift, like any other programming language, uses various statements and blocks of code to loop, change, and/or iterate through your objects and data. This includes blocks of code such as if statements, for-loops, do-while loops and Switch statements. These are contained within functions, which make up larger structures like classes.

if player.health <= 0{
   gameOver()
}

if (player.health <=0) && (player.lives <=0){ //&& = "and"
   gameOver()
}

//(a)
if !didPlayerWin { stageLost() }

//(b)
if didPlayerWin
{            
   stageWon()
}
else
{
  stageLost()
}

//(c)
if (enemy == Enemy.angelType){enemy.aura = angelEffects}
else if(enemy == Enemy.demonType){enemy.aura = demonEffects}
else{ enemy.aura = normalEffects }

//(d)
if let onlinePlayerID = onlineConnection()?.packetID?.playerID
{
  print("Connected PlayerID: /(onlinePlayerID)"
}

//(e)
if let attack = player.attackType, power = player.power where power != 0 {
    hitEnemy(attack, power)
}

//(f)
let playerPower = basePower + (isPoweredUp ? 250 : 50)

for itemName in inventory.values {
    print("Item name: \(itemName)")
}

for var index = 0; index < 3; ++index {
    print("index is \(index)")  
}

let limit = 10
var someNumber = 1
for _ in 1...limit {
    someNumber *= 2
}

let score = player.score
var scoreCountNum = 0
while scoreCountNum < score {
    HUD.scoreText = String(scoreCountNum)
    scoreCountNum = scoreCountNum * 2
}

let score = player.score
var scoreCountNum = 0
do {
    HUD.scoreText = String(scoreCountNum)
    scoreCountNum = scoreCountNum * 2
} while scoreCountNum < score

switch (comboX6_counter) {
                
            case 2:
                GCHelper.sharedInstance.reportAchievementIdentifier("Piki_ComboX6", percent: 25)
                break

            case 5:
                GCHelper.sharedInstance.reportAchievementIdentifier("Piki_ComboX6", percent: 50)
                break
                
            case 10:
                GCHelper.sharedInstance.reportAchievementIdentifier("Piki_ComboX6", percent: 100)
                
            default:
                break
                
        }

Up until this point, we have kept from discussing probably the most important aspects of Swift or any OOP languages for that matter—how the language handles functions on objects and how it organizes these objects, object properties, and functions and performs various object-oriented design concepts, such as polymorphism and inheritance with classes, Structs, enums, protocols, and other data structures. There is much more to discuss about how Swift utilizes these concepts, more than we can fit in this chapter but throughout the course of this book, especially as we get into how to use Apple's game-centric SpriteKit and SceneKit frameworks, we will flesh out more on these topics.

-(int) getPlayerHealth() {
    return player.health;
}

- (return_type) method_name:( argumentType1 )argumentName1
joiningArgument2:( argumentType2 )argumentName2 ...
joiningArgumentN:( argumentTypeN )argumentNameN
{
  function body
}

func getPlayerHealth() -> Int {
    return player.health
}
//How we'd use the function
var currentHealth : Int = 0
currentHealth = getPlayerHealth()

func function_name(argumentName1 : argumentType1, argumentName2 : argumentType2, argumentNameN : argumentTypeN) -> return_type
{
  function body
}

//with a Player type as a parameter
func displayPlayerName (player:Player){
     print(player.name)
}

//without any parameters; using a class property
func displayPlayerName(){
     print(currentPlayer.name)
}

In OOP, classes make up the basic frame of an object, its functionality and interactions with other classes, objects, and various data structures, such as protocols, Structs, extensions, generics, and enumerations. In the following chapters, as we begin to structure our games, we will dive deeper into all of these concepts, but for now, let's understand the basics of classes and how they differ in Swift from Objective-C and other languages.

Here's the basic structure of a class in Swift:

//(a)
Global-project wide properties/variables
//(b)
class className : parentClassName, protocolName…protocolnName
{
//(c)
  class scope properties
//(d)
initializers (init(), convenience, required, etc)

//(e)
  func function_name1(argumentName1 : argumentType1, argumentName2 :    argumentType2, argumentNameN : argumentTypeN) -> return_type
 {
   function-scope variables and body
 }
                         .
                         .
                         .
  func function_nameN(argumentName1 : argumentType1, argumentName2 :    argumentType2, argumentNameN : argumentTypeN) -> return_type
 {
   function-scope variables and body
 }
//(f)
deinit()

} // end of the class
//(g)
global-project wide properties/variables (alternative position)

The Swift class structure works somewhat similar to what we see in C# and Java, as opposed to Objective-C's two files' (.h/header, .m/.mm/ implementation) setup: