This course is the third course in the specialization about learning how to develop video games using the C# programming language and the Unity game engine on Windows or Mac. Why use C# and Unity instead of some other language and game engine? Well, C# is a really good language for learning how to program and then programming professionally. Also, the Unity game engine is very popular with indie game developers; Unity games were downloaded 16,000,000,000 times in 2016! Finally, C# is one of the programming languages you can use in the Unity environment. This course assumes you have the prerequisite knowledge from the previous two courses in the specialization. You should make sure you have that knowledge, either by taking those previous courses or from personal experience, before tackling this course. The required prerequisite knowledge is listed in the "Who this class is for" section below. Throughout this course you'll build on your foundational C# and Unity knowledge by developing more robust games with better object-oriented designs using file input and output, inheritance and polymorphism, and event handling. This course gives you even more tools to help you build great games with C# and Unity! Module 1: Start using files to implement your Unity games Module 2: Learn how inheritance and polymorphism help us write less code for our games Module 3: Implement event handling to make better object-oriented designs and add menus to your Unity games Module 4: Explore the complete implementation of a small Unity game Module 5: Complete final peer review “Unity” is a trademark or registered trademark of Unity Technologies or its affiliates in the U.S. and elsewhere. This course is an independent work and is not sponsored by, authorized by, or affiliated with Unity Technologies or its affiliates
Basic Gameplay
Loading...
Do curso por University of Colorado System
Intermediate Object-Oriented Programming for Unity Games
46 classificações
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
University of Colorado System
46 classificações
Curso 3 de 5 em Specialization C# Programming for Unity Game Development
Na lição
Feed the Teddies
Conheça os instrutores
Dr. Tim "Dr. T" ChamillardAssociate Professor
Computer Science
In this lecture, we'll look at the implementation
of the basic gameplay in our Feed the Teddies game.
So let's get to it.
As you can see,
we have lots of prefabs to support our gameplay,
and we have lots of scripts to go along with those as well.
So, let's go look at the code for
the key game objects without trying to cover everything completely.
We'll start with the burger class which is
an IntEventInvoker because it invokes Int events.
We have some stuff for blowing up and shooting french fries,
we cast some collider dimensions,
we have some other boundary checking stuff included,
we set the health to 100,
we do firing support so that we have a cooldownTimer to control our firing rate,
and we use this canShoot field to help us do that.
Here in the Start method where we initialize a bunch of stuff,
we set up the screen coordinate stuff,
we cache that collider information,
and here's where we use the EventManager.
So first, we add a HealthChangedEvent to our dictionary of unityEvents.
Remember, this is in the IntEventInvoker class,
then we add ourselves as an invoker for that HealthChangedEvent to the EventManager.
And then, we also add the GameOverEvent to our dictionary of unityEvents,
and then we add ourselves as an invoker for the GameOverEvent to the EventManager.
So, the Burger class is the reason that we needed to have a dictionary
of unityEvents that have an Int argument rather than just a single field.
We also set up our cooldownTimer.
So we add a timer component,
and we set the duration to what our configurationUtils say,
is the BurgerCooldownSeconds, and then we add a listener
to the cooldownTimer to listen for when the timer is finished.
I made some modifications to the timer for this game,
so the timer works much more like a regular timer where
instead of checking to see if it's finished on every frame,
we just wait for it to tell us it's finished by invoking an event,
and we listen for it here.
In update, we move horizontally and vertically, and ClampInScreen.
And we also adjust to this canShoot field that controls our firing rate.
So, if we can't shoot right now,
so we're cooling down,
but we're not providing any input on the fire access,
then we stop the timer,
and we set the flag to true again.
So, this allows the player to spam the fire button
so they can shoot as quickly as they can press and release the spacebar.
The more general automatic firing,
if we canShoot and there's an input on the firing axis,
then we start the cooldownTimer,
we set the flag to false,
and then we instantiate french tries to shoot.
If we have a collision with something,
we check to see if it's with the TeddyBear.
And if it is, we create an explosion,
we destroy the teddy bear,
and we call a TakeDamage method that we will look at soon.
We also look for triggers,
so the burger actually has
a regular box collider and a trigger box collider attached to it.
And, if in fact we have FrenchFries entering the trigger,
we set up an explosion and destroy the french fries.
Those are the french fries we're shooting.
So if we run into them by mistake, we get rid of them.
If it's a TeddyBearProjectile that we've just collided with,
then we set up an explosion,
and we destroy the TeddyBearProjectile, and we TakeDamage.
I wrote the TakeDamage method because we take damage from
both teddy bears and TeddyBearProjectiles.
The clamping stuff is as you'd expect.
When that cool down timer finishes,
we just reset the flag to true because we're
cooled down and we can shoot some more french fries.
And here's that TakeDamage method.
First, we set the health to the maximum of zero or a health minus damage.
So this keeps us clamped so we don't go below zero in health,
and then we invoke this event,
the HealthChangedEvent with the Int argument,
our current health, and then we check to see if the game is over.
And if it is, we invoke the GameOverEvent.
Now, we have to provide an Int argument here
even though we don't actually need an Int argument here,
but that simplified our EventManager because we could have
everything that invokes events be an IntEventInvoker,
and the unityEvents with one Int argument is the only kind of event there is in our game.
FrenchFries are much simpler.
We get them moving when we start.
FrenchFries might invoke the PointsAddedEvent.
So we do the standard create that event here in this object,
and then register it with the EventManager.
When FrenchFries become invisible, we get rid of them.
And here's that RemoveInvoker so that we don't have the FrenchFries script hanging around
in that dictionary in the EventManager after
the FrenchFries game object it was attached to gets destroyed.
If the FrenchFries run into a TeddyBear, that's great.
That's what we're trying to do,
we're trying to feed the teddies.
And so it invokes the PointsAddedEvent to give us points for doing that,
it creates an explosion,
it destroys the TeddyBear,
it creates another explosion,
and it destroys the FrenchFries.
If you don't destroy the FrenchFries when they hit a TeddyBear,
they just tunneled right through that teddy bear
and hit another teddy bear if there's one there.
And that's fun, but that's not the way it really ought to work.
If the FrenchFries are colliding with a TeddyBearProjectile,
we destroy both the TeddyBearProjectile and the FrenchFries.
And this is actually an interesting gameplay thing because you
can shoot those teddy bear projectiles with french fries to protect yourself.
There is a HUD in the game,
and the HUD displays the score in the health bar and that countdown timer.
So, when we start up the HUD,
we add a listener for the PointsAddedEvent just in case the score changes.
We add a listener for the HealthChangedEvent just in case the health changes.
We add a listener for the TimerChangedEvent because we are
going to need to know when the timer moves from 30 seconds to 29,
for example, so that we can update this play.
So we'd listen for that event,
and we initialize the timerText.txt.
This property to get the score is accessed by our game manager script.
HandlePointsAdded adds those points to the score and changes the score text.
HandleHealthChanged changes the value of the health bar,
which is just a slider.
I used a pre-built UI component in this game for the health bar.
Of course, you can do something much fancier that moves from green to red,
and so on as health is reduced,
but I didn't for this game.
And when the TimerChangedEvent happens,
we change that countdown timer text.
The TeddyBear class has some stuff so it can shoot TeddyBearProjectiles.
It starts moving as usual,
and it creates and starts that shoot timer,
including adding a listener,
to know when the timer has finished.
The StartRandomTimer method is just a method I wrote
that sets the duration of a timer to a random range,
and then starts the timer.
When that shot timer finishes,
we instantiate a TeddyBearProjectile and start another random timer.
This way, the TeddyBears aren't firing every second,
there's some variation in when they shoot and that makes it seem more realistic.
And there's that method I was talking about,
the StartRandomTimer that sets
the duration to a random range and then starts running the timer.
The TeddyBearProjectile is also relatively straightforward,
so we get it moving at the start.
When it becomes invisible, we destroy it.
OnTriggerEnter, a TeddyBear could have run into the TeddyBearProjectile,
and if it does, we destroy the TeddyBearProjectile and blow it up.
If a TeddyBearProjectile runs into a teddy bear projectile
which is certainly possible as you have multiple teddy bears shooting these things,
it destroys both of those objects with explosions, and that's it.
The final class that we'll look at here is the FeedTheTeddies class,
so this is essentially the game manager for the game.
There's a game timer,
so this is that countdown timer that I've been talking about.
And it keeps track of the HUD,
and we'll see why soon.
The Awake method is called before any of
the start methods on any of the scripts is called,
so we create and start the game timer.
And we also add to our dictionary of events,
we invoke a TimerChangedEvent,
and then we tell the EventManager that we are an invoker for that event.
And then finally, we listen for the GameOverEvent which remember,
the burger will fire when its health gets to zero.
In update, we'd just checked to see if the players trying to pause the game.
When the game timers finished,
we call this EndGame method that I wrote that we'll get to.
When the GameOverEvent is invoked,
we also call this EndGame method,
that's why I wrote the method.
And ending the game sets the high score and
tells the menu manager to go to that high score menu.
Now, you might be wondering why I didn't just remove these two methods all together,
and I couldn't because they have different method signatures.
I couldn't just replace them with the EndGame
because this one has one Int parameter even,
though that parameter is unused.
So, this is where I just said,
I would have one Int perimeter here so that I could have
the EventManager only needs to hold unityEvents with one Int argument,
but it's unused here.
So the SetHighScore method actually gets the HUD's script from the HUD,
accesses the property, remember I show you where that happens,
and then it does some stuff with PlayerPrefs.
So if there's already been a high score recorded,
and this is a new high score,
then we set that PlayerPrefs to
the current score because it's the new high score, and then we save.
And if there isn't a high score value in PlayerPrefs yet,
we set the high score to the current score, and save it.
That was a whirlwind tour of the classes that
we use to support gameplay and there are some other minor changes too,
so feel free to explore the code as much as you want
to make sure you understand how this basic gameplay works.
To recap. In this lecture,
we saw how we could implement a variety of gameplay objects,
and we also saw how those objects can interact with each other
through the EventManager so they don't actually need to know about each other.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
