Yes, for re-usability, code maintance and code extensibility loosely coupled code is must. and for loosely coupled code, observer pattern is must have.

if that is a daily discussion topic i wouldn't stay long there.

@@nitras.design Why do you hate discussing architecture?

@@CoReeYe he doesn't hate it, he's just saying if the entire team is sitting around discussing things a junior should already have engrained into him you must be working for a joke of a company

Thank you :) I definitely recommend everyone take a look at the book too. He does a good job explaining how the patterns work and some of their origins.

same here

Yessssd

Agreed.

hmm, i'll definitely consider it lol. not sure how it'll feel w/ how bright my office is, but i can give it a shot :)

This is the theme I use. Not too dark but just right for day and night use in my opinion. It says "VS 2015" but will work with 2017 no problem. There are lots more on the website as well to choose from. studiostyl.es/schemes/indie

Thank you very much! :) I really like doing examples like this, just takes a while to put together a good one that's really usable in a project but fits into a short video, but it's also a lot of fun :)

@@Unity3dCollege I was just watching the video again (1 month later), getting inspiration for coding and saw you answered my comment. Thanks for the response, I truly enjoy the content you put out for us!

Thanks! :)

Ah thx !: )

It's on my shortlist for things to cover soon :)

@@Unity3dCollege much appreciated!

Sebastian Lague did a realy good job on explaining events. search for it on his channel.

Very welcome! :)

It is easy. If you have monoBehaviours, you should use UnityEvent. It is powerful while if you have plain C# classes, employ C# events. You know why UnityEvent is powerful because it decouples your codes and you add listeners/observers inside the inspector not inside codes but one big drawback is that you can not rename the functions easily because you have to add them again (missing references)

They're slower so it also depends on the optimisation you're looking for

There's no real drawback, I've just gotten in the habit of using ?.Invoke but didn't want to use that here since it's a bit outside the scope. But if you're able to use the latest .net, ?.Invoke() is the way to go IMO :)

?.Invoke() ? What do you mean? How would it look here?

@@ZoidbergForPresident OnPointOfInterestEnetered?.Invoke();

@@ZoidbergForPresident hi I know it is late to comment on your question but " .? " operator basically checks if left hand of the statement is null. Here is the reference to official .net explanation. docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators

public delegate void PropertyChangeHandler(); public event PropertyChangeHandler OnNameChangedEvent = delegate { }; public event PropertyChangeHandler OnLevelChanged = delegate { }; public event PropertyChangeHandler OnGoldChanged= delegate { }; public void RegisterOnNameChangedHandler(PropertyChangeHandler handler) { OnNameChangedEvent += handler;} ...

I asked that "How can we implement abstract classes or interfaces?". I mean, abstract Subject implementation. By the way I dont like event callbacks, Interfaces 2.5x faster than events.

That's the point where using event would be a lot better. Maybe doing enum of event types would be good? Then AchievementSystem would do something like if(eventType == EventsType.HealthChange) { ... doing something with the value ... }

The only way is to split things in several MonoBehaviours that derives from Subject. So there would be PlayerName.cs, PlayerLevel.cs, PlayerGold.cs. And place them on player GameObject. Composition! XD I`m also dont like c# events, but not because of performance. You can't serialize c# events, also no way to access listeners and debug things. I think the best way to do events in unity is ScriptableObject's Events. The 'must have' video: kzfaq.info/get/bejne/qMeBZsx5zavDe58.html (27:33)

@@STARasGAMES I already thought about that but I am finding better way, thanks any way :)

Isnt that like the react way of observer pattern?

​@@LanPodder The flux pattern is a larger idea than observers, and would use observers on specific pieces of state to fulfill subscriptions. Flux details how data flows and interactions happen, not just what piece of data belongs to a or many interact-able entities.

What do you mean by Unity built-in events? UnityEvent?

Definitely. I don't normally do my observables with them, but there have been a few projects where it was a good fit, I'll see if I can put together a good example sometime soon.

It is limiting. If you use a base class to subscribe to subjects, then it becomes difficult to inherit from other things. Say if you had a base class for Spells, but you also have a Fireball that should also be an observer. If both Spell and Observer inherit from Monobehaviour, you simply can't inherit from both in C#. Multiple inheritance comes with several issues and you might not want to have your systems be made in a way that makes these things occur.

In the same book this video is based on, the author (and its sources) advises to not use singletons too often...

So maybe we can finally get to the bottom of this, are singletons used in game programming these days or not? So many ppl have varied opinions on this it's difficult to get a straight answer.

Generally it wouldn't use a find, there'd be a singleton or some other way to inject to object. Much of the time though, the things observing something are the same things that create them, so I often find myself registering events right after creating the new object. On singletons... there are drawbacks & it's very easy to fuck them up and make your project a mess... but they're used almost everywhere, and using them carefully can be completely fine IMO. (i've been back and forth on this a lot over the years lol)

@@OtakuDYT There's nothing wrong with using singletons per se. It's a simple pattern and it works. But as your project grows they may fuck you up. Say, you have this achievement system as a singleton, everything's fine, you're happy, and now 2 years down the road you decide that you want to have a local multiplayer (split screen) in your game where both players are logged in and both can unlock theirs achievements (don't know if anybody actually would want that, but that's just an example). So, now you need to have two achievement systems, right? One instance for every player. But it's a singleton, so you can't. And so the journey begins. You make it a not-singleton, just plain old instance. But you still have AchievementSystem.GetInstance() all over the place. So you have to get rid of that. And now what? Well now you have to provide the instance of achievement system to every other object instance that depends on it. Not an easy task when you have a lot of code structured around the assumption that everything is a singleton, with many layers of abstractions. It gets even harder because now you have two instances of the system, and you need to somewhere / somehow decide which instance of the achievement system to pass to which game objects. It probably would be better to just leave the system as a singleton, and make it support any number of players, and pass the player that unlocked the achievement as an argument when calling the system. And in this specific case this may be a good enough solution. But in other situation may not. Also, singletons are not great when it comes to writing tests - which you should if you're making anything more sophisticated than a pong - because you can't see (from the outside of the class) that it's using some singletons, and even if you know it, it is still hard to mock them. Sure, you can always do some monkey patching magic or what not. But at this point it is just more hassle than it's worth, i'd say.

@@plunntic Thanks for that, yeah I'm currently busy trying to use things like scriptable object events to trigger things rather than direct system connections. Probably going to be issues with that down the line too but all I can do is improve as I go as necessary.

HAWXLEADER with a singleton pattern, while you have global access to the singleton instance in any class, you have to directly call an object method. it’s like a 1 to 1 interaction. The object is not listening to a signal as you called the method directly. With the other observer pattern, you fire a notification (signal) and any listeners will respond to the signal. So you can have day 10+ objects listening to the same signal. When the signal fires all 10 objects will get notify and do their thing.

C# events are great in non gaming apps. In gaming apps, you don't want GC allocations and events/Action/delegate will add this behind the scenes giving the GC a random chance to run during gameplay and introducing micro pausing in your main thread which is judder, affecting the smooth FPS you desire.

Delegate & events are essentially a c# implementation of that observer pattern functionality, wrapping up a lot of the underlying code :)

Have you worked with javascript? Because events are used a lot there aswell and i found that knowing about those helps with understanding this pattern

"cliché"