Before we move on to how Swift handles one of the main topics of OOP, functions and classes, let's quickly run through if-else statements. An if statement checks whether a Boolean statement is true or false. We have the example as follows:

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

This checks whether or not the player's health is less than or equal to 0, designated by the <= operator. Note that Swift is OK with there not being parenthesis, but we can use this if we wish or if the statement gets more complicated, as in this example:

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

Here, we check not just whether the player has lost all of their health, but also if all of their lives are gone with the and (&&) operator. In Swift, like in other languages, we separate out the individual Boolean checks with parentheses, and like other languages, we do a logic-or check with two bar keys (||).

Here are some more ways to write if statements in Swift with the added key words, else-if and else, as well as how Swift can check if-not a certain statement:

//(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)

Let's look at what we put in the code:

We touched on for-in loops before dealing with collections. Here again is a for-in loop in Swift that will iterate through a collection object:

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

For some of us programmers who are used to the older way of using for-loops, don't worry, Swift lets us write for-loops in the C-style, which many of us are probably used to:

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

Here's another way of using a for-loop without using an index variable, noted with the underscore character _ but of course using a Range<Int> object type to determine how many times the for-loop iterates:

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

Note the … between the 1 and limit. This means that this for-in loop will iterate from 1-10. If we wanted it to iterate from 0 to limit-1 (similar to iterating between the bounds of an array's index), we could have instead typed 0..<limit where limit is equal to the array's .count property.

Another very common iteration loop in programming is the do-while loop. Many times we can just utilize the while portion of this logic, so let's look into how and why we might use a while loop:

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

In game development, one use of the while loop (though executed differently in a game app, this accommodates iterating once per frame) is for displaying the counting up of a player's score from 0 to the score the player reached—a common esthetic of many games at the end of a stage. This while loop will iterate until it reaches the player's score, displaying on HUD object showing the intermediate values up until that score.

A do-while loop is practically the same as the while-loop with the extra caveat of iterating through the code block at least once. The end-stage score count example can also illustrate why we would need such a loop. For example, let's imagine that the player did really bad and got no score when the stage ended. In the while loop given, a score of zero won't let us enter the block of code in the while loop since it doesn't fulfill the logic check of scoreCountNum < score. In the while loop, we also have code that displays the score text. Though maybe embarrassing to the player, we would want to count up to the score and more importantly, still display a score. Here's the same code done with a do-while loop:

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

Now score text will display even if the player scored nothing.

Switch statements are useful when we wish to check many different conditions of an object in a fully encompassing and neat way without having a wall of else-if statements. Here's a code snippet from the game PikiPop that uses a Switch statement from the game, PikiPop, that sets the percentage a GameCenter achievement (in this case, a 6x combo) based on the number of times the combo was achieved by the player. Don't worry too much about the GameCenter code (used with the GCHelper singleton object); that's something we will go over in future chapters when we make games in SpriteKit and SceneKit.

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
                
        }

The switch statement here takes the variable used to count how many times the player hit a 6X combo, comboX6_counter, and performs different tasks based on the value of comboX6_counter. For example, when the player has done a 6X Combo twice, the Piki_ComboX6 achievement gets 25% fulfilled. The player gets the achievement (when at 100%) when the counter hits 10. The purpose of the keyword break is to tell the loop to exit at that point; otherwise, the next case block will iterate. Sometimes, this might be desired by your game's logic, but keep in mind that Swift, like many other languages, will continue through the switch statement without break. The keyword default is the catch-all block and is called when the value of the item checked by the switch statement is anything but the various cases. It can be thought of as an equivalent to the else{} block, while all of the cases are similar to else if(){}. The difference though is that Swift requires all cases of the switch be handled. So, though we can suffice with an if without an else, we have to have a default case for a switch statement. Again, this is done to keep Swift code safe and clean earlier in the coding process.

In Objective-C, functions are written the following way:

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

This is a simple function that returns the player's health as an integer—the Int equivalent in Objective-C.

The structure of the function/method is as follows in Objective-C:

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

Here's the same function in Swift:

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

This is how a function is structured in Swift:

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

Note how we use the keyword func to create a function and how the argument/parameter names are first with the types second, separated by the colon (:) and within parenthesis.

Here's what a typical void function looks like in Swift. A void-type function is a function that doesn't return a value.

//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 a void function, there's no need to write ->returnType, but even if there are no parameters, we do have to put in the () parenthesis at the end of the function name.