Chapter 2 – Tutorials

Informations presented on this page may be incomplete or outdated. You can find the most up-to-date version reading my book Learn Swift by examples. Beginner level

What we will do:
In this part we will implement a method for game board printing. We will also add a class to represent a single ship as well as method checking if ship can be placed in a given "place".

We will learn new things:

extension,
guard,
instance methods and type methods,
optional,
string interpolation,
switch statement,
ternary conditional operator,
tuple.

In this part we cover the following topics

Game board printing method
Type methods
guard statement
String interpolation
Extensions
switch statement
Create Ship class
Mathod checking if ship can be placed
Tuple
More details about optionals
Last step

Source code for this chapter.

Game board printing method

In the Board class an empty printBoard() method was created

func printBoard() {
}

1 2	func printBoard() { }

In this chapter we will implement this method. Before we do this, some printing rules should be explained.

As we know, our game board is divided on rows and columns. Both number are not limited so in consequence it would be hard to use as coordinates both letters and digits -- we will use only digits.

 12345
1.....
2.....
3.....
4.....
5.....

12345

1.....

2.....

3.....

4.....

5.....

As it was stated in the previous chapter, to simplify our further considerations we will add around our game board a one-cell width border of type notAllowed. Other cells are filled with empty value. This border is not a part of a normal game board so we don't index any of its cells.

  12345
 ++++++ <--- border
1+.....
2+.....
3+.....
4+.....
5+.....

12345

++++++ <--- border

1+.....

2+.....

3+.....

4+.....

5+.....

Because there may be a lot of rows, we have to know in advance how many digits are needed to print the last index of it. If for example we decide to have 1234 rows, then we need 4 digits to print it. It means that all of our row indexes should be printed on 4 characters right shifted and left-padded with spaces if needed. Rows number 5, 17, 324 should be printed as

324

1234

Because there may be a lot of columns, we have to know in advance how many digits are needed to print the last index of it. To simplify a little bit our code, let's assume that we will use less than 100 columns. So numbers used as indexes have at most two digits. We will print every digit in separate row. Column number 5 should be printed as

5

while number 17 should be printed as

1
7

Putting all the rules together, our game board, in case of 12 rows and 15 columns, should be printed as

            111111
   123456789012345
  ++++++++++++++++
 1+...............
 2+...............
 3+...............
 4+...............
 5+...............
 6+...............
 7+...............
 8+...............
 9+...............
10+...............
11+...............
12+...............

111111

123456789012345

++++++++++++++++

1+...............

2+...............

3+...............

4+...............

5+...............

6+...............

7+...............

8+...............

9+...............

10+...............

11+...............

12+...............

Type methods

To make it, we need a method determining the number of digits needed to print the largest row number. Such a method is not directly connected with a board -- it is rather universal method which may be used by many other classes or methods. This is why we will put its code in separate class where we will "collect" all helper or useful method. Create the EngineGameBattleshipUtils class with the frame of our method

class EngineGameBattleshipUtils {
    class func determineNumberOfdigits(number: Int) -> Int {
        
    }
}

class EngineGameBattleshipUtils {

class func determineNumberOfdigits(number: Int) -> Int {

}

This code looks almost familiar except class keyword precedings function. All the functions implemented so far were an examples of instance methods. Intance because to use them an instance of a class is needed. We have to create an object and than call an (instance) method on this object. Other words, this kind of methods need object because they operate directly on the objects. With class keyword precedings function we define type methods that is a method which "belongs" to rather a whole type of objects than particular object. In consequence, no object of this type is needed to use this method. The need to determine the number of digits may occur in many different types and is not something typical for Board, Ship or any other batleship game class but rather for integer numbers, no mather where they are used. That is why separate code of this method in a versatile class collecting different utility methods seems to be resonable.

Body of this method may looks like below

	class func determineNumberOfdigits(number: Int) -> Int {
        var value = 10
        
        guard number > 0 else {return 0}
        
        for digits in 1...10 {
            if (value > number) {
                return digits
            }
            value *= 10
        }
        
        return 0
    }

class func determineNumberOfdigits(number: Int) -> Int {

var value = 10

guard number > 0 else {return 0}

for digits in 1...10 {

if (value > number) {

return digits

}

value *= 10

}

return 0

}

We require in our implementation that number argument is a positive integer (as coordinates in our case are always positive integers). To verify this requirement the code like below is typicaly used

