Good morning, everybody. We're here to talk about OS X, right? Game Center for OS X, specifically Game Center for OS X. Hopefully you've seen some of the earlier slides. Excuse me, Kristy, who just talked about multiplayer gaming, is awesome. And one of my favorite topics, because I think all games should be multiplayer. But we're here to talk about Game Center for OS X.

I hope that shows up. It's a little tight. It says, welcome back. I'm Norman. Well, actually, he's Norman. Norman will be helping me by coming on stage and showing a demo of Crush. You hopefully saw the demo two days ago, yesterday, yesterday in Dan's talk. So we've taken what Megan and Dan did and did a little OS X spin on it. So welcome to everybody. Welcome back for me. Welcome back to my crew. We've been doing Game Center for a few years and this is really exciting.

Because now we have it on OS X and it's cross-platform and it works with all the iOS devices that are out there now. You don't have to wait for iOS 6 for these features. So as I mentioned, Game Center is new for OS X Mountain Lion. This is the first release we have for OS X and we think it's great. It's the exact same community. So everybody who's been playing, I think there's a hundred people. 125 million users, something like that, have access, already have accounts, already have friends.

So we can leverage that. You can leverage that when you're building your games. This is great. And of course, multiplayer features. You can compete with all 125 million. And after this, maybe you'll have some insight how to create a game that works on both platforms to have the most fun.

So I'm going to be talking about the API that we're delivering. I'm going to be talking about the user interface that your users will be using. And I'm going to be talking about this from the context of OS X. So specifically, a little bit of a repeat here. Game Center API for OS X, what's available to you? How do you use it? We're going to show you a little bit about how to set up a project. So this is slightly new.

It's similar to what we've done with the previous OS X. So this is a little bit about what you've done for iOS and how you get something into the iOS app store. We'll talk a little bit about the OS X app store, the Mac app store. Primarily, I'm going to try to focus on the differences between iOS and OS X. There's so much documentation out there now for Game Center. We've done presentations at WWDC for the last two years. All those are available online.

There's developer documentation also on the developer site. And if we have some chance, we'll be doing that. And then, of course, I'll talk to you about some best practices when creating your games for OS X. So we'll go into this. Game Center as a whole is really comprised of exactly three pieces.

Game Center services is large, but there's an application that the users use. There's the framework, which you guys as developers use. And then there's the services, which you need to -- which, as a developer, you use to set up leaderboards, and so on. And then there's the services, which you need to -- which, as a developer, you use to set up leaderboards, and so on.

up leaderboards, achievements, group gaming which is new, which will allow you to share your leaderboards and achievements across different apps. So they could be an app designed for an iPad and an iPhone and an OSX app, that's the new part of it. Which is really awesome and it works today. And in fact I've been told that some people are already trying it out, which is great.

As developers I hope you all downloaded the SDK. We're going to be around this afternoon and tomorrow in the lab. That's really your best resource. This slide is going to be online in a couple of weeks, a few weeks I think. So let's talk about the Game Center app to start with. So I'm just going to give you a run through because if you're familiar with iOS, this should look identical, almost identical.

This is the page that you see when you log in. So you have access to change your status, your account, your photos. All the apps that are shown are top apps in the Mac App Store. So it allows better discovery. You want to be on your top app and one of the ways to do that is Game Center and will help promote your app. The other one is friends.

So you can see your friends, see what games your friends are playing, see what games in common you have so that you can actually go and invite him to play a game. There's also a couple sections. If you scroll down, you'll see OS X games. This is the new section as well as what games your friend has on iOS, which you can't see in this screenshot. Then of course there's the game section. The top bar represents recommendations.

These are all OS X game recommendations. And shows all your OS X games here. Again, this screen is much larger and you can scroll through and see your iOS games. But you'll actually have the ability to look at your achievements, the leaderboards for each of the games, compare similar to iOS. And then the request page. So in this case, Mikey has requested to be my friend and I can ignore him or accept it. Accept it, more friends, more games, more fun.

So we really like that. That in a nutshell was the app. But you guys are all developers, right? And you're really here to find out about the framework. GameKit framework. It's even got the same name. So we've worked really hard to try to make the GameKit framework on OS X equivalent to the GameKit framework on iOS. Because we assume that you've got some knowledge, some experience, and you're going to be able to use it.

