Global Nerdy

Even though the new iOS and new iPhones have finally been released, it’s still the early days of the iOS 8/Swift era. The language is still evolving, people are still trying to figure out how to best make use of its features, and there are no veterans. It’s not too late for you to get started with iOS development.

In this article, I’ll look at some Swift/iOS 8 tutorials of note, including one that I’ll be reviewing regularly.

Before you begin: Xcode 6.0.1 now available!

You may have missed it amidst all the hoopla about the new iPhones and upcoming Apple Watch: Xcode has already undergone its first post-iOS 8 update. Xcode 6.0.1 was released on Wednesday, September 17th — get it now!

The iOS Apprentice, Third Edition

When people ask me the question “What tutorial would you recommend for getting started with iOS programming?”, my answer is consistently The iOS Apprentice, published by RayWenderlich.com and written by Matthijs Hollemans. I recommend it to both people who are completely new to programming, as well as experienced developers who want to get the hang of iOS programming.

In 4 tutorials spanning 900 pages, Matthijs takes the reader from building a simple “Hello World” app and through all sorts of iOS development topics from UI controls to common iOS design patterns to working with location and mapping to storing data to accessing web services and more. The iOS Apprentice is written in a casual style and packed with screenshots and illustrations to make sure that you get the point. The third edition has been rewritten for programming in Swift and using the iOS 8 SDK, he also covers the Swift programming language.  With the tutorials, you also get each app’s full source code and assets, which you can reuse in your own apps.

Part 1 of the third edition is available right now, and it’s free if you subscribe to RayWenderlich.com’s newsletter. You have to buy The iOS Apprentice to get parts 2 through 4, and the third edition of these parts will become available in the coming weeks (in the meantime, you’ll be able to get the 2nd edition, which is in Objective-C and covers iOS 7’s SDK).

All four parts of The iOS Apprentice are a great deal at $54, and it was helped me get up to speed with iOS programming very quickly. I can’t recommend it highly enough. Bonus: If you bought an earlier edition of The iOS Apprentice, you get the third edition for free!

Find out more about The iOS Apprentice on its page at RayWenderlich.com.

(By the bye, you should check out RayWenderlich.com regularly; it’s a great source of iOS programming info.)

Swift for Rubyists / Swift for JavaScript Developers

If Ruby is your native tongue, JP Simard (an iOS developer at Realm) can help ease you into Swift programming in his 50-minutes-and-change session titled Swift for Rubyists. The video above is only part of the experience; you should go to the Swift for Rubyists blog entry on Realm’s site where you can see the video synced up with his slides and read the transcript of his presentation, complete with code.

If you’re more comfortable with JavaScript, JP also gave a presentation of Swift for JavaScript developers. It’s from the end of July, and while some details may have changed between then and Swift 1.0, most of it should still be applicable today.

(You might also want to check out Realm itself; it’s a mobile database and API that replaces Core Data and SQLite. They’re also working on an Android version.)

Free Swift/iOS game programming tutorial

Bloc, “the world’s largest online bootcamp”, offers a free tutorial in which you learn iOS game programming in Swift and Sprite Kit by building Swiftris (pictured above), a version of the classic game Tetris.

I’ll be your guinea pig: Going through Rob Percival’s “Complete iOS 8 and Swift Course”

Rob Percival’s courses on Udemy have an impressive number of five-star ratings. His Complete Web Developer Course has over 900 five-star reviews, and his iOS 7/Objective-C course has earned rave reviews. He’s updated his iOS course, which is now called The Complete iOS 8 and Swift Course, which makes the claim of being “THE most comprehensive, cost-effective and career-enhancing mobile app development course you’ll find on the web – or your money back.”

In the course, you learn iOS 8 and Swift development by building “15 Real World Apps” over 145 lectures and over 19 hours of content, starting from the basics and working your way up to building clones of Instagram and Snapchat. He even throws in some very tempting extras, including:

• A tutorial on loading OS X and Xcode on a Wintel machine so you don’t need to use a Mac
• Unlimited web hosting for one year (“worth $200”) and a WordPress tutorial so that you can set up a site with which to promote your apps
• A copy of his ebook, How to Earn $10,000 While Learning to Code
• Over 1,000 graphical assets (“worth $300”) to use in your own apps

If you’ve every stumbled across an ad for the course or the page for the course itself, you may have wondered “Is this course everything it claims to be?”. I’ve wondered myself, and I’ve decided to give it a try. I signed up for the course (thanks to a very short-lived deal where it was available for a mere $29) and will go through every lesson, lecture, and exercise. I’ll report my findings regularly here on Global Nerdy.

This article is part two in a series that looks at a simple “Shoot ‘Em Up”-style game for iOS written using Sprite Kit and Swift. If you missed the first installment, which provides the complete code, the necessary graphics and sound resources, as well as instructions for assembly, it’s here.

In this article, we’ll look at:

• How the code is organized, both in the way it’s ordered, and through the use of MARK: comments, and
• The operator overloads and extensions to CGPoint that support vector math

How the code is organized, and those MARK: comments

The code in the Simple Shoot ‘Em Up game is divided into two major sections:

1. A set of operator overrides and extension properties for doing vector math on CGPoints
2. The GameScene class, which defines the entire game

The GameScene class is divided into three subsections:

1. Properties
2. Event-handling methods
3. Game state methods

Each section is marked with a MARK: comment. If you’re familiar with iOS development with Objective-C, // MARK: is Swift’s answer to good ol’ #pragma mark. If you’re not familiar with #pragma mark, read on…