	class func determineNumberOfdigits(number: Int) -> Int {
        var value = 10
        
        if number > 0 {
            for digits in 1...10 {
                if (value > number) {
                    return digits
                }
                value *= 10
            }
        }
        
        return 0 
    }

class func determineNumberOfdigits(number: Int) -> Int {

var value = 10

if number > 0 {

for digits in 1...10 {

if (value > number) {

return digits

}

value *= 10

}

return 0

}

As we can see, the whole block of code

            for digits in 1...10 {
                if (value > number) {
                    return digits
                }
                value *= 10
            }

for digits in 1...10 {

if (value > number) {

return digits

}

value *= 10

}

is embraced by if only to prevent them beeing executed in case of required conditions are not fulfilled. In this short snippet it looks acceptable but for longer code, maybe with more nested conditions of this type, we will get few level of code indentation and set of closing curly brackets which may make the code less readable. The main idea of such an if is to check if some required conditions are fulfilled. If not, in most cases further code execution doesn't make any sense. That is why in Swift we gave guards which check all necessary conditions. With guard code looks more natural and let us keep the code that handles a violated requirement next to the requirement.

guard statement

A guard statement, like an if statement, executes statements depending on the logic value of an expression. Unlike an if statement, a guard statement always has an else clause. If the guard statement’s condition is met, code execution continues after the guard statement’s closing brace. Any variables or constants that were assigned values using an optional binding as part of the condition are available for the rest of the code block that the guard statement appears in. If that condition is not met, the code inside the else branch is executed. That branch must transfer control to exit the code block in which the guard statement appears. Other words, if guard statement’s condition is false then execution of the current block code must be aborted.

Equiped with determineNumberOfdigits(number:) function, we may start implement printBoard() method.

