[MUSIC PLAYING]
MOE SY: Hi, everyone.
Thank you for joining the Google for Games Developer Summit.
My name is Mo.
I am a cloud gaming architect at Google Cloud.
Today I will be joined by Christina and Jason
from Unity to talk about Unity Game Simulation.
If you're a game developer, you probably
know Unity, the leading real-time 3D development
engine that supports over 25 platforms and powers 50%
of all new games.
What you might not know is Unity and Google Cloud
have partnered for years to make game development easier
and more accessible for more creators using
the power of the cloud.
Last fall, Unity announced a Unity Simulation,
a new cloud-based product that enables designers, developers,
and creators to generate synthetic training
data at scale, as well as test, train,
and validate all their computer vision and perception projects
in Unity by harnessing the power of the cloud.
Within Google Cloud, Unity leverages Google's turnkey
Kubernetes solution, GKE.
GKE, or Google Kubernetes Engine,
gives Unity developers a secure way
to manage and operate simulations at scale.
GKE provides strong security defaults,
such as encryption at rest, encryption in transit,
leading to a more secure environment for Unity
developers.
As an added benefit of running GKE,
Unity is able to seamlessly integrate with GCP's ecosystem.
Unity uses Google's virtual private cloud
to define its global network, as well as Google Cloud Identity
and Access Management to manage fine-grained access control,
each of which have first-class integrations within GKE.
Today, we're excited to help our friends at Unity
announce their latest innovative product
in the world of simulation that's specifically
tailored for game developers.
I would like to introduce Christina from Unity
to talk about Unity Game Simulation.
CHRISTINA GUO: Thanks, Mo.
Creating games is hard, and launching a quality game
is even harder.
Yet the first impression your game makes on your players
can determine its long-term success.
To build a quality game, you need to thoroughly balance it
prior to launch.
A well-balanced game will create a fun experience
for all your players.
You'll appeal to more players and keep
them happy and engaged, which means a higher lifetime value.
So how do you create a well-balanced game?
Currently, the answer is extensive manual balancing.
Through spreadsheets and human playtesters,
you'll tediously try to find the right damage value for a weapon
or the ideal speed of a character.
But these are just two of hundreds of possible parameters
that you might want to adjust in your game.
In order to get these right, you may
need to spend hours tweaking values
in oversimplified and inaccurate spreadsheets.
Or you contract dozens of human playtesters,
but the feedback you receive is subjective and costly.
Today, we're excited to announce Unity Game
Simulation, supported by the Google Cloud infrastructure.
Unity Game Simulation is an affordable solution
that complements your pre-launch play
tests to provide faster iteration and results at scale.
The tool allows you to balance more and iterate on your game
more often.
Using the online dashboard, you have the power
to setup, run, and analyze thousands of simulations.
Because these player interactions
run simultaneously, you also speed up your balancing.
The scale of cloud balancing provides more accurate results
than manual balancing and spreadsheets
[? can ?] replicate.
This quantitative balancing coverage
costs a fraction of a playtester's hourly rate,
giving them more time to focus on the look
and feel of the game.
Let's dive into an example.
Furyion Games, a Canadian game development studio,
created "Death Carnival," a fast-paced top-down shooter.
One of the features of the game is the weapon socket system.
Each weapon allows players to select a base weapon, ammo,
weapon module, and temporary power-ups.
Each of these combinations is made up
of many variables that control the play style
and efficiency of the web.
In earlier versions of the game, the team
balanced weapons by hand.
They would configure a weapon, compile a build,
send it out to playtesters, and watch them play.
Based on the feedback, they would reconfigure the weapons
and repeat.
Each iteration of this process would take hours.
Enter Unity Game Simulation.
Furyion used the tool to run thousands of simulations.
They were able to identify the right combinations of base
weapons, ammo, weapon modules, and power-ups
for their desired survivability and level completion time.
This allowed them to ensure the weapons were balanced.
By configuring the weapon parameters and multi-stage
simulations, Furyion was able to condense
the equivalent of 165 million playthroughs
into just 10 efficient simulations,
taking just over three days to balance their weapons system.
They estimate that the tool saved them $80,000 and 600
hours of dev time.
Those resources would just previously
have been spent on managing playtesters, measuring
weapon performance, and compiling builds.
Now, they can instead be spent on polishing
the creative elements of the game.
Jason, an engineer on the team, will now
demonstrate how Furyion achieved these results.
JASON GRECO: After deciding to use Game Simulation,
a game developer at Furyion implements
the Unity Game Simulation package and uploads
a build to the game simulation service from the editor window.
I won't go through this in detail,
but the process is simple.
Once the developer has uploaded the "Death Carnival"
simulation build, it's time to create a simulation
from the web UI.
This is where designers configure and run simulations.
For this "Death Carnival" simulation,
we will be testing 45 key combinations of weapons, ammo,
and modules 100 times each in order
to establish the mean performance of each combination
with high confidence.
Let's name this build Phase 1.
And we'll select our build from the dropdown.
For the values in our simulation,
we'll be testing shotgun, machine gun, and missile.
Our ammo count will be 10, 15, 20, 25, and 30.
And for our weapon module, we'll be using triple
shot, wave, and burst.
Once this simulation is finished,
we'll get a spreadsheet with a row for each combination
of these parameter values.
And lastly, we'll run each combination 100 times.
So in total, this will run 4,500 combinations of simulations.
So fast forward one hour, and we can
see that this simulation has already completed,
and we have our aggregate data.
So let's open up this data.
I've gone ahead and imported the file into Google Sheets
and made a chart with the level completion time
by weapon combination.
So here we can see the chart.
And in this chart, we see the shotgun and machine
gun both have some pretty underpowered combinations.
As a next step, I can buff these combinations
and run the simulation once more.
Furyion has already done this, so let's take
a look at the final results.
And we can see that the underpowered combinations have
come down pretty drastically in player completion time, which
translates to a much better gameplay experience for "Death
Carnival's" players.
Now that we've seen Unity Game Simulation in action,
let's peel back the onion a bit and talk
about the underlying infrastructure.
We chose GKE to build Unity Game Simulation
on top of because it gives us the container
management we wanted.
With Google Compute Engine, we would
have needed to manage the components individually,
such as auto scaling, networking, security,
container health, et cetera.
With GKE, we just specify what we want,
and it's managed for us.
One of the most important features in building Unity Game
Simulation is GKE's auto scaling.
We need the ability to dynamically scale up
our number of resources so we can quickly
handle workloads of thousands of simulations
without having to pay for idle resources.
Because games all have different system requirements,
using separate node pools, we're able to adjust this instance
type for each game when we schedule a simulation.
With Unity Game Simulation, users
tend to run a mix of smaller and larger batches of simulations,
so it's important for us to have fast scaling of resources.
The smaller number of simulations a user is running,
the more impactful any extra overhead is,
so being able to quickly scale up as needed
lets us handle both types of workloads.
In addition to GKE, we used a number of other GCP offerings
in building this tool.
One example is Stackdriver, which we used for our services.
The log aggregation and metric instrumentation
around GKE and other Google Cloud resources
helped minimize the work in setting up our dashboards
and alerting as we transition from our initial proof
of concept into a production system.
Because we're running user code, it's also important for us
to sandbox everything as much as possible.
With IAM and RBAC, the user code containers
can be configured to run with no permissions
to any GKE or GCP resources, even on the same node.
IAM also helps secure our resources and data
by locking them down to just a few necessary admins
for a services so we're able to create a service
account for each of them with the minimum required
permissions.
In addition to GKE and other products we just mentioned,
I'd like to quickly cover some of the other tools
that we found very useful in the development of Unity Game
Simulation.
First is Cloud SQL, which we're using
as the database for services that manage our job state
and orchestration.
Second is GCR, which we're using along with IAM that I mentioned
earlier for securely managing all of our Docker containers.
We also use Dataproc for handling
the aggregation of our simulation data
from each of the individual simulation instances.
And finally, Terraform, which helps us
manage all the GCP infrastructure that we have.
In summary, Unity Game Simulation
creates a more efficient, accurate, and affordable
solution for game balancing.
It complements playtesting, backing human feedback
with quantitative data.
Try the open beta for free.
Visit unity.com/products/game simulation for more
information, and thank you all for watching.
[MUSIC PLAYING]