Organizing code with MARK: comments

There’s a jump bar at the top of every editor window in Xcode, which makes it easy to navigate throughout your project. If you’re editing the GameScene.swift file (go edit it right now if you’re not), it should look like this:

Click on the part of the jump bar just to the right of GameScene.swift, as shown below:

A menu will appear. It will display the various named entities — functions, classes, properties, methods, and so on — inside GameScene.swift:

You might notice that the menu lists the entities in the order in which they appear in the code, and that they’ve been organized into the following sections. You’ll see that:

• There’s a line above each major section: one for the vector math stuff, and one for the GameScene class, and
• The code has named sections, namely:
  • Vector math operators and CGPoint extensions: A set of operator overloads and extension properties to allow for vector math on CGPoints.
  • Properties: Properties of the GameScene class.
  • Events: Methods that respond to events.
  • Game state: Methods that change the game state.

These divisions were created using MARK: comments:

• The Properties, Events, and Game state sections were created using the comments // MARK: Properties, // MARK: Events, and // MARK: Game state respectively,
• The Vector math operators and CGPoint extensions section, complete with a line above it, was created using the comment // MARK: - Vector math operators and CGPoint extensions. Note the - (minus sign) that comes between // MARK: and the section name.
• The dividing line separating the vector math stuff and the GameScene class was created with the comment // MARK: - — that is, // MARK: followed by a - (minus sign with nothing after it).

Using // MARK: and its Objective-C cousin, #pragma mark to organize your code is a good habit to take up.

Vector math

In the game, the player’s ship remains stationary and dead-center at the bottom of the screen. The player shoots at the aliens passing overhead by tapping on the screen, and the ship fires shots in the direction of that tap:

In order to program this action, we’ll need to make use of vector math.

Before we begin: Sprite Kit’s coordinate system

Most UI and computer graphics programming systems have their origin at the upper right-hand corner of the screen, with X increasing as you go rightward, and Y increasing as you go downward. Sprite Kit is based on OpenGL, which uses the same coordinate system that you use in math, with X increasing as you go rightward, and Y increasing as you go upward:

With this coordinate system, the origin (0, 0) is located at the lower left-hand corner of the screen rather than the upper left-hand corner.

Vectors and points

An ordered pair (x, y) can represent:

• A point located at (x, y), or
• A vector that starts at (0, 0) and ends at the point (x, y)

We’re going to use the connection between point coordinates and vector coordinates to create some overloads and extensions that will help simplify programming our game.

Vector addition

The first overload we’ll implement will allow us to add two vectors together, as pictured below:

If you take a vector (x1, y1) and add another vector (x2, y2) to it, the resulting vector is (x1 + x2, y1 + y2).

In Swift, we’ll implement vector addition by taking advantage of the point coordinate/vector coordinate connection and use CGPoints to represent vectors. As a result, our vector addition overload of the + operator takes two CGPoints (x1, y1) and (x2, y2), and returns the vector sum (x1 + x2, y1 + y2):

// Vector addition
private func + (left: CGPoint, right: CGPoint) -> CGPoint {
  return CGPoint(x: left.x + right.x, y: left.y + right.y)
}

With this overload, you can add any two vectors represented by CGPoints just by adding them with the + operator.

Vector subtraction

It’s easy to picture vector addition, but it’s a little harder to picture vector subtraction. The diagram below should help:

Subtracting a vector is easy to see in equation form: taking a vector (x1, y1) and subtracting another vector (x2, y2) gives you a resulting vector (x1 – x2, y1 – y2). Here’s our game’s implementation of vector subtraction:

// Vector subtraction
private func -(left: CGPoint, right: CGPoint) -> CGPoint {
  return CGPoint(x: left.x - right.x, y: left.y - right.y)
}

This overload lets you subtract a vector represented by a CGPoint from another vector represented by a CGPoint through the use of the - operator.

Vector multiplied by a scalar

Multiplying a vector by a scalar preserves the vector’s direction, but changes its magnitude:

Multiplying a vector (x, y) by a scalar k gives you the resulting vector (kx, ky). Here’s how we implement vector-scalar multiplication in our game:

// Vector * scalar
private func *(point: CGPoint, factor: CGFloat) -> CGPoint {
  return CGPoint(x: point.x * factor, y:point.y * factor)
}

With this overload, you use the * operator to multiply a vector represented by a CGPoint by a scalar factor represented by a CGFloat. Note that order is very important in this operation: the first operand must be the vector, and the second operand must be the scalar — it won’t work the other way around!

Length of a vector and normalizing a vector

We’ll need to get the length of a vector, and for that we’ll use the Pythagorean theorem:

Being able to get the length of a vector will come in handy when we want to normalize it. By “normalizing”, we mean preserving its direction, but changing its length to 1:

I wrote an extension to the CGPoint struct that provides two properties:

• length, which returns the length of a vector represented by a CGPoint, and
• normalized, which returns a CGPoint representing 1-unit-long vector that has the same direction as the vector in question.

Here’s the code:

private extension CGPoint {
  // Get the length (a.k.a. magnitude) of the vector
  var length: CGFloat { return sqrt(self.x * self.x + self.y * self.y) }
   
  // Normalize the vector (preserve its direction, but change its magnitude to 1)
  var normalized: CGPoint { return CGPoint(x: self.x / self.length, y: self.y / self.length) }
}

Next steps

With the code organization explained and the vector math taken care of, we’ll cover the actual workings of the game in the next installment.