So we've got some experience, hopefully, because you all have apps on the app store. And when moving to a new platform, we wanted to try to keep it as much the same as possible to ease your life. You'll see when Norman comes up, he'll show you some magic in Xcode and you'll see how similar it really is. So this might end up being a short talk because there aren't a lot of differences. But I'll go over an overview of the GameKit framework.

We provide you UI for you to use. We provide you UI for you to show leaderboards really easily. It's two or three lines of code. It's almost identical to iOS. The major differences you'll find is in OS X under AppKit, you have a multi-window environment. In iOS, it's a single window environment and everything's presented modally on top of that. But here we see a leaderboard for our demo game. With me up there. So I'm one of Norman's friends.

That's great. Achievements. You can see the achievements inside your game. Again, really easy to do. And of course, multiplayer. My favorite feature. And here you can see Norman's just about to invite me to a game. But we'll get back to this. You'll see more in the demo. It's really cool when you get to see all this stuff live.

So the functionality of the game kit, this is just sort of a list of what you would want to do or what features we give to you that you can put into any game. So single player games can be more fun and more competitive if you add leaderboards and achievements. You don't need to have a multiplayer game to have competition. So we have access to players. Players have profiles.

You can authenticate your players. The players have friends. You can see your players' friends. You can see your players' friends' photos. And of course, leaderboards and achievements. Submitting achievements is the same. Submitting scores is the same. There are subtle differences, and we'll get into that. And of course, there's all these multiplayer features. This is, I think everybody should strive to try to make multiplayer a reality in your game. So, auto-matching.

It's the same auto-match system. Invites work similarly. And in fact, when you're going into group gaming and you've listed on iTunes Connect that you have a compatible game, when you send an invite, it goes to all of the devices that have that game. So you can send an invite and receive it on both an iPad and a MacBook Pro, and you can decide where you want to play the game. That's really cool, and it works.

It works with all the iOS devices that are out there now. And I'll get into that a little bit. So peer-to-peer networking. You can set up a match, a GK match, as Christy eloquently described in the last session. How to communicate, how to check for player statuses, all of that is almost identical. And then there's voice chat and turn-based gaming.

So, feature parity. I wanted to bring this up again because I want you to know how hard we strive to make it ideally the same. So, if you've already got a game... That has these features on iOS. It's really simple, at least for the Game Center parts of it, to make it work on OS X. So players are a GK player, and authentication is handled the same, and it has the same properties as a GK player. We're feature parity with iOS 5 because Mountain Lion is shipping in a month, approximately, and we want it to work cross-platform right out the gate.

So all of you with iOS 5 devices can join in the fun. Leaderboard. So GK score is identical. GK leaderboard view controller. Achievements. There's a GK achievement descriptions. There's GK achievements. They're all identical. Submitting achievements is exactly the same. Matchmaking is handled exactly the same. So you have a GK matchmaker view controller. You present the view controller. We handle all the state transitions of sending invites, notifications, accepting invites, connecting people. So the multiplayer. Turn-based matches, exactly similar. And of course, voice chat works across devices, too.

There are, however, some differences. There have to be some differences. The biggest difference comes from the object hierarchies between OS X and iOS. And everything in iOS land uses the UIKit framework. And the UIKit framework gives you things like UI view controllers and UI images. In OS X, we're underneath the app kit. And the app kit gives you things like NS view controllers and NS images. In iOS, there's essentially one window. And everything is presented as view controllers stacked up on top.

Whereas in OS X, it's a multi-windowed environment. So when you want to show one of our leaderboards or achievements, it actually is a separate window, and you can move it around. But what we've done is we've added a class. So these are the differences. Pretty much the only differences from a Game Center perspective between iOS and OS X. What we've done is we've provided you with this class. It's called a GK dialogue.

And you can use it in a very similar manner to you would as a root view controller in iOS. So that when you want to present one of our UI elements that we give you back as a GK leaderboard view controller, you can use this. And it's really simple. So you can allocate a new one.

