WWDC2013 Session 504

Transcript

X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
[ Silence ]
>> My name is Daniel Kurtz.
I'm an iOS engineer on the
Game Center team here at Apple.
And I'm here to talk
to you today
about what's new in Game Center.
So before we really get into
it, let's do a quick recap
of what Game Center actually is.
Game Center is a gaming platform
which allows the players
of your games, be they
single player or multiplayer,
to be able to interact with each
other by tracking their scores
and achievements that they'd
been earning in your game,
sending challenges to
their friends in order
to beat those scores
and achievements.
And then going even further
with the multiplayer support,
we have hosted turn-based gaming
within the game kit framework,
as well as real-time
multiplayer matchmaking.
Now, Game Center has been
incredibly successful.
You might have heard the
other day that we have
over 240 million
players in Game Center,
and they're playing games both
on their iOS devices
as well as on OS X.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So we've-- when I
asked you what's new
in Game Center this year,
perhaps the first thing
that comes to mind
is our brand new UI
for our Game Center
app on iPhone.
And we're very happy
about this UI.
We think it's very
exciting and fun.
But we're not stopping here.
We've got a lot of things going
on under the covers new
this year for Game Center
that you can take advantage
of within your game in order
to make it even further
integrated
and social with your players.
So today, we've got a
large grab back of topics
that we're going to talk about.
First up is the Game
Center in-game experience
with the GK Game
Center view controller.
We also have a lot of new
changes regarding leaderboards
and scores, Leaderboard Sets,
as well as Most Recent
Score Leaderboards,
a new type of leaderboard
that allows you
to track scores in a new way.
Also, because we're talking
so much about scores today,
we have improved
security measures
to help you limit
cheating within your game.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And building on top of both
scores and achievements,
we've improved challenges
even further
to make it more immersive
for your players.
And then, finally,
last but not the least,
we're going to round
it out of talking
about how you can take advantage
of handling local player events
and some fundamental API
changes that we've done
with how you can respond
to events relevant
to the local player
of your game.
So let's get right into it.
Let's talk about the Game
Center in-game experience.
And you probably all already
know this game, perhaps,
it's the in-game menu
for Temple Run 2.
And on that right
column in the middle row,
it's the leaderboards button.
Now, today, if you were
to pull out your iPhone
and play this game and tap
that leaderboard button,
up would pop the GK Game
Center view controller,
giving you the ability to take a
look at your leaderboard scores,
your achievements, perhaps
new challenges you've earned.
In iOS 7, that same
thing still happens
and we've updated the look,
the UI of the GK Game
Center view controller
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
in a very radical way.
We feel that this makes
it much more ingrained,
much more embedded
within Temple Run 2.
As you can see, Temple
Run 2's screen still shows
through in the background.
However, the same information is
still available to your players.
You still have the same list
of leaderboards, can still look
at the achievements that
your players have earned
or currently endeavoring
to earn,
and the challenges they've
gotten from their friends,
as well as the ability to rate
the game within the App Store
up in the top left or like the
game on Facebook if they wish.
So programmatically,
nothing has really changed
as to how you're going
to present the GK Game
Center view controller.
It's the same exact API
that you'd be using before
with a little bit of a wrinkle
when you're thinking
about performance.
So let's take a look
at some code.
Let's say that you have
a target action setup
for that leaderboard button in
your game and you want to hear
when that button is tapped
to show the Game
Center view controller.
Well, in your target
action method,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
the first thing you're going to
do is grab the shared instance
for the GK Game Center
view controller,
setting up the delegate to cells
so that you can dismiss
it appropriately,
set up your view state
to whatever appropriate initial
view state you wish to show.
And here's a little
bit of a wrinkle,
the throttle rendering call.
We'll get into that
in just a moment.
And then, finally, you're going
to present the view
controller just like you would
with any other UIView
controller within you game.
Now that throttle rendering call
that I'm talking about, right?
As I mentioned, the GK
Game Center view controller
with iOS 7 is partially
transparent.
Moreover, it's also
doing some blurring
and other heavy compositing
on the GPU.
So in order to make this
present as smoothly as possible
so that players can get in
and out of the menu and back
to playing your game,
you don't really need
to be running graphics at 60
frames per second and you're
about to push this
view controller over.
So you can step back in
the gas pedal a little bit
and let the view
controller present,
dismiss when you need to,
and get right back to it.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So really, that's
all that's changed
with the GK Game
Center view controller.
It's really just the exact
same API with a brand new look
that we feel really makes it
that much more ingrained
within your game.
So let's move on to the
next new topic of today.
Leaderboard Sets.
This is something we're
very excited about.
Today, on-- in iOS 6 device
or on OS X Mountain Lion,
your game currently has
at most 25 leaderboards
that it can define and
use on Game Center.
Now, I'm happy to tell you
that we have increased
this maximum limit
to 100 leaderboards.
You can have at most 100
leaderboards in a flat list
that your game can
use in Game Center.
And we're not stopping there.
With this new feature that
we have, Leaderboard Sets,
we're increasing actually
the maximum amount
of leaderboards you can use
within your game twentyfold
to 500 maximum leaderboards.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And now, with Leaderboard Sets,
we're introducing an
organizational hierarchy,
a structure that you can
impose on these leaderboards.
You can think of Leaderboard
Sets as a tagging architecture
where a single leaderboard can
belong to many different sets,
and likewise, a single
set can contain many
different leaderboards.
Then you have at most
100 sets that you can use
within your game and at
most 100 leaderboards
that you can put
in a single set.
So why are we asking you
to use Leaderboard Sets before
you can actually unlock the full
500 leaderboards for
use within your game?
It actually comes down
to usability issue.
Let's say you've got a Water
Planet group of stages, right?
And also, for this
group of stages,
you have a boss level
at the end.
And maybe you've also
got different levels
of difficulty-- easy,
medium, hard.
So one possible leaderboard
that your game has is the
Water Planet Boss Level
Medium leaderboard.
You, being the endeavoring game
developer that you are, however,
also have 499 other leaderboards
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that you've made
within your game.
So when a player wants to
go and checkout their score
on the Water Planet Boss
Level Medium leaderboard,
either within your game,
the Game Center application,
or the GK Game Center
view controller,
how are they supposed to find
this leaderboard amongst all
500 leaderboards?
It really comes down to a needle
in a haystack problem, right?
So what sets allow us to
do is to organize this
into meaningful groups of
data to make it a lot easier
for players to parse
when they're looking
through your game.
Here's an example from the GK
Game Center view controller
for this game, where when the
player taps the leaderboard
segment, the first thing that
they are shown is the list
of Leaderboard Sets
within the game.
Then if we were to tap that
Water Planet set up at the top,
the very next screen would
show all the leaderboards
that are contained within
the Water Planet set.
Pretty straightforward, right?
So let's consider how we
could actually put this single
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
leaderboard into various sets
and how we can start imposing
some order to the chaos
of these 500 leaderboards.
Well, right off the bat, we
have three pretty obvious ways
or three pretty obvious sets
that we could organize a
single leaderboard into.
One characteristic of this
leaderboard is that it belongs
to the Water Planet group
of stages within the game.
There's also the boss
level for the Water Planet,
and its medium difficulty.
So right there, that's
three different sets
that this leaderboard
could belong to.
And while this leaderboard
could belong to these sets,
we could also add all the
other leaderboards that belong
to these appropriate
sets as well.
So the Water Planet set
contains all the stages
for Water Planet-- water
boss, medium, et cetera.
So just like with leaderboards,
Leaderboard Sets can have
names of players saved.
And moreover, depending
upon the set
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that a leaderboard
is contained within,
the name for that individual
leaderboard can change as well.
So let's take a look
at the examples
of what this actually
means and how it works.
So we go back to these three
sets that we've defined
that the Water Boss Medium
Level leaderboard can be
contained within.
In Water Planet set, we could
simply just name Water Planet,
and that Water Boss Medium Level
leaderboard, when it's contained
within the Water Planet, that
is when the player has navigated
to the Water Planet set to
look at this leaderboard,
we could just display
the string boss medium.
From here, it's clear that
this is the Boss Medium Level
leaderboard for the Water
Planet group of stages.
There's no redundant
information.
Everything is very
much contextual.
And we can go and name all the
other leaderboards appropriately
for that set as well.
Then the Water Boss Set,
just call it Water Boss.
That same leaderboard when
it's in the Water Boss Set,
we only have to call it medium
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
because it's obvious it's the
medium level of difficulty
for the water boss set.
We go and name all
the other leaderboards
in that set appropriately.
And then you're getting
the picture
with medium set, call it medium.
And we could call this
one stage Water Boss.
And name all the other
medium level leaderboards
in the medium set
appropriately as well.
So we've gone and we've
given this single leaderboard
different names depending
upon the way the players have
actually navigated to it.
But it's still the
exact same leaderboard.
That is, regardless of the
path that players happen to go
or take in order to find this
leaderboard, the exact same list
of scores is going to be
displayed to the user.
It's just really UI
customization option
that you have at your
disposal in order
to make information
contextual and not redundant.
So let's take a look at how
we can actually set your game
up in iTunes Connect in
order to use Leaderboard Sets
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
and start organizing
the leaderboards
of your game into these sets.
We're going to take a very,
very quick blow-by-blow
quick flyover here.
I definitely urge you to check
out the iTunes Connect
session tomorrow, however,
if you want to get more
detail as how you can set
up Leaderboard Sets
within your game.
So in the Game Center page for
your game on iTunes Connect,
in the leaderboard section of
that page is this new button,
Move All Leaderboards
into Display Sets.
When you click this button,
you're going to be asked
to create the very
first set for your game.
And now, the first thing that
you're going to have to do
when you're creating this
set is to find a handle.
This is really just the
name that you're going
to be referring to this set
when you're configuring
it on iTunes Connect.
This isn't the same as the
string that players are going
to see when they're
using your game.
It's really just a
convenience for you.
Then, after creating that
handle, that Set Reference Name,
you're going to have to
create a leaderboard set ID.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Just like leaderboards, you have
to create a unique identifier
for your set on iTunes Connect.
And we suggest that
you create it
as a reverse DNS style string.
So in this case, for
the Water Planet set,
we're going to give it
this reverse DNS string.
Now, after that,
you've created a set.
And from creating a set, you
actually have to give it a name
that is going to be
displayed to your players.
So the very next step you're
going to have to take is
within the Display Set
Localization portion
of the screen after
creating the set,
there's an Add Language
button here.
And you need to then go
and create language-specific
display names for this set.
So we could take, say,
English as the first language
that we're going to define
a name for, for this set.
We're going to name this Water
Planet set just Water Planet,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
liked we talked about
in the example.
And then we can also create an
English locale-specific image
that we wish to be displayed
to players when they're looking
at this set on English
locale devices.
And then, further, if
you're creating your games
for multiple languages
either now or in the future,
you can create other
localizations as you see fit.
So after you've created the
display name for this set,
the next thing you need to
do is actually start adding
leaderboards in your
game into this set.
So you'll see another
part on the screen
that says Leaderboards in This
Set with Add to Set button.
Clicking that button, you're
going to be asked to select one
of the leaderboards that
you've already defined
in iTunes Connect.
Let's take that Water Boss
Medium Level leaderboard.
And then you're going to have
to give that leaderboard a name
when it's being displayed
within the Water Planet set.
So again, you choose a
language, give, in this case,
the English language
string that's going
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to be displayed to your players.
And then either now
or in the future,
go and give other
languages if you decide
to localize your game
for multiple locales.
So that's really all there is to
it for actually setting up sets
within iTunes Connect.
Now, using Leaderboard
Sets programmatically
with the Game Kit Framework
is very straightforward.
We nowhave a GK Leaderboard
Set class
and it defines three fundamental
properties that you're going
to have to care about
when you're using sets
within your game.
The first is an NSString title.
Now this is really just the
display name that you set
up on iTunes Connect
for your set.
And if your game is running
on an English locale device,
it's going to display the
English name, Japanese
or Japanese name, et
cetera, et cetera,
just like how leaderboard
titles work today as well.
Then you're going to have
your NSString identifier.
This is just the set ID that
you defined on iTunes Connect.
And, as well, optionally,
there's the group identifier.
Now we didn't talk about this
in the iTunes Connect overview,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
but just like how leaderboards
work with game groups,
a feature that we
introduced last year,
so too do Leaderboard Sets.
And we're not really
going to talk a whole lot
about the group identifier
in game groups
with Leaderboard Sets today,
but I definitely urge you again
to check out the iTunes
Connect session tomorrow
for more detail on that.
So we've got the GK
Leaderboard Set class.
Just like GK Leaderboard
objects before,
you can actually use
the sets that you've set
up on iTunes Connect
within your game.
The very first thing you need
to do is load all the sets
that belong to your game.
And you can do that calling
Load Leaderboard Sets
with Completion Handler.
Now, when your completion
handler is called, you're going
to be passed back an NSArray
of GK Leaderboard set instances.
And from there, you're on free.
You can do anything
that you wish
with these leaderboard
set objects.
For instance, you can
load the leaderboards
that are contained
within those sets.
So when this completion handler
is called, we can take one
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of the sets that
we've been given back.
And to load the leaderboards
that are contained
within that set, we could
call Load Leaderboard
with Completion Handler
or Load Leaderboards
with Completion Handler.
And when that completion
handler is called back,
you'll be provided an NSArray
of GK Leaderboard instances.
And now I'm assuming that
you're already familiar
with GK Leaderboard
objects, from this point,
you can treat these objects just
like you would any other
GK Leaderboard object
within your game.
One other thing that you can do
with GK Leaderboard set
instances is to load the image
that you upload with
iTunes Connect for that set.
So within this Load
Leaderboard Sets
with Completion Handler called
back, you could take one
of those sets and call Load
Image with Completion Handler.
And that completion handler will
pass back a GK image object.
So a GK image object is
really just a typedef.
If you're running on iOS,
then that's going to point
to UIImage, if you're running
on OS X, they'll be an NSImage.
And once this completion
handler is called back,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
you can use it just like
any other image asset
within your game.
So that's Leaderboard Sets.
Again, it's-- you can think of
them as a tagging architecture.
It allows you to group multiple
leaderboards into a set.
A single leaderboard
can be contained
within many different sets.
An important thing that I
wish to pint out here is
that if you wish to unlock
all 500 leaderboards, that is,
if you wish to adopt Leaderboard
Sets within your game,
then you must make sure
that every leaderboard
that you create within your game
is a member of at least one set.
So let's move on to the next new
thing with leaderboards today,
Most Recent Score Leaderboards.
So you're all probably
already familiar
with how leaderboards
work within Game Center,
the best score ranking system.
That is, if you've got
an ascending leaderboard
or ascending sort
order leaderboard,
and your player happens to
earn 10,000 points today,
then tomorrow, when they
score 5,000 points, let's say,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
5,000 isn't better than 10,000,
so 10,000 is going to remain
on the all-time time span
for that leaderboard.
Or what if you want to
implement a leaderboard
where scores can both go
up and down over the course
of people playing your
game, like batting average.
If you want to track your
player's batting average
over a season, that's going
to not just be monotonically
increasing or decreasing,
it's actually going
to be increasing
or decreasing over time.
So that's what a Most Recent
Score Leaderboard allows you
to do.
Most Recent Score Leaderboards,
they're just an alternative
to Best Score Leaderboards.
And the way that they function
should be pretty obvious
by the name.
It's just that the next score
that you submit to a leaderboard
for your player, that's going
to be the score that shows
up on the leaderboard
in Game Center.
So really, what this means, it's
actually a very profound effect
of this is that it allows you
to take full 100 percent control
over the ranking system
for this leaderboard.
You could do things like power
rankings for your chess game
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
or your legendary
RPG Heroes game.
You could do win/lose
percentage or even, you know,
simpler things like batting
average or golf strokes or OPS.
Really, it's entirely up to you.
And setting up a Most
Recent Score Leaderboard
for your game is really
just a single checkbox away
on iTunes Connect.
Within the Leaderboard
Configuration screen
on iTunes Connect when you're
creating a new leaderboard,
you'll notice that there's a
new field here called Score
Submission Type.
Now by default, that Best Score
field is going to be clicked.
However, if you click the Most
Recent Score checkbox right
there, that instantly
turns this leaderboard
into a Most Recent
Score Leaderboard.
Now you may already be familiar
with the Sort Order field
right below, we've had this
for a long while already.
Sort Order is just as applicable
to Most Recent Score
Leaderboards as it is
to Best Score Leaderboards.
If you say set this
to low to high,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
then the lowest scores are going
to get the best ranks
on this leaderboard.
So using baseball,
again, as an example,
if you want to track ERA, you'd
probably want it to be low
to high because lower is better.
High to low for batting average.
You want it so that the highest
scores get the best ranks.
So Most Recent Score
Leaderboards programmatically
are identical.
100 percent identical to
regular best score leaderboards
in the Game Kit Framework.
However, since you are
now being given the power
to entirely customize the
ranking system that's afforded
to you, there's a lot of
things that you could do
when you're preparing these
scores for submission.
So let's take a look at an
example of what you could do.
Let's say that you want to
create a power ranking system,
that is, you have a
multiplayer game and you've got
like a ladder ranking system
within your game so that
if a high-rank player and a
low-rank player play each other
in a match and the low-rank
player happens to win,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
then the low-rank player's
rank is going to jump
up the difference of those two
players' ranks, and vice versa,
the high-rank player,
because he lost,
is going to drop
by the difference.
Well, what we could do here
programmatically is at the end
of the match, we could
load the leaderboard scores
for those two players, the local
player and the other player,
setting the identifier for
the GK Leaderboard object
to that Most Recent Score
Leaderboard identifier you've
set up on iTunes Connect.
So once you've loaded the
scores with completion handler
and your completion
handler is called back,
you can grab the score values
for both the local player
and the other player.
And then, based upon the
previous power ranking, that is,
the local player's value
of the local player
and the previous ranking of
the other player's value,
as well as the outcome
of the match whether the local
player happened to win or lose,
you can create a new
local player score value.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Then from there, you
submit these scores just
like you would any other score
to any other regular
old leaderboard.
You allocate a native score
with the leaderboard identifier
for the Most Recent Score
Leaderboard, you set the value
to the new local player's
value, and then, finally,
you call report scores
passing in an array
with that local player's score.
So, really, that's all there is
to Most Recent Score
Leaderboards.
It's very, very similar
to how you would work
with Best Score leaderboards
programmatically,
but since there's so much
else that you can do in order
to customize the
ranking system, really,
the opportunities are
endless as to what it can do.
So while we're in the
neighborhood of GK Leaderboard
and its API, I just want to
touch on a couple of changes
that we have this year with iOS
7 for the Game Kit Framework.
First of all, you
may be familiar
with the GK Leaderboard
Category property.
That was a pointer for basically
the NSString identifier
that you set up on
iTunes Connect.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
We're deprecating this in favor
of the identifier property.
And the reason is basically
because with GK Leaderboard
Sets, sets and categories,
they sound sort of familiar
or similar to each other,
so in order to, you know,
allay any confusion,
we're deprecating the
category property.
You may also be familiar with
the Set Default Leaderboard
with Completion Handler Call
on GK Leaderboard
as a class method.
Now, this basically allowed
you to make it such that
when a player is viewing your
game within the Game Center app,
that the very first leaderboard
that they're presented
with within your game detail
view is the leaderboard
that you're choosing.
But since this is something that
isn't so much of the property
of the leaderboard, but
much more the local player,
we're deprecating the GK
Leaderboard method in favor
of GK Local Player Set
Default Leaderboard Identifier
Completion Handler method.
So use that instead in
case you're interested.
So we've talked a lot about
new leaderboard features today,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Leaderboard Sets, to
increase the maximum amount
of leaderboards that
you can use,
as well as Most Recent
Score Leaderboards,
and new ranking systems that
you can create using them.
Let's take a quick
peek under the hood
as to how actual
score submission works
in the Game Kit Framework
in the Game Center platform,
and what's going
on under the hood
when you're communicating
with Game Center.
So when your game is running
and it's making submissions
to Game Center, whether it's
running on an iOS device
or an OS X system, it's
actually not alone.
We have a daemon called gamed
that is always running
in the background.
And when your game
is communicating
through the Game Kit Framework
with the Game Center platform,
transparently, as in you don't
need to remember any of this,
transparently, your game
is actually establishing a
connection with gamed,
our daemon.
Then in turn, gamed is
establishing a connection
with the Game Center
servers in the outside world.
So when you submit
a score, let's say,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to the Game Center system,
you're actually submitting
that to gamed.
And now, gamed is going
to automatically relay
that to the Game Center server.
So why do we do this?
Well, let's say, for instance,
that internet connectivity
of the device happens to be
lost, and thus, the connection
with the Game Center
server is separate.
Well, for any score submissions
or achievement submissions
or any other type of submissions
happen to fail because of this,
gamed will automatically
store those requests
that you're making.
Any of the failed ones
or any of the future ones
that you're making to game d,
your game doesn't need to worry
about internet connect--
internet connectivity,
gamed is always just
there managing it for you.
So that when Game Center
server, the connection
with the server happens
to be reestablished
and the device comes
back online,
or even if your game happens
to go offline before these
submissions make it over,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
gamed is going to immediately go
and forward those
score submissions
over to the Game Center
server on your behalf.
Really, you don't need to
worry about any of this,
it's all done transparently
for you.
So you may be familiar
with the report scores
with completion handler API
and how our completion handler,
as a signature, such that it can
pass back an NSError object.
This is largely vestigial.
This whole store and
forward mechanism
with the gamed daemon
is something
that we introduced in iOS 5.
So it's been running
up through today.
As long as your score and/or if
you're submitting achievements,
your achievements
happen to be in it
with the proper consistent
identifier that you set
up on iTunes Connect,
you don't need to worry
about checking this NS
error object and its value.
We're actually not going
to hand one back to you.
In the past, before we
implement the store and forward,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
we used to ask you
to check to see
if there was an internet
connectivity error
that was handed back to you.
And if so, we asked you
to actually do the storing
and forwarding of
these requests later.
But you don't need to do that.
You haven't had to
do that since iOS 5.
So if you've got a code
like that within your game,
definitely take it out.
You don't have to worry
about caching your
scores and achievements.
In fact, we definitely
urge you not
to because there
are complications
that can arise with challenges.
Just the moment that your
player has earned the score
and achievement,
submit right away.
Give it over to gamed, it'll
do the heavy lifting for you.
And that being said, if you're
submitting multiple scores
for a single play-through
session, like, let's say,
your player is going to be
earning coins in the session,
they're also going to be getting
a track time around the level,
and then finally,
you're also going
to be submitting another
score for their high score
in that level, then those
are three different scores,
you should batch those into
a single NSArray and pass
that in via report
scores method.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So that's what new
in leaderboards.
A lot of new stuff.
We've got many more leaderboards
with Leaderboard Sets,
up to 500 leaderboards that you
can define within your game.
We also have Most Recent Score
Leaderboards that allow you
to create custom ranking
solutions for your game.
And we also took a quick
peek under the hood
of how gamed works when
you're submitting scores
and also achievements
and other requests
to the Game Center platform,
and how we do the heavy lifting
for you so you don't have to
worry about this caching logic
and network connectivity.
You just have to submit your
scores and then get right
on to letting players
play your game.
So we've talked a lot
about leaderboards today
on a very related topic that I
think dovetails pretty nicely.
Let's talk about how we can
limit cheating within your game.
Now you may all be familiar a
bit with screens such as this.
In case you don't recognize
that there's some
suspicious score values here.
I don't think, you know, the
six top players or however many
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
in this game happened to
have earned in 64 max,
but I don't think that's
actually ever humanly possible.
So clearly, something
suspicious is going on here
and it probably means
that there are people
who are cheating in the game.
I'm happy to tell you
today that with iOS 7,
we are doing three things
in order to help you limit
and combat cheating
within your game.
And the first is
completely free for you.
When your game is
submitting scores to gamed
on an iOS 7 device, when it
reaches gamed and gamed goes
to relay that score to
the Game Center server,
it is automatically attaching
a cryptographic signature
to the score submission, as well
as other submissions
like achievements.
So that if a nefarious player
happens to go and tamper
with that submission
when it's in midstream
to the Game Center servers,
that's going to get picked
up automatically and
Game Center is going
to reject that score outright.
That's free for you.
You don't have to do any sort of
coding or configuration steps.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
If your game is running
on iOS 7, we've gotten
that taken care of for you.
Now another thing that
you can do in order
to help limit cheating
within your game
like from an exploit
level or angle is
with the Score Range property
on the Leaderboard Configuration
screen in iTunes Connect.
If you've got a leaderboard
where it's only believable
or only humanly possible for
a player to legitimately earn
at most 10,000 points within
that leaderboard on your game,
then I definitely suggest
that you set that To Value
in the Score Range
field to 10,000.
What this does is it essentially
creates a visible score range
for scores within your
leaderboard for that game.
And what I mean by that is if a
player happens to submit, say,
one billion points
to this leaderboard,
when it's really only
humanly possible for them
to earn 10,000 legitimately,
then the Game Center
server is going to accept
that score submission, it's
just not going to be visible
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to other players of the game
when they're looking
at that leaderboard.
So we're hanging on to
these scores, right?
There are a lot of reasons,
one is because circumstances
within your game
might actually change.
You might realize that you
forgot to carry the one,
for instance, when you're trying
out your game design docs,
and you realized that it's
actually totally allowable
and believable for a player to
earn at most a billion points
within this leaderboard.
So at a later time, you
can come back to the screen
in iTunes Connect, vamp that
To field up to a billion,
and that player's score
that was earlier hidden
by the Game Center server
will now become visible.
So this isn't an
unforgiving configuration set.
It's just another arrow in your
quiver to help limit cheating
and exploits within your
game, but it will allow you
to backtrack in case
you decide that, "No,
it's totally OK all along."
The third thing that we are
providing you with iOS 7
and OS X with iTunes Connect
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to help limit cheating is a
brand new configuration tool
within iTunes Connect.
And this tool is going to help
you audit suspicious player
activity on your
leaderboards of your game.
And now, we've got
a lot of things
that we're talking about today.
So I definitely urge you
to check out what's new
on iTunes Connect session
tomorrow 'cause they're going
to go into in-depth as to
how you're going to be able
to actively manage player
activity within your game,
'cause you know you're
being best, you made it.
And it's a living
breathing thing
so you understand it
as it's being played.
So with this tool, you'll
be able to make sure
that everything is
running smoothly.
So that's what's new in
security for Game Center.
We've got signed submissions,
this is totally free for you.
We are signing every
submission we're making
to the Game Center
platform and to the server.
So if anybody happens
to tamper with it,
when it leaves the device and
goes off into the internet,
we're going to detect that on
the other end and we're going
to reject those submissions
outright.
Definitely, I suggest you
use the Score Range field
within iTunes Connect on the
Leaderboard Configuration screen
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
in order to filter out
anybody who's exploiting issues
within your game.
And then finally, we've got a
new management tool that's going
to allow you to help audit
suspicious player activity.
And you can find out
more about that tomorrow.
So we've gone through new
leaderboard features as well
as how we can help you limit
cheating within your game
if it's Game Center enabled.
Let's move on to the next
topic today-- Challenges.
So Challenges was
a brand new feature
that we introduced last
year, and we've been thrilled
with the uptake and adoption
of challenges in your games.
And we introduced, again, last
year with iOS 6 Mountain Lion.
And what it really does is
whether your game is a single
player or a multiplayer,
challenges add a competitive
element to your game.
If your game support
leaderboards or achievements
within Game Center, and
players can challenge each other
to either meet or beat
those leaderboard scores
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
or to earn those achievements
that they've earned.
And this was also supported
automatically whether
through the Game Center
app on iOS or OS X
or through the GK Game Center
view controller, players that go
through our UI, select their
scores, challenge their friends
to beat those scores,
same with achievements,
and players would start
receiving notifications
and would complete
everything, and it was great.
We also provided you, however,
with API to extend your game
for custom challenge
gameplay to hook into events
when players happen to
complete a challenge,
and also to allow you to issue
challenges programmatically
within your game.
So before we talk about what's
new in Challenges this year,
let's just do a quick run
through of how Challenges
work currently.
So let's say Tom is playing
a racing game and he happens
to earn a lap time of 50
seconds around the track.
Then he could challenge
Alice to go
and beat his lap
time of 50 seconds.
So he sends a challenge
to Alice.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
Alice gets that challenge
and she opens up your game,
and she happens to play that
same track getting a score
of 40-second lap time.
Now, 40 seconds is
better than 50 seconds,
so Alice has completed
that challenge.
She gets a push notification
to her device
from the Game Center
server telling her
that she just beat
the challenge.
Automatically in the background,
since the score challenge,
Tom gets a new challenge
from Alice challenging him
to beat her score of 40 seconds.
So that's great and that's
how Challenges work currently.
But let's say that
Tom happened to earn
that lap time using a beat-up
old pickup truck per se.
So it might be hard to actually
get 50 seconds as a lap time
with a beat-up old
pickup truck and much,
much harder than doing it
with, say, a super car.
So how can we make it such that
when Alice gets that challenge
from Tom that she can only
complete that challenge as long
as she's earned that score
with the same gameplay context
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that Tom used to earn his score?
Well, that's what a new feature,
Modal Challenges,
allows you to do.
Now, Modal Challenges, what
they allow you to do is
when you're reporting scores
and reporting achievements
to Game Center, you can
optionally provide us
with a list of challenges
that you wish the server
to consider for completion.
And this entails some new API.
Report Scores and Report
Achievements now have extra
methods for Report Scores
with Eligible Challenges
with Completion Handler
and Report Achievements
with Eligible Challenges
with Completion Handler.
This API doesn't replace
the current Report Scores
and Report Achievements
API that you know.
It's really just an augmented
version in case you wish
to make use of Modal
Challenges within your game.
So let's take a look
at how we can make sure
that when Alice is earning
her lap time around this track
in your game that she
only completes challenges
that were earned for
that exact same car
that Alice has raced
around with.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So at the end of Alice's
play through, right,
first thing that you could do
is load the Received Challenges
that Alice got from her friends,
and that completion
handler is called back.
You could filter through
any of the score challenges
because we only really care
about lap times in this case.
For every score challenge
that Alice has received
from her friend, there
is a context property.
Now this is something that has
existed forever in Game Center.
Every score has a UN64
property called context
that you can add any value
that you wish to the score.
And when you either submit
it to a leaderboard or attach
to a challenge, that context
is going to be attached
to that score on the other end.
So you could embed the car
model that Tom happened to race
around the track with on
that score that he used
to create the challenge.
And then on Alice's device,
you can pull the car
model out of that score.
All you need to do is check
to see whether the car model
for that challenge happens
to match the car
model Alice just used
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
to race around the track.
And if it does match,
you can add it
to these challenges
with same car array.
Really, just a list
of challenges you wish
to be considered by the Game
Center servers for completion.
And finally, you're going to use
the new API for Report Scores.
You're going to pass the
score that Alice just earned
in her play through session
and you're going to pass a list
of the challenges that
were created with scores
with the exact same care
that Alice just raced
around the track end.
And then the optional
completion handler.
And that's it.
That's how Modal
Challenges work.
As well as making sure
that only challenges
that makes sense can be
completed within your game,
this also allows
you to do things
like challenge-specific modes
within your game so that
when a player launches
your game because they wish
to play a single
challenge, you could set them
up an entirely new gameplay mode
so that when they are in a score
in that mode, only that
one challenge is completed.
Really, it's all up to you.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
A new feature that we
have for Challenges
as well regards programmatically
issuing challenges
within your game.
Now, we allowed you to
programmatically send Challenges
to players within your game when
we released Challenges in iOS 6
and OS X Mountain Lion.
And we further augmented
this with iOS 7.
So let's say that your
player just happened
to complete a level and they
earned a score of 500 points
and maybe they even
earned an achievement,
right now will be a great
time to allow your players
to send a challenge
to their friends.
You don't want them to have to
exit your game in order to go
into the Game Center app to
do this, it's better for them
to just do it right here
so that they can get
on with playing your game.
Now again, last year, with
iOS 6 and OS X Mountain Lion,
we allowed you to do this.
We're making it even easier
this year by providing you
with a friend picker and compose
controller that we create
on your behalf and
present to the player,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
where they get a list
of their friends,
and if it's an achievement
challenge
which friends have earned
this achievement or eligible
to receive this challenge, the
player can then select friends,
one or many, that they wish
to send this challenge to,
pressing the Next button, up
comes a composed controller
with a preformatted
default message
that you can optionally pass
to us that they can edit,
and then they can choose to send
that challenge to their friends.
Using this composed
controller flow is very,
very straightforward.
And let's take a look
at how we can do this
with achievement challenges.
The first thing that
you're going
to do is allocate your GK
achievement object just
like you would in any
achievement challenge
that you wish to issue
programmatically previously.
You set up the achievement,
setting the identifier
with the appropriate
identifier on iTunes Connect.
And you make sure that you set
that percent complete
value to 100 percent.
You can only challenge friends
to 100 percent complete
achievement, not part way.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And then, to get this
UIViewController
that represents the
composed sequence,
you're going to call a new API.
And it's available on both
GK achievement and GK score,
and it's this method here.
Its challenge composed
controller with players
where you can pass in an
optional list of friends
of the local player that
you wish to be preselected.
Then a message which is
an optional NSString
that you can pass that will pop
up in the composed controller
as the default message
that players can then edit.
And then the completion handler.
And when the completion
handler is called back,
that means that the
player happen
to either send the
challenge to their friends
or cancel sending the challenge.
And at this point, you need
to dismiss the view controller
and then do whatever
post processing you wish
because we also tell you
whether the player happened
to really issue that challenge,
and if they did, which friends
and player IDs they
sent that challenge to.
And then finally, once
you've gotten this incense
of the UIViewController,
you just need to present it
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
like you would any other UI
view controller within your app.
And that's it.
That's how you do
programmatic issuing
of challenges with iOS 7.
We think it makes it even
easier in order to allow players
to send challenges
to each other.
So you may be familiar already
with our existing
Issue Challenge
to Players Message method.
And since we've really
streamlined the way
that you can send challenges to
friends of your local player,
we're deciding to
deprecate this method.
And instead, we urge you to move
on to using the Challenge
Composed Controller
with Players Message
Completion Handler, the new API.
Now, in case your game is
running on an iOS 7 device
and is still using this legacy
API, they'll still work,
but we're going to present
a composed controller
and friend picker to the player
on your behalf automatically.
And this is great, but
I definitely urge you
to consider moving
over to the new API
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
because if you were
programmatically sending
challenges in the middle of
a gameplay session per se,
you definitely don't want
a view controller to pop
up in the middle of a player
jumping over a very wide pit.
So you know when
the timing is best
to actually present this UI.
So definitely move on to
the new API that we have.
So that's what's
new in Challenges.
We've got modal challenges
for selective completion
of challenges within
your game based
on context that you define.
We've got brand new programmatic
issuing of challenges API
to make it even easier to
send challenges to friends
with a local player
in your game.
And we've also-- because
of this streamlined API,
we've deprecated the
issue challenge API.
And if your game still happens
to use it when it's running
on iOS 7, it's still going
to work, but the new UI,
that new view controller,
is automatically going
to be presented to
the local player.
So that's Challenges,
that's what's new
in Game Center for Challenges.
Let's move on to the next
big topic of the day--
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
handling events relevant
to the local player.
Now you may be familiar
with handling events
for the local player in the
Game Kit Framework today.
We have a lot of different
singleton objects that you had
to declare delegates for.
If you want to hook into when
the local player completed the
challenge, we have the GK
Challenge Event Handler
Singleton and we had the GK
Challenge Event Handler Delegate
Protocol that you would set as a
delegate for that event handler.
We also had things
for turn-based match--
or for a turn-based gameplay,
they had a singleton object,
and the GK Matchmaker
had an invite property.
Well, we've thoroughly revamped
the way and redefined the way
in iOS 7 that you can
handle events relevant
to the local player.
And we're doing it like this.
You can think of the GK Local
Player instance as the source
of all the events that are
relevant to your local player.
And so, whether the players
received the challenge,
completed the challenge,
gotten a new turn,
maybe a turn-based invite
or some matchmaking invite,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that's going to be channeled
through the local player.
And the local player can have
multiple listeners registered
to it.
And when a local player
listener is registered
on the local player and a
message happens to come in,
an event is triggered, that
listener or any listener
that is compatible for that
callback is going to get called.
Your listener object when you
register on a local player,
it needs to conform to the GK
Local Player Listener Protocol.
And this protocol, in turn,
conforms to three sub-protocols,
all defining optional methods.
None of the methods in these
protocols are required,
so you can pick and choose.
First is the GK Challenge
Listener Subprotocol
that defines the
various callbacks
that you can optionally conform
to when the player has completed
a challenge or had some sort
of challenge relevant
event occur.
We've also got GK
Turn-Based Event Listener
for turn-based gaming
specific callbacks
and GK Invite Event
Listener for GK Matchmaking,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
real-time matchmaking callbacks.
Once you've created your
listener, in order to register,
it's very straightforward.
I'm going to adopt one of
these subprotocols or any
of those methods and those
subprotocols, and you're going
to call on the Local Player
Instance Register Listener
passing this listener
instance that you've set up.
And you can pass-- you can
register multiple listeners.
And you also don't need
to worry about the timing
that you're registering
these listeners.
You may be familiar that
previously we asked you
to register or set delegates
on turn-based event handlers,
challenge event handlers,
all those other singletons
in the authentication
handler callback.
Well, you don't need to
worry about that anymore.
In case your-- the local player
happened to receive some sort
of event and there is
no listener registered
for the local player at
that time that could handle
that event, the local player
is going to cache that event.
So when you register
listener at some time later,
it'll have that event to
dispatch to your listener or all
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
of the listeners that are
capable of handling that event.
So since we've talked a
bit about challenges today,
how about we take a look
at the group of methods
that you can implement
optionally within your listener
in order to hook into
challenge relevant gameplay?
The GK Challenge Listener
Subprotocol defines four
different methods that you can
optionally implement in order
to hook into challenge-specific
events concerning the
local player.
Let's take a quick look
through these different methods,
what they mean, and
how you can use them
within your listener
object or objects in order
to enable custom challenge
based gameplay in your game.
The first is concerning
selecting challenges.
That is, when a player
happens to receive a challenge
from a friend, whether
they are playing your game
or they're hanging around
in the Game Center app,
and they tap an iOS
notification center banner
or they tap a play bubble
within the Game Center app,
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
or if they tap a play bubble
within the GK Game
Center view controller,
we're going to call back to
your listener Player Wants
to Play Challenge.
And really, what this means is
that the player tapped this
challenge banner and they want
to play your game in order
to complete that challenge.
So at that point, if you've
got challenge-specific gameplay
modes within your game, you
can call Self-Start Challenge
for Challenge if you've
got a method like that,
passing in the challenge to set
up this gameplay
mode for challenges.
Similar to selecting
challenges within your game,
we also got receiving
challenges.
This is an event that
is called back to your--
on your local player listener
when the player is playing your
game currently and they happen
to receive a challenge
from a friend.
At that time, player did receive
challenge is going to called
on your listener and you may
wish to present some custom UI,
like if Alice sent
Tom a challenge
to beat her track
score, you might want
to show Alice's picture right
there with the challenge message
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
that she happened to define.
And you could do that
within this method.
The last two methods in the GK
Challenge Listener Protocol are
concerning completing
challenges.
The first, when the local player
happened to complete a challenge
that they receive from a friend,
Player Did Complete Challenge
Issued by Friend is called
when the local player completes
a challenge in your game.
And at this point, you know,
if you want to congra--
display a congrats banner to
the player or whatever UI,
maybe even reward them
gameplay-wise within your game,
you could do that here.
And then, also, when the
local player's friend happened
to have completed the challenge
that the local player sent then,
that's where Player Issue
Challenge was Completed
by Friend is going to be
called back on your listener.
At this point, you might
want to inform the player
that perhaps their friends
are a little bit better
than they thought they were,
and again, do whatever you wish
in your game that makes sense.
So that's just how
challenges work
with GK Local Player Listener.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
But we're also doing a lot
of things concerning
turn-based gaming as well
as real-time matchmaking.
Those are all built with
the GK Local Player Listener
architecture as well.
And as you may guess, that
means that we are, in turn,
deprecating the GK
Challenge Event Handler,
the GK Turn-Based Event Handler
Singleton and their delegates,
as well as the Invite
Handler property
of the GK Matchmaker object.
And since this affects
multiplayer as well, tomorrow,
Nathan's got a multiplayer
session,
making multiplayer
games with Game Center,
I definitely urge you to
check that out in order
to learn how you can adopt GK
Local Player Listener Protocols,
in order to use turn-based
gaming
within your game
and GK Matchmaking.
So we've learned a lot of
different things today.
In addition to our brand new
UI that we've also got going
on with the GK Game
Center view controller,
we've increased the maximum
amount of leaderboards
that you can use within your
game to 500 leaderboards.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
And you can impose a
hierarchical structure
on these leaderboards with a new
feature called Leaderboard Sets.
Most Recent Score Leaderboards,
in case you want to make it
such that player scores on
a leaderboard can go both up
and down, and completely
customize the way
that you rank players
within a leaderboard
for your game, we've
got those too.
Security measures that
we're taking on your behalf
and we're also allowing you to
take in order to help combat
and limit cheating
within your game.
Challenges, we've
got modal challenges,
further augmenting
challenge-based gameplay,
and making it even easier
for you to allow your friends
to send-- or your
players to send challenges
to their friends
within their game.
And then finally, we have
totally redefined the way
that you can handle
events with--
concerning the GK Local Player--
with the GK Local
Player Listener API.
So it's a ton of stuff that
we've got going on this year,
and that means that you probably
have a lot of questions.
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000
So Allan Schaffer,
he's our Graphics
and Game Technologies
Evangelist.
You can reach him at
this address right here.
Ask him if you've got any
questions after the conference.
Also, we've got brand
new documentation updated
for this year's Game Kit
Framework available at the URL
in the screen, as well as
at developer.apple.com,
we've got some sample code
exhibiting how you can make use
of best practices in order to
adopt Game Center features,
both new for this year
with iOS 7 and preexisting.
So definitely check that out.
As well as Apple developer
forms, definitely use those.
So a couple of sessions, what's
new in iTunes Connect tomorrow,
check that out if you want
to learn more about how
to use game groups
for Leaderboard Sets,
this new auditing tool
to help limit cheating,
turn-based gaming
with Game Center.
So thank you so much everybody.
Have a great WWDC.
It's been a pleasure.
[Applause]
[ Silence ]
X-TIMESTAMP-MAP=MPEGTS:181083,LOCAL:00:00:00.000