	func printBoard() {
		let leadingPadding = EngineGameBattleshipUtils.determineNumberOfdigits(number: rows)
        var leadingPaddingString = ""
        var line = ""
        var digit = 0
        
        for _ in 1...leadingPadding {
            leadingPaddingString += " "
        }
        
        line = leadingPaddingString + " "
        for c in 1...cols {
            digit = c/10
            if digit == 0 {
                line += " "
            } else {
                line += "\(digit)"
            }
        }
        
        print(line)		
	}

func printBoard() {

let leadingPadding = EngineGameBattleshipUtils.determineNumberOfdigits(number: rows)

var leadingPaddingString = ""

var line = ""

var digit = 0

for _ in 1...leadingPadding {

leadingPaddingString += " "

}

line = leadingPaddingString + " "

for c in 1...cols {

digit = c/10

if digit == 0 {

line += " "

} else {

line += "\(digit)"

}

print(line)

}

For a game board with 12 rows and 15 columns this should print

ss#*********111111

1	ss#*********111111

where instead of characters s, # and * spaces are printed -- above this characters are used to clarify how this line is created. Character

s is a part of leadingPaddingString -- in this case this variable is a two-space length string and is created by

Swift

for _ in 1...leadingPadding { leadingPaddingString += " " }

1
2
3

        for _ in 1...leadingPadding {
            leadingPaddingString += " "
        }
# is printed in place of border sorrounding game board and is created by

Swift

line = leadingPaddingString + " "

1

line = leadingPaddingString + " "

* is printed in one-digit column numbers as for them there is no tens digit; this part is created by

        for c in 1...cols {
            digit = c/10
            if digit == 0 {
                line += " "
            } else {
                line += "\(digit)"
            }
        }

for c in 1...cols {

digit = c/10

if digit == 0 {

line += " "

} else {

line += "\(digit)"

}

Notice underscore _ usage in place of a variable name

        for _ in 1...leadingPadding {
            leadingPaddingString += " "
        }

for _ in 1...leadingPadding {

leadingPaddingString += " "

}

We do this every time the value from the set we iterate over is not important for us. In this case we simply want to concatenate space leadingPadding times. Underscore _ is the way we say: I don't care about this value.

String interpolation

The "\(digit)" is how we create "interpretable" strings in Swift, that is strings whose contents depends on some values evaluated during execution. String interpolation is a way to construct such a new string value from a mix of constants, variables, literals, and expressions by including their values inside a string literal. Each item inserted into the string literal and wrapped in a pair of parentheses, prefixed by a backslash \(ITEM) is interpreted and result of interpretation substitutes its call place

let age = 12
let message = "Age \(age): is \(age < 30 ? "young" : "middle-aged")"
print(message)

let age = 12

let message = "Age \(age): is \(age < 30 ? "young" : "middle-aged")"

print(message)

In the example above, the value of age (number 12) is inserted into a string literal in place of \(age). The value of age is also part of a compound expression later in the string where ternary conditional operator is used.

The ternary conditional operator use above is a special operator with three parts, which takes the form question ? answer1 : answer2. It’s a shortcut for evaluating one of two expressions based on whether question is true or false. If question is true, it evaluates answer1 and returns its value; otherwise, it evaluates answer2 and returns its value. The ternary conditional operator is shorthand for the code below:

if question {
    answer1
} else {
    answer2
}

if question {

answer1

} else {

answer2

}

Expression used in message string returns either young or middle-aged string depending on age variable value. Finally this short three-line code shoud print

Age 12: is young

1	Age 12: is young

Read Strings and Characters for complete information about strings in Swift.

Very similar code prints second line with unity digits

        line = leadingPaddingString + " "
        for c in 1...cols {
            digit = c%10
            line += "\(digit)"
        }
        
        print(line)

line = leadingPaddingString + " "

for c in 1...cols {

digit = c%10

line += "\(digit)"

}

print(line)

For a game board with 12 rows and 15 columns this should print

ss#123456789012345

1	ss#123456789012345

so at this moment we should have

ss#*********111111
ss#123456789012345

1 2	ss#*********111111 ss#123456789012345

Remember that characters s, # and * are not realy visible -- here they are used in places of spaces to clarify how both lines are created.

Extensions

Using type method like determineNumberOfdigits(number:) to separate common code which "belongs" to rather a whole type of objects than particular object is one possible option how we can solve this issue. If we pay a lot more attention to it, we discover that in this example determining a number of digits is something we do on particular integer object. Saying the truth we made it as a type method for didactic reasons to describe what a type method is. Now we will show how this type on problems could be acomplish in more swifty style with extensions.

Extensions add new functionality to an existing class, structure, enumeration, or protocol type. What is very important, this includes the ability to extend types for which we do not have access to the original source code. Extensions are declared with the extension keyword:

extension TypeWeExtend {
    // New functionality to add to TypeWeExtend goes here
}

extension TypeWeExtend {

// New functionality to add to TypeWeExtend goes here

}

Let's use this concept to implement another helpful method. This method should enlarge specified string to a given length left padding it with spaces by default or any other character if specified. For example, if string 12 should be transformed into four-character string, this method should return ..12 where dots . are used in a place of spaces to make it visible. Create the EngineGameBattleshipExtensions.swift file and put inside the following code

extension String {
    func leftPadding(toLength: Int, withPad: String = " ") -> String {
        guard toLength > self.count else {return self}
        
        let padding = String(repeating: withPad, count: toLength - self.count)
        
        return padding + self
    }
}

extension String {

func leftPadding(toLength: Int, withPad: String = " ") -> String {

guard toLength > self.count else {return self}

let padding = String(repeating: withPad, count: toLength - self.count)

return padding + self

}

Notice how padding string is created. In determineNumberOfdigits(number:) function a variable leadingPaddingString is created as leadingPadding spaces concatenated together in for loop

        for _ in 1...leadingPadding {
            leadingPaddingString += " "
        }

for _ in 1...leadingPadding {

leadingPaddingString += " "

}

More swifty way is to use initializator with repeating argument. We have seen this in previous chapter in array subsection where for example one-dimensional array containing 5 empty strings was created

var mutableArray3 = [String](repeating: "", count: 5)

1	var mutableArray3 = [String](repeating: "", count: 5)

or in Board initializer where two-dimensional array was created

board = Array(repeating: Array(repeating: .none, count: cols+2), count: rows+2)

1	board = Array(repeating: Array(repeating: .none, count: cols+2), count: rows+2)

Because we extend functionality of String class, self refers to a given string object. So self.count is about the number of characters in it, while padding + self is a concatenation of sequence of spaces (or other character specified as withPad argument) and string itself (padding and self part respectively).

Now we are ready to complete last part of a game board printing method. The rest of the printBoard() code shouldn't be difficult to follow

		for r in 0...rows+1 {
            line = ""

            if r == 0 || r == rows+1 {
                line += leadingPaddingString
            } else {
                line += String(r).leftPadding(toLength: leadingPadding)
            }
            
            for c in 0...cols+1 {
                switch board[r][c] {
                case .empty:
                    line += "."
                case .hit:
                    line += "!"
                case .ship:
                    line += "X"
                case .shot:
                    line += "*"
                case .none:
                    line += "?"
                case .notAllowed:
                    line += "+"
                case .rescue:
                    line += "O"
                }
            }
            
            print(line)
        }

for r in 0...rows+1 {

line = ""

if r == 0 || r == rows+1 {

line += leadingPaddingString

} else {

line += String(r).leftPadding(toLength: leadingPadding)

}

for c in 0...cols+1 {

switch board[r][c] {

case .empty:

line += "."

case .hit:

line += "!"

case .ship:

line += "X"

case .shot:

line += "*"

case .none:

line += "?"

case .notAllowed:

line += "+"

case .rescue:

line += "O"

}

print(line)

}

This code should print board in the form similar to given below

ss#*********111111
ss#123456789012345
ss++++++++++++++++
s1+..............+
s2+..............+
s3+..............+
s4+..............+
s5+..............+
s6+..............+
s7+..............+
s8+..............+
s9+..............+
10+..............+
11+..............+
12+..............+
ss++++++++++++++++

ss#*********111111

ss#123456789012345

ss++++++++++++++++

s1+..............+

s2+..............+

s3+..............+

s4+..............+

s5+..............+

s6+..............+

s7+..............+

s8+..............+

s9+..............+

10+..............+

11+..............+

12+..............+

ss++++++++++++++++

switch statement

For those who are familiar with C-like programming languages it may appear to be strange that all cases in the last part of a printBoard() method are break-less. In C break is used to break execution after completion matching case. In Swift this is a default "mode" as in most cases this is what we expect to happend in switch statement. There is no need of break usage in switch

// No implicit fall through
let text = "one"
switch text {
// Can't use "empty" case
//case "one":
//case "One":
//   print("Case 1")
//Note:
//There is no need to use break statement
case "one", "One":
    print("Case ONE")
case "two", "Two":
    print("Case TWO")
default:
    print("Default")
}

// No implicit fall through

let text = "one"

switch text {

// Can't use "empty" case

//case "one":

//case "One":

// print("Case 1")

//Note:

//There is no need to use break statement

case "one", "One":

print("Case ONE")

case "two", "Two":

print("Case TWO")

default:

print("Default")

}



Case ONE

If we want to use C-style fall through bahaviour a fallthrought keyword must be used. The fallthrough keyword causes code execution to move to the next case or default block on a case-by-case basis. Other words, this is not "global" behaviour for all cases within a given switch but concers only the case inside which fallthrought is used.

switch text {
case "one", "One":
    print("Case ONE")
    fallthrough
case "two", "Two":
    print("Case TWO")
default:
    print("Default")
}

switch text {

case "one", "One":

print("Case ONE")

fallthrough

case "two", "Two":

print("Case TWO")

default:

print("Default")

}



Case ONE

Case TWO

Remember that doing that, the fallthrought does not check the case condition for the switch case that it causes execution to fall into. The fallthrough keyword simply causes code execution to move directly to the statements inside the next case (or default case) block, as in C’s standard switch statement behavior.

var number = 2
switch number {
case 1, 2:
    print("1 or 2")
    fallthrough
case 3, 4:
    print("3 or 4")
default:
    print("all other options")
}

var number = 2

switch number {

case 1, 2:

print("1 or 2")

fallthrough

case 3, 4:

print("3 or 4")

default:

print("all other options")

}



1 or 2

3 or 4

Another improvement in Swift is an ability of switch's cases to check if their values are included in an interval.

// Inteval matching
let number = 12
switch number {
case 1...10:
    print("Range one")
case 11..<15:
    print("Range two")
case 15:
    print("Range three")
default:
    print("Out of range")
}

// Inteval matching

let number = 12

switch number {

case 1...10:

print("Range one")

case 11..<15:

print("Range two")

case 15:

print("Range three")

default:

print("Out of range")

}



Range two

Also tuples can be tested by case statement which can be very handy and allows to simplify our code. Tuples are described later in this chapter but this example is given here for completion. Please go back here when you read about tuples.

var point2D: (Double, Double)
point2D = (2.5, 2)
switch point2D {
case (0, 0):
    print("Origin")
case (_, 0):
    print("Point is on the OX axis")
case (0, _):
    print("Point is on the OY axis")
case (1..<2, 1..<2), (2...3, 2...3):
    print("Point is inside the restricted area")
default:
    print("Free 2D point")
}

var point2D: (Double, Double)

point2D = (2.5, 2)

switch point2D {

case (0, 0):

print("Origin")

case (_, 0):

print("Point is on the OX axis")

case (0, _):

print("Point is on the OY axis")

case (1..<2, 1..<2), (2...3, 2...3):

print("Point is inside the restricted area")

default:

print("Free 2D point")

}



Point is inside the restricted area

Other things which may be useful is the ability to bind the value a switch matches to temporary constants or variables, to be used in the body of the case.

point2D = (0, 5)
switch point2D {
case (0, 0):
    print("Origin")
case (let x, 0):
    print("Point (\(x),0) is on the OX axis")
case (0, let y):
    print("Point (0, \(y)) is on the OY axis")
case let (x, y):
    print("Free 2D point (\(x), \(y))")
}

point2D = (0, 5)

switch point2D {

case (0, 0):

print("Origin")

case (let x, 0):

print("Point (\(x),0) is on the OX axis")

case (0, let y):

print("Point (0, \(y)) is on the OY axis")

case let (x, y):

print("Free 2D point (\(x), \(y))")

}



Point (0, 5.0) is on the OY axis

point2D = (2, 3)
switch point2D {
case (0, 0):
    print("Origin")
case (let x, 0):
    print("Point (\(x),0) is on the OX axis")
case (0, let y):
    print("Point (0, \(y)) is on the OY axis")
case let (x, y) where x > y:
    print("Point (\(x), \(y)) from a 2D subspace")
default:
    print("Eeee...")
}

point2D = (2, 3)

switch point2D {

case (0, 0):

print("Origin")

case (let x, 0):

print("Point (\(x),0) is on the OX axis")

case (0, let y):

print("Point (0, \(y)) is on the OY axis")

case let (x, y) where x > y:

print("Point (\(x), \(y)) from a 2D subspace")

default:

print("Eeee...")

}



Eeee...

Create Ship class

Create a new class, as we did it before, and name it Ship. This class at this moment will have only one component: Direction enumeration used to uniquely identify or position a ship on a game board. Three elements are needed to place a ship

size so we know how many successive cells the ship occupies;
coordinates of the first element so we know when it starts;
direction so we know one of the four possible final location option.

    start column
    |
    |
.........
....u....
....u....
..llXrr..---start row
....d....
....d....
.........

Ship of the size 3
X - first element; it has (start row, start column) coordinates
u - successive cells the ship if it is directed up
d - successive cells the ship if it is directed down
l - successive cells the ship if it is directed left
r - successive cells the ship if it is directed right

start column

.........

....u....

..llXrr..---start row

....d....

.........

Ship of the size 3

X - first element; it has (start row, start column) coordinates

u - successive cells the ship if it is directed up

d - successive cells the ship if it is directed down

l - successive cells the ship if it is directed left

r - successive cells the ship if it is directed right

class Ship {
    enum Direction {
        case up, down, left, right
    }
}

class Ship {

enum Direction {

case up, down, left, right

}

Mathod checking if ship can be placed

As it was explained above, to place a ship on a game board three elements are needed: its size, coordinates of the first element which we will name anchor and direction. So, the header of a mathod checking if ship can be placed may look as follw (put this code in Board class)

func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {
}

1 2	func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool { }

Tuple

Let's stop for a while and explain what is anchor: (row: Int, col: Int). This is an example of tuple. Tuples is a well known concept from script programming languages and something I always want to have in C. Of course we can live without it and mimic with for example arrays or dictionaries but tuples are more natural. Tuples group multiple values into a single compound value. The values within a tuple can be of any type and do not have to be of the same type as each other.

// Tuple of type (Int, String)
let warning = (123, "This is a critical warning")
var (currentMessageCode, currentMessageText) = warning
print ("Message text " + currentMessageText)
print ("Message text \(currentMessageText)")

// Tuple of type (Int, String)

let warning = (123, "This is a critical warning")

var (currentMessageCode, currentMessageText) = warning

print ("Message text " + currentMessageText)

print ("Message text \(currentMessageText)")

If we don't care about the first element of a tuple, we can write it as

(_, currentMessageText) = warning

1	(_, currentMessageText) = warning

We can also use index numbers starting at zero to get tuple's element

print ("Message text " + warning.1)

1	print ("Message text " + warning.1)

To make our code more readable, we can name the individual elements in a tuple when the tuple is defined

let alert = (messageCode: 456, messageText: "This is an alert")
let info = (messageCode: 456, messageText: "This is an information you can simply ignore")

print ("Message text " + alert.messageText)

let alert = (messageCode: 456, messageText: "This is an alert")

let info = (messageCode: 456, messageText: "This is an information you can simply ignore")

print ("Message text " + alert.messageText)

Tuples are great for temporary usage. They are not suited to being use as a complex data structure persisting for a long time. In such a case structures and classes are better choice.

Going back to our method, and trying to implement mayPlaceShip(size:anchor:direction) it, we will probably write

	func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {
		var r: Int!
        var c: Int!
        
        if direction == .up {
            for i in 0...size-1 {
                r = anchor.row + i*(-1)
                c = anchor.col + i*(0)

                guard r>0, r<rows+1 else {return false}
                guard c>0, c<cols+1 else {return false}

                if board[r][c] != .empty {
                    return false
                }
            }
        }
        
        return true
	}

func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {

var r: Int!

var c: Int!

if direction == .up {

for i in 0...size-1 {

r = anchor.row + i*(-1)

c = anchor.col + i*(0)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

return true

}

This code allows to check if ship may be directed up. To chek down direction we will copy existing code, change a little and add to the body of our function

	func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {
		...
        else if direction == .down {
            for i in 0...size-1 {
                r = anchor.row + i*(+1)
                c = anchor.col + i*(0)

                guard r>0, r<rows+1 else {return false}
                guard c>0, c<cols+1 else {return false}

                if board[r][c] != .empty {
                    return false
                }
            }
        }
	}

func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {

...

else if direction == .down {

for i in 0...size-1 {

r = anchor.row + i*(+1)

c = anchor.col + i*(0)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

To check all the direction we need such a spaghetti repetitive code

	func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {
		var r: Int!
        var c: Int!
        
        if direction == .up {
            for i in 0...size-1 {
                r = anchor.row + i*(-1)
                c = anchor.col + i*(0)

                guard r>0, r<rows+1 else {return false}
                guard c>0, c<cols+1 else {return false}

                if board[r][c] != .empty {
                    return false
                }
            }
        } else if direction == .down {
            for i in 0...size-1 {
                r = anchor.row + i*(+1)
                c = anchor.col + i*(0)

                guard r>0, r<rows+1 else {return false}
                guard c>0, c<cols+1 else {return false}

                if board[r][c] != .empty {
                    return false
                }
            }
        } else if direction == .left {
           for i in 0...size-1 {
               r = anchor.row + i*(0)
               c = anchor.col + i*(-1)

               guard r>0, r<rows+1 else {return false}
               guard c>0, c<cols+1 else {return false}

               if board[r][c] != .empty {
                   return false
               }
           }
       } else if direction == .right {
            for i in 0...size-1 {
                r = anchor.row + i*(0)
                c = anchor.col + i*(+1)
                
                guard r>0, r<rows+1 else {return false}
                guard c>0, c<cols+1 else {return false}
                
                if board[r][c] != .empty {
                    return false
                }
            }
        }
        
        return true
	}

func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {

var r: Int!

var c: Int!

if direction == .up {

for i in 0...size-1 {

r = anchor.row + i*(-1)

c = anchor.col + i*(0)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

} else if direction == .down {

for i in 0...size-1 {

r = anchor.row + i*(+1)

c = anchor.col + i*(0)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

} else if direction == .left {

for i in 0...size-1 {

r = anchor.row + i*(0)

c = anchor.col + i*(-1)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

} else if direction == .right {

for i in 0...size-1 {

r = anchor.row + i*(0)

c = anchor.col + i*(+1)

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

return true

}

Notice, thet the only thing changed in each repeated part is row/column "modficator" -- sometimes it is equal +1 if coordinate should be increased, sometimes it is equal -1 if coordinates should be decreased and sometimes it is equal 0 is coordinate should stay unchanged. So let's make this element variable and keep the rest of the code constant

	func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {
		var modifier: (forRow: Int, forCol: Int)!
        var r: Int!
        var c: Int!

        switch direction {
        case .up:
            modifier = (forRow: -1, forCol:  0)
        case .down:
            modifier = (forRow: +1, forCol:  0)
        case .left:
            modifier = (forRow:  0, forCol: -1)
        case .right:
            modifier = (forRow:  0, forCol: +1)
        }

        for i in 0...size-1 {
            r = anchor.row + i*modifier.forRow
            c = anchor.col + i*modifier.forCol

            guard r>0, r<rows+1 else {return false}
            guard c>0, c<cols+1 else {return false}

            if board[r][c] != .empty {
                return false
            }
        }

        return true
	}

func mayPlaceShip(size: Int, anchor: (row: Int, col: Int), direction: Ship.Direction) -> Bool {

var modifier: (forRow: Int, forCol: Int)!

var r: Int!

var c: Int!

switch direction {

case .up:

modifier = (forRow: -1, forCol: 0)

case .down:

modifier = (forRow: +1, forCol: 0)

case .left:

modifier = (forRow: 0, forCol: -1)

case .right:

modifier = (forRow: 0, forCol: +1)

}

for i in 0...size-1 {

r = anchor.row + i*modifier.forRow

c = anchor.col + i*modifier.forCol

guard r>0, r<rows+1 else {return false}

guard c>0, c<cols+1 else {return false}

if board[r][c] != .empty {

return false

}

return true

}

Variable modifier allows us correctly change coordinate depending on the direction.

There is one more thing needed explanation -- mysterious exclamation mark ! just after variable declaration.

More details about optionals

As we know from previous chapter, every object must have a value or must be explicitely defined as optional which is a way to indicate that this object may not have a value. We set an optional variable to a valueless state by assigning it the special value nil. In Swift, nil is used in case of the absence of a value of a certain type. We may say, that nil is a value which tell us, that there is no correct value. If it sounds a little bit crazy, recal NaN "number" which is a sequence of bits interpreted not as a number but as incorrect (nonexisting) numeric values. Optionals of any type we want can be set to nil, not just object types. Conversely, nil cannot be used with nonoptionals. If a variable (rather constant) in our code needs to take no value, we have to declare it as an optional value of the appropriate type. Optional is denoted by question mark ? sufixes type name: Int?, Ship? etc. The key queston is: How we can use optionals? And the answer is not so obvious. We have few options

Simple guess and try approach

Swift

var thisMayBeEmpty: Int? print(thisMayBeEmpty) thisMayBeEmpty = 1 print(thisMayBeEmpty) thisMayBeEmpty = nil print(thisMayBeEmpty)

1
2
3
4
5
6

var thisMayBeEmpty: Int?
print(thisMayBeEmpty)
thisMayBeEmpty = 1
print(thisMayBeEmpty)
thisMayBeEmpty = nil
print(thisMayBeEmpty)

doesn't work - we have Expression implicitly coerced from Int? to Any Swift compile warning in all of three prints and results are not such as we want (Optional(1) instead of 1)
```
nil

Optional(1)

nil
```

If we are sure (but we have to be sure if we don't want to crash our application) that optional contains a non-nil value we can force unwrap its value with an exclamation mark added at the end of the optional's name

print(thisMayBeEmpty!)

if (thisMayBeEmpty != nil){
    print("Have some nonempty value: " + String(thisMayBeEmpty!))
} else {
    print("Nothing to print")
}

print(thisMayBeEmpty!)

if (thisMayBeEmpty != nil){

print("Have some nonempty value: " + String(thisMayBeEmpty!))

} else {

print("Nothing to print")

}

When working with optionals, if-else is something we must use. There is a special syntax we can use in this context. Optional binding is used to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

if let nonempty = thisMayBeEmpty {
    print("Have some nonempty value: " + String(nonempty))
} else {
    print("Nothing to print")
}

if let nonempty = thisMayBeEmpty {

print("Have some nonempty value: " + String(nonempty))

} else {

print("Nothing to print")

}

Notice that for nonempty we don't have to use an exclamation mark.

We can do even more: we can chain together multiple optional bindings, and the entire chain fails gracefully if any link in the chain is nil.

let number1: Int?
let number2: Int?

number1 = 2
number2 = nil

if let value1 = number1, let value2 = number2 {
    print(value1, value2)
} else {
    print("One of values is nil")
}

let number1: Int?

let number2: Int?

number1 = 2

number2 = nil

if let value1 = number1, let value2 = number2 {

print(value1, value2)

} else {

print("One of values is nil")

}

When we are sure that optional has some value every time we will use it, we can "remove" the need to check and unwrap the optional's value every time it is accessed thanks we can assume to have a value all of the time we need it. These kinds of optionals are defined as implicitly unwrapped optionals and we write it by placing an exclamation mark instead of question mark after the type we want to make optional. For example, this code

Swift

var implicitOptional: Int! print(implicitOptional)

1
2

var implicitOptional: Int!
print(implicitOptional)

in contrast to

Swift

var thisMayBeEmpty: Int? print(thisMayBeEmpty)

1
2

var thisMayBeEmpty: Int?
print(thisMayBeEmpty)

doesn't generate any warning or error and we can use implicitOptional variable without need of any explicit unwraping with an exclamation mark

Swift

implicitOptional = 1 print(implicitOptional)

1
2

implicitOptional = 1
print(implicitOptional)
Another handy tool we can use is the nil-coalescing operator ??. When used, for example in expression (a ?? b), it unwraps an optional a if it contains a value, or return a default value b if a is nil. The expression b must match the type that is stored inside a.

Swift

thisMayBeEmpty = nil print(thisMayBeEmpty ?? 3)

1
2

thisMayBeEmpty = nil
print(thisMayBeEmpty ?? 3)

The nil-coalescing operator is a shorthand for

Swift

a != nil ? a! : b

1

a != nil ? a! : b

Last step

In the last step we should add test() method to the EngineGameBattleship class and call it in the main file.

	func test() {
        var x = boardPlayer.mayPlaceShip(size: 4,
                                    anchor: (row: 2, col: 2),
                                    direction: .down)
        
        print(x ? "empty" : "occupied")
        
        x = boardPlayer.mayPlaceShip(size: 4,
                                    anchor: (row: 9, col: 2),
                                    direction: .down)
        
        print(x ? "empty" : "occupied")
        
        x = boardPlayer.mayPlaceShip(size: 4,
                                    anchor: (row: 5, col: 7),
                                    direction: .right)
        
        print(x ? "empty" : "occupied")
        
        x = boardPlayer.mayPlaceShip(size: 4,
                                    anchor: (row: 5, col: 8),
                                    direction: .right)
        
        print(x ? "empty" : "occupied")
    }

func test() {

var x = boardPlayer.mayPlaceShip(size: 4,

anchor: (row: 2, col: 2),

direction: .down)

print(x ? "empty" : "occupied")

x = boardPlayer.mayPlaceShip(size: 4,

anchor: (row: 9, col: 2),

direction: .down)

print(x ? "empty" : "occupied")

x = boardPlayer.mayPlaceShip(size: 4,

anchor: (row: 5, col: 7),

direction: .right)

print(x ? "empty" : "occupied")

x = boardPlayer.mayPlaceShip(size: 4,

anchor: (row: 5, col: 8),

direction: .right)

print(x ? "empty" : "occupied")

}

In test() method we simply do four tests of our mayPlaceShip(size:anchor:direction) method. To call it, change the main file conrents to the form

import Foundation

let game = EngineGameBattleship()
game.printBoards()
game.test()

import Foundation

let game = EngineGameBattleship()

game.printBoards()

game.test()

Now we can run our code. Just after both boads printed, result of a test() method should be displayed

empty
occupied
empty
occupied

empty

occupied

empty

occupied