You set the parent window so that when you present the view controller, it shows up in the right spot. And then we provide a present and a dismiss method. Of course, when Norman actually gets to do the demo, you'll see this in play. He does a little Xcode magic. It's kind of cool.

If you're using one window, you only need one dialogue controller. If you're using multiple windows, you'll want to have multiple dialogue controllers. In our case, we have a single window game where the game itself is in one window. And all the methods to bring up the leaderboard and the view controller all come from one main menu in our game. And so it's easy in our case. We just have a single dialogue view controller -- a dialogue controller.

And there's one thing that I've been asked to mention. This is not Game Center related. Not entirely Game Center related. But early on when we released GameKit Framework on iOS, before we introduced Game Center features, we had these two classes. It's called a GK Session and a GK Peer Picker Controller.

And we used these to connect players together and browse for players to play with and communicate. So what we're telling everybody to do is, for best practice, use GK Match and GK Matchmaker Controller. At the end of the session, if I have some time, I've prepared some slides to talk a little bit about the GK Match and the Matchmaker View Controller.

But the best resource was -- No, an hour ago. But as I said, all the videos are going to be online, and you should review that. And there's quite a lot of documentation. We talked about it last year as well. Things haven't changed. And then the last piece is Game Center services.

Game Center services is all the servers that hold the leaderboards and the profiles and the profile pictures and the achievements and things like that. And it interacts quite closely with iTunes Connect. iTunes Connect is where you go to enable your game for Game Center. So you set everything up there. You're going to say what leaderboards you're using, what achievements you have.

And this is a new piece where you define the game groups. So Dan talked a little bit about game groups. Christy talked a little bit about game groups. There's the iTunes Connect session, what's new in iTunes Connect this morning, where they talked a little about game groups. That's where everybody probably is because they're doing a repeat. And multiplayer version compatibility. So previously you were only allowed to have version compatibility with the same bundle ID.

Now they allow you to actually have version compatibility across bundle IDs. This allows us to have OS X games play with iOS games. And I think that's really, really cool. So now that I've sort of told you about everything, I want to talk about how you actually create the game. So it's a little bit more involved. If you're coming from OS X, you can't just compile and go.

You'll need to get a certificate. You'll need to deal with the -- You'll need to deal with the -- You'll need to deal with the developer site. So the first thing you want to do when you're getting started up, and this will be familiar to everybody who has iOS experience, particularly getting things into the store. So you go to the developer site. This is where you register to get a signing certificate, where you get all your provisioning profiles.

So first thing you do, you go to the dev site, you set up an app ID. Once you've set up the app ID, you configure the app. In our case, we want to say what machines we're going to be doing our testing on. You need an entitlement for Game Center. This is the new piece, which is the main reason for going through here before you actually test.

You need to sign your apps either with an ad hoc certificate, sorry, profile. So when you go get the profile, you'll get two profiles, right? You'll get one so that you can share and beta test your apps, and you'll get another one that you sign for submitting to the store.

The version number, sorry, excuse me, the build number inside Xcode, right? At the bottom is where you define, and here we have another enabled Game Center, and this is per version, right? So you have to do this for every version of your game, not just for the overall game. You have to do that too, but that's sort of another caveat.

And here you can see I have some leaderboards set for my group, right? There's a global leaderboard, there's a few achievements, and this is the cool new part that I like to talk about. You'll see there's two games in there on the multiplayer compatibility side, right? There's an iOS game and a Mac OS X game.

And we'll show you that it's fairly easy to make that work. But this is a new thing, and I hope to see lots of great games.

Here we go, Game Center integrated. I'm logging back in. It has leaderboards. I have achievements. And the single player, this is a typical vertical scroller slash shooting game.

You as a developer can be creative in terms of creating the right solution. So for Crash, as you can see in the simulator, we basically hold down the single touch on the screen so you can move around as well as performing the shooting. So you can be creative and bring the best look and feel of the OS X native app.

What we have down here is we actually hook up to the mouse events, so when you click down the mouse, then you can move left and right. But some users might prefer, if you're coming from a first person shooting experience, you might want to hook up to WASD or error keys in order to feel better or be detached away from the mouse. Okay, so let's look at... The code here. So there's some fundamental differences, as Gabe mentioned. One of the big ones is the difference between app kit versus UI kit.

