All language subtitles for 002 Observers With UnityEvents_en

Hello and welcome in this lecture, we're going to be implementing the observer pattern using unity

events, and if you haven't come across them before, we're going to do a brief overview of them and

see how they fit the observer pattern.

So let's start with an example to really understand how the observer pattern works in practice and what

mechanisms we might use to implement it in unity and C-sharp.

So here we were mentioning that I have a game where you can level up so you can get experience points.

This is a level monitor behavior here, a level component and we've got experience is basically the

only state of this class.

The configuration is how quickly it gains experience over time.

This is just a very simple little hack so that we don't actually have to implement any gameplay where

in this method here, if you're not familiar with routines, this is a code routine.

And what it's doing is you can basically say it like this.

It repeats it loops around a weights two point two seconds and then it gains 10 experience.

So it just keeps gaining experience every point two seconds.

That's how it levels up, and the configuration here is the points per level.

So this is goes back to my point about not caching stuff.

We don't have you noticed a variable that tells you what level you are because you can calculate that

from your experience points.

So if we go down to the level method, you can see that it's simply the experience points divided by

the points per level.

And because these are both integers, this ends up being an integer division.

And if you have less than the points per level, you are level zero.

Once you have, say, 200 points, you then a level one until you have 400 points, then you're level

two, etc. Get experience.

It's pretty straightforward.

Gain experience again.

Pretty straightforward.

Gets it set settings here, really?

So this is a very basic class.

Now we've got a health component, and this health component kind of has some little hacky logic here.

Again, we've got this kind of health drain code routine and all this is doing.

If we're going to have a look at it is it will drain the health down to zero at whatever drains per

second every seconds.

I just remove something from the health every second.

So again, we've got this game played little test for us and at the beginning we reset the health.

So the current health gets reset to the full health in a week.

So then we've got some Getz's and we've got a reset health public method, which we might not want to

be public in the long run.

And then finally, there's a debugger mono behavior, which simply every second is putting out the vital

stances put.

It's logging the experience, get level and get healthy.

So if you run this, it really does not do very much.

You can see in the sample seen here, we've got the observer example and we've got a possible system.

If you go ahead and just play, the political system doesn't run by default.

It's been set up to not run on a wake, and we've just got our log messages down here saying the experience.

As it goes up and up and up, you can see the level that's being calculated and printed here.

That's working, as I explained, and the health, which is just steadily decreasing and decreasing

and decreasing.

Now suppose that in my game, I wanted to implement behavior where my health gets reset whenever I level

up.

Now the naive way to do this, if you didn't know about the observer pattern, would be to go into level

and say, OK, well, whenever I gain experience, I need to check whether I have leveled up.

So before I gain the experience, I'm going to keep a note of what my level was.

So I'll say that the level is equal to get level when I start off.

So that's kind of made a copy of that initial level.

And then after I've gained experience, I can simply say if the new level so get level is greater than

level, then I can do whatever it was I wanted to do, which in this case would be to get components

of type health and to call reset health on that.

Obviously, this has created a link that doesn't really make sense.

I mean, why should the level component know anything about health is is a rule more about the health

components, more that the health component wants to be reset when level levels up.

So instead of doing this, what you could do is remove all this logic from here.

I'm just going to come and sit out for a second because we will need this in a little while.

And what you can do instead is you could go ahead and go over to health and you could decide that we're

going to reset health by polling, polling, basically being checking every frame.

So we would go into here after a while cut out an update method in this update method.

First of all, I need to be keeping track of the current level to see whether I've leveled up so far.

For a start, I'm going to have to create a kind of extra piece of state in health to do with level,

which is weird.

But we'll get to that in a second.

Then we're going to have the last call at last level, that piece of state.

I'm going to set to zero, but I'm actually going to initialize it in start if we access other things

we shouldn't do in a way, Krista and start.

So we're going to get components of top level.

Don't get level, we're going to initialize last level to that value and then in update, what we're

going to do is if last level is less than current level and I need to get the current level into a variable

and say, let's do an its current level is equal to this same line here.

Get component level, get level notice.

I'm not caching this level component here.

I'm just getting it when I want it.

And then if we have increased, then we need to store a new last level.

First of all, so last levels equal to current levels so that we don't go resetting every single frame.

And then you can call reset health.

This is complicated and it is polling, which means that this is happening every single frame we're

having to check and get the other level and compare, even though we arguably could know when we did

it the other way.

Then we called it from level that was much more efficient.

It was just the dependencies were all wrong.

So what we want to do is for us to be able to subscribe.

This is a perfect example of the observed pattern.

We've got something that we want to observe.

The subject, which is level and the observer is health and wants to observe that level.

So how can we do that?

Well, one way that you can do this in Unity exclusively is using something called a unity event.

Now I'm going to start with this because although it might not be the most obvious suggestion, it is

quite easy to understand.

So what you can do is you can create a serialized field that has the tight unity.

Event and we can call it something like on level up, and you don't have to give it any value at all

that automatically gets set up correctly by unity.

So on level up now, what are we going to do with on level up?

Well, let's uncomment this coat that we had in gain experience.

And when we do level up, we can detect that on Line 24 with that if statement we can do on level up

dot invoke.

So you see that on the on the unity event has this invoke functionality.

Now what that does is it essentially calls a notification on anybody who's listening to this unity event.

Now how do we go and listen to the event while there's ways of doing it?

But the obvious way is to do this in the inspector.

That's why I've made it a serialized field so I can go ahead and remove this start code and update code.

We don't need that anymore.

Let's get rid of that.

We can get rid of the extra state that we included there as well.

We don't need that.

And then we head into unity, let it recompile itself.

And if you go to the observer example game object, then essentially what we can do is this level script

now has this on level up section, and you can add items to this list of observers.

And basically, what that's going to do is everything in this list will get cooled when we level up.

So, for example, we've got a particle system here.

You can link all sorts of gameplay events to this on level up event so I can drag in my particle system

game object into the object, the target object to run.

And then with the function, I need to go ahead and select that.

I wants to run a function on the particle system components and then I need to go down to whichever

function I want to run.

This case is going to be the play, and what we can do now is observe that if we go ahead and hit play

and we're gaining experience periodically, you should see the log messages down here when we reach

200.

You can see it played a particle effect, a signal that I leveled up.

I level up again plays a particle effect again.

So every so often it's playing a particle effect in response to that unity event.

This is the observer pattern in action, except it's an observer pattern that isn't fully realized in

code is configured using the unity event configured using the Unity editor.

So here's a challenge for you to replenish the health using this unity event that we have just created.

Go ahead and add the unity event in that code that I was writing the first part of the lecture to the

code that you can download as a resource against this lecture, then add a unity event.

Call back a new one.

We've got one talking to the particle system at a new one.

Hook it up to the observer example game object and call the reset health method.

So pause video and have a go.

OK.

Welcome back.

So how are we going to do this?

Well, we're going to start off by going into unity because we set up these unity events that we're

going to add a new call back.

We're going to drag the observer example as the game object targets in here.

Then we're going to go select function.

You can see it's showing us the components are available on that game object.

We need to find the health component.

We need to get to the reset health and they go, we're now calling reset health when we level up, so

if we go ahead and hit play.

Then you can see we're gaining experience, then we level up and our health goes back up to maximum,

so we're not we're constantly draining the health, but it also gets reset every time we level up.

Great stuff.

So that shows us how the observer pattern can be implemented using unity events.

In the next lecture, we're going to look at how we can implement it using delegates and actions using

pure C-sharp.