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
The Event Manager
Loading...
Del curso dictado por University of Colorado System
Intermediate Object-Oriented Programming for Unity Games
17 calificaciones
University of Colorado System
17 calificaciones
Curso 3 de 5 en SpecializationC# Programming for Unity Game Development
De la lección
Feed the Teddies
Conoce a los instructores
Dr. Tim "Dr. T" ChamillardAssociate Professor
Computer Science
In this lecture, we'll look at the EventManager for our Feed the Teddies game.
And this EventManager is more flexible and robust but
also more complex than the event managers we've seen so far in the course.
The first chunk of code we'll look at is the EventName enumeration.
So this is just an enumeration that has the names of
the five different events that we have in this particular game.
We have an event for when the game starts.
We have an event for when the game is over.
We have an event for when the health changes,
when points are added, and when the timer is changed.
This next class is a little more interesting.
This class is called the IntEventInvoker because it is
a class that invokes one or more Int events.
The Dictionary here is a new collection class that we haven't looked at before,
but I will tell you that dictionaries have a key.
In this case, we're using EventName and a value.
In this case, it's a UnityEvent that has one int argument,
and we can look up values by using keys.
And that should remind you of PlayerPrefs where we looked up values using keys.
The difference here is that in C#,
our key doesn't have to be a string.
It can be any data type we want and the value doesn't have to be string, int, or float.
It can be any data type we want.
So here we're using keys of that enumeration I just showed you,
and the values are actual event objects.
Now, you should go do an in-video quiz about dictionaries.
The reason we have a Dictionary here is because we will end up before we're
all done with classes that actually invoke more than one event.
And so, we couldn't just have a field for the UnityEvent int.
We needed to have a dictionary of unityEvents so
that classes can invoke multiple integer events.
We also have an AddListener method where the eventName
and the listener to listen to that event are passed in as parameters.
And notice, of course, this is UnityAction with one int argument because that's
the appropriate delegate for listening to a UnityEvent with one int argument.
So we pass those two pieces of information in as parameters.
And we check with the ContainsKey method to see if that
particular eventName is supported by this particular invoker.
So ContainsKey checks for that key.
And if the Dictionary does contain that key,
we know we have a UnityEvent with one int argument for that particular event name.
So we do our standard add that listener to the invoker where
we get the invoker by putting the key in between square brackets.
So this is much like indexing into an array,
but this time we're using a key to find something in the Dictionary.
The EventManager is the most complicated part although
those other two pieces are things we need for our event system in this game.
The EventManager has two dictionaries,
and the key again is by EventName.
The Dictionary of invokers is a list of those IntEventInvokers,
because we might have multiple invokers for a particular event.
And so, we have a list here instead of just a single invoker.
Similarly, the listeners is a dictionary of a list of
listeners where each one is a UnityAction with the one int argument delegate.
And that's also keyed by the EventName.
So, the EventName gives us a way to map between invokers
and listeners as we're adding invokers and adding listeners through the EventManager.
This Initialize method actually goes through and make sure that
the Dictionary has empty lists for every possible EventName.
So this part up here might look a little unusual to you.
Basically, what it's doing is it's going through each of
those five values in
the EventName enumeration and doing stuff with that name inside the loop.
And so, if the dictionary doesn't have that name already,
it creates new lists for the invokers and listeners.
And if it already does have that name,
it just clears the list.
We do it this way because this Initialized method
might be called multiple times as we play the game.
And we don't want to try to add a new list if
the Dictionary already does contain a particular name,
because that throws an exception when we try to add
something with the same key as the dictionary already has.
Adding an invoker looks very similar to what you've seen in the past,
although this time we were passing in an eventName in addition to the invoker,
and notice there's that IntEventInvoker type.
And then we add all the listeners we have for that eventName to this invoker,
and then we add the invoker to the list of invokers in the Dictionary for that eventName.
Adding a listener is similar.
And finally, we actually have something new in this EventManager where we
remove an invoker by passing in the eventName and the invoker.
And we go to the Dictionary and we remove that particular invoker.
And this is an efficiency thing.
As the game runs,
we have invokers that are destroyed.
And we might as well take them out of the Dictionary as they're
getting destroyed rather than keeping them hanging around.
Those are the core ideas behind the event system in the Feed the Teddies game.
To recap, we explored how to implement a pretty robust EventManager.
We also saw how we can use C# dictionaries in
an EventManager though of course you'll use
dictionaries in other places in your game development as well.
I said in the lesson introduction that this is one
step away from commercial quality EventManager.
And the one step is to have an EventManager that
supports various types for the invokers and the listeners.
And once you take that step,
you've got an EventManager you can use in a commercial game,
and that's exactly what I'm doing in my balloons extreme game.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2018 Coursera Inc. Todos los derechos reservados.