So here we have a declaration of UI view controller. By the way, I'm going to be working in my menu.h and my menu.m file in our project. These are the primary files that deal with creating the UI of the game. And these are the only places that we have that deal with the game kit. So here we are in the header file. We have a declaration of UI view controller. We type that to a view controller. Which is not going to be working for us for OS X because we don't have UI kit. We have app kit instead.

And the way we use this view controller in our game is to bring up any of the associate views. For example, achievement view or leaderboard view on the iOS side. As Gabe has mentioned in his previous slide, we do have a GK dialog controller that's available on the OS X.

So we're going to be using that to present and dismiss any of the leaderboard or achievement view. So let's go ahead and add that into our class. So if we are on iOS, let's keep the declaration of the UI view controller because that's what's available and that's working for us.

Otherwise, on OS X, we're going to have a declaration of UI view controller. And that's working for us. Otherwise, on OS X, we're going to have a declaration of UI view controller. So let's go ahead and add that into our class. And we declare a new property called GK dialog controller which we'll be using for translating the presentation and dismissal of any of the view controller we bring in and out from the game kit framework. So that's that.

Let's switch to... The source file. So now we have a whole bunch of compilation errors. So when you look at this, as soon as we have a declaration of different properties based on different platform, we need to change the synthesizers so the right instance variable can be created. So instead of doing synthesizing just the view controller, let's do if we are on iOS, let's synthesize view controller. Otherwise, if we're on Mac, because we are declaring the dialog controller as one of the properties, let's synthesize that one.

Okay, so what we have so far is on OS X, view controller is no longer available to us, and we use a GK dialog controller instead. But we can't really use it right now without any of the other properties. So let's go ahead and initialize this for the OS X. So in our view initialization, let's do this. If we are not on iOS, so which means we are on OS X, the GK dialog controller can be created by calling the standard alloc init.

And we're setting up a single property, which is the pairing window. This is easy for us. We don't have a single window game, so therefore we can always retrieve the window by doing the self view window that will give us the one and only window that's available to us. And that.

Okay, so we have a dialog controller at this point, and it's initialized and ready to go. And now it's coming down to how we present and dismiss any of the view controllers from GameKit. And you can see we have all these iOS-specific code that we will need to do some refactoring.

So to do some refactoring, I come up with a generic present and dismiss method that's available on both platforms. So when you call it on the iOS side, it will be automatically calling the view controller, present, and dismiss any of the view controller you want to bring up. But on the OS X, it will just use the GK dialog controller to present and dismiss the view controller. Let's go ahead and say if we're on iOS, our present view controller.

Notice how we're declaring a UIViewController here. That's UIKit that's available on the iOS. So the body will be the existing code that we have. So we use the UIViewController to present a model view of the GameKit controller. And then we're going to use the UIViewController to present a model view of the GameKit controller. And for the corresponding dismiss, again, we're doing a UI view controller.

and we'll be calling the view controller directly dismissal. On OS X, since we have declared GK dialog controller, and that's available to us and has been initialized, so we can go ahead and use that. And for OS X, because it's AppKit and we are switching to an SPU controller here.

So we use the GK dialog controller calling the present view of the input view controller here. And for the dismissal, we are going to be doing the same thing of using the GK dialog controller. Alright, so with this block that's in our code right now, we have two functions that's available for iPhone and OS X. And it will behave differently, but it's the same interface of calling in and out from your code. So let's go ahead and start using these new functions and put them into our code.

Alright, so we have a couple of places doing view controller dismiss and view controller presentation, but if you notice this code, this is our existing iOS code. What it does is, because iOS is single window and it's full screen, everything is presented modally, and in order to bring up any of the model view controllers, you need to dismiss any of the previous one that's being brought up. So we're doing this fail-safe tag here previously, but it's no longer needed for OS X because we're dealing with multi-window environment. So let's make that iOS only.

And for the completing our new code refactoring, let's go ahead and start using the new dismiss method because this has been factored out. So I already have that in. Remove that. And this is actually a self-dub view controller. And for view controller presentation, we have created a present view controller. So let's go ahead and use that. Remove this. And this is the second dialog controller when invite happens. So we'll go ahead and make this iOS only. That's dismissing any of the model view that's already presented. Let's use the dismissed view controller here.

And view controller presentation. Let's go ahead and use the new function that we created, which is cross-platform. Copy that and here you see how we show leaderboard, which is the old iOS code. I change that to use the new code, which is for both platforms show achievements. Let's do the same thing for present view controllers.

And after we authenticated matchmaking controller, we are going to be using the new present view controller. And here, any of the view controller that's finished being interactive with the user will perform a dismissal. But let's do the -- go ahead and use the new dismiss view controller function that's available to us. So here, this is the code to dismiss the achievement view. And here, dismiss the leaderboard view. Dismiss matchmaking view controller. And again, matchmaking view controller. So now we have finished making these changes. All right, build succeeded. Let's go ahead and launch that.

Alright, so this is Crash running on OS X and you can see it's logging me in automatically. And from Game Center I'm logging in here, my profile photo is showing and I have one and only friend of Gabe. Right here. Crash is on iOS. The implementation is a peer-to-peer multiplayer game. This is the most important part. So after -- yeah.

So the leaderboard is now being presented. It's the same chunk of code. PresentViewController and DismissViewController is running on both platforms. So now achievement also works. And how you notice... These views are actually independent windows, which is different compared to OS X. I'm going to go ahead and send an invite to Gabe, who's going to be running the very same app running on his iPad. Let's see if we can do a cross-play. Okay, invite friend, one and only. Hey, be nice to me. I'm a good friend to have.

That's a good thing. We're connected and ready to play. Press play. There you go. I'm green, he's red. Yeah. It's fairly easy and fairly straightforward, but you see how I am at a disadvantage here, or maybe Gabe just being... Yeah, I just stopped. Merciful. So I'm using a mouse here, and immediately I notice the input that we're using, it's...

So that's... that... Okay, so what do we have here? We have a single set of source file that's being available for both projects.

So let's go back to iOS project, and you can see the changes that we have made are propagated to this project because they share the same files. Let's just make sure we didn't break that for doing any cross-platform work. It's always good to verify on both platforms. All right, because we changed the view controller presentation, this missed, and these are still working.

and no problem. All right, so last week when Gabe and I worked together, and Gabe came up with this crazy idea saying, "Oh, you know, with Crash launching that after you log into Game Center, we have no--any acknowledgment for the user to know that you're logged in." So he said, "Why don't you just put--load the player profile photo and put it on the screen somewhere?" So we're going to go ahead and do that.

So let's switch to OS X project. So now let's develop on OS X. And GKPlayer actually gave us this functionality. So if you look at the GKPlayer, there's an API already, existing API, got little photo for size. Everything is looking exactly the same except this guy. So on iOS, it's a returning user, a UI image pointer in a callback block, but it's only having an NS image on the OS X. So we need to bridge the gap here.

And from this point, Any code that we write should always have the mentality of having to run on both platforms. So ideally, I would only want to write this code once, having the logic set once, but it works magically on both platforms. Okay, so let's figure out where we need to stick that code in first.

So in the initialization, we're authenticating with Game Center. So at this point, we have a login result. Whether it's success or failure, we are doing different things. So here would be a good place to put in that code to perform a load of player profile. So let's say we load the player profile and put it on the bottom right corner of the screen.

So how do we do that? That's easy. We just call the API. It gave us the image. But how do we put the image on the screen? We need to put the image to some sort of image view and put that image view on the screen as a subview.

OK. But on iOS, we have a UI image and UI image view. But on OS X, we have an image and image view, which is quite different. So to bridge the gap, I'm declaring a new prototype called picture or profile photo. So let's go ahead and do that. If we are running on iOS, I'm going to tap that UI view to a profile image data type, and also I will type dive UI image view to profile image view.

Otherwise on OS X, I'm going to go ahead and use NSImage instead for this data type. I use NSImageView for...

So we can go back to this code and start loading our image. So to load image, we're calling into-- we find a local player, which is the player that's always logging in. And then we call the load for the size, specify a small. And notice the callback block here. Instead of taking the NS image or UI image, I'm using the brand new data type I have created above.

So if the photo is set and loaded, we're going to say define the dimension of the photo we want to display to be 64, and we create this photo image view. We need to set where it's going to be locating. So for the bottom right, so the x axis will be the total width minus the dimension, and y start at zero, and we want to display as a box, so it's same dimension.

So once we have the dimension and we have the image view, we need to set the image property to be the photo that's being returned to us by GameKit, and we also set a frame, which is the location, and we add that to our game view, so it will be overlaid on top, and we close that.

On OS X, let's go ahead and run that. Okay, so now I'm logging in. Profile photo is loaded and displayed. So let's, for sanity check, let's go back to iOS project, builds, and let's load up the simulator. And it's working some sort, and what do we have here? We have a... iOS only bug.

The gotcha here is the difference between UI view and NS view. In the UI view, the origin of The view starts at the top left corner. However, if you switch to OS X using the NS view, it's on the bottom left. That's your origin. So there are a couple ways to solve this.

You can apply a transform to your view, just so that all the coordinates are exactly the same across different platform. Or you can invert the math by setting-- take the difference on the approach when calculating the y-axis. So let's go ahead and do that. So we are in the iOS project.

So here's the code that we have loaded. And for OS X, we want the y coordinate to be zero, because that's when the bottom starts. Let's change that. So if we're on iOS iPhone, the height of where the y-axis should be-- the total height minus the picture dimension. Otherwise, on OS X, we just use zero.

So now let's build that and have a quick run-through. And here we go. We invert it, and now the bug is fixed, and OS X should not be touched. Here. So we have feature parity as well as fixing the bugs on the iOS-only side. And I'm logging to Game Center. So let's look at the games. And I have Crash that's under me. And these are my achievements, which have completed. And if you look at the achievement over here on the iOS side, they are exactly the same, which is quite cool.

And you get that for free by using-- by adopting the GameKit framework. And using GameGroups. Yes. So that's the end of the demo. So hopefully you get an idea of how easy it is to bring the equivalent GameKit functionality from iOS to OS X. And now I'm going to switch back to Gabe. So I think Norman did a great job, especially showing how easy and similar the two platforms are from the GameKit framework. We showed exactly how to deal with the UI view controller and the NS view controller.

We used a GK dialog controller instead of a root view controller. Images, pretty much the same. There's a convenience here. It just so happens that the relationship between an NS image and an NS image view is the same as the relationship between a UI image and a UI image view. So that made it really easy for us. But you also notice some of the difference. So the graphic coordinates, for example, are different between the two platforms.

And then, of course, we saw that target OS iPhone show up quite a lot. It's probably really important. I have a few minutes left. And as I mentioned before, I talked a little bit about this old API that existed for GK session. But I really wanted to talk a little bit about peer-to-peer multiplayer. I know Christy did a fantastic job, so I'm just going to go over this briefly, and then I'll try to summarize it.

I don't have much time left. So to get a multiplayer game going, it's fairly easy. You have a match request, a GK match request, which defines all your match parameters. How many people are in their game, if you have any special matching attributes, or you want to divide your players into buckets.

GK matchmaker, which is a singleton, which you can use to do a quick match. You set an invite handler there. There's a GK matchmaker view controller, which is the UI. So you saw that in the demo where Norman invited me. That's the GK matchmaker view controller. And then of course the GK match, which you use to communicate between your different players.

So I think I have three slides on this. The first is the GK matchmaker view controller. And that gets created basically in two ways. With a match request, if it's an outgoing match, or with an invite, if your user has accepted an invite, launches your game, if you set the invite handler, you'll get this invite, and you need to create the view controller. And of course displaying it is just subtly different. It's still only a line.

Really easy to do. The objects that you get back, the GK matchmaker view controller, is still a GK matchmaker view controller on both platforms, but use the dialog controller in our case to present it. How you actually get a GK match is one of two ways. Either as a delegate from the GK matchmaker view controller, so when the invite has been successfully made, and the...

Related sessions. Yeah, I'm lost, so these all happened before me, but videos will be available. I know that the presenters will all be available. Thank you everybody for coming.