Видео

Please increase video resolution 😊

Thank you for this, it saved me from dying. :)

really very useful video. your explanation make it easy to understand! gave me new ideas to work and improve my games! thanks

Sup shawty.

Finally, a dude that's not talking about beginner "101" stuff. You earned a new subscriber from me. I don't actively look for intermediate and advanced stuff in RUclips so I'm glad I get recommended videos like yours -- I've been wanting to validate my knowledge on these topics and also gain some new insights on how to practice them. I realized from your video that the framework I've built follows the factory pattern in some way. Just to give you some context, I implemented a base ScriptableObject, and relevant Monobehaviour and regular classes that are needed to "build a level/mission." I've had my fun with generics (so much fun that one of my classes have 4 generic types requiring it, and it's nested with generic types too), while it was painful to write at first, it turned out to be solid as I'm able to just "create a new mission type" and have the underlying factory pattern build the mission on runtime without me worrying if the new mission/level type supports the same functionalities as other missions (these functions were enforced from the base classes that comes with that ScriptableObject I mentioned). There were benefits to having this framework: * portable (since the missions are now packaged as ScriptableObjects, it's easy to move them around from project-to-project or directory-to-directory so long as the unity project has the framework in it) * editable - I've built an editor window around that base ScriptableObject class (and just reused their custom Editor if they implement it) which allowed a neat editing experience for the game designer. * you have control over generating game objects - which is a stark contrast if you go with creating missions/levels with prefabs/scenes. There's a recent problem that I encountered where the mission and its objects should scale up/down and transform to a specific "play space" -- for context this is for an AR functionality. * easy to manage - I just drag-and-drop the scriptable object on a mission manager I created, generate the mission, and handle the mission start/restart/end/abandon from there.

Really helpful and clear to understand tutorial.

Very useful video, just what I needed, but the quality made it really difficult to follow. Would be nice to have it HD

Stir fry by migos

A big like to the helpful video. Thankyou so much!!

Thank you, you've helped me a lot! :)

can you please make vertex shader that rotates to the current camera position?

wow, cool game! when does it come out?

HOLY PEAK

Is this a game you made?

B A S E D

👌

nice

Love it!!

Scriptable objects are really trash at performance, 2 year project, i made everything with acriotable object at the end of the development cycle i have to remove all scriotable object and link them directly instead of getting from unity assets, a few bytes wrong lilla project but a lot of performance drops will,so stay away from scripts blender objects

Wow, cool game!

I'm pretty much already a pro at this game tbh

thkns its great to have this content !!

Base class should have a virtual method that your child classes will override, ie Jump(), in the pet class should be Virtual void Jump() and in cat or dog, you go Override void Jump() :: As for the List of Pets, I would have made a static list in the Pet class, on construct add to list, on destruct remove from list!

HEY! YOUR VIDEOS ARE AWESOME!! LET ME SAVE THEM IN MY PLAYLIST FOR GAMEDEV!!!

Hi there! Awesome video, really useful and clear. One thing I am not entirely sure about is why you use [Field: SerializeField] in your WeaponSO script. Whats the need for it? If you could clear that up that would be great :D

Why not use a base class that holds the maxHealth variable and derived class can just use it?

I use unity 2019 and I have problems with performance like if I add more than 10 object or more than 3 rigid body and max fps is 160 that decrease fast is the problem in my laptop

Your code example in theory is very good, it compacts memory usage. But there is a slight issue... size of float is 4 bytes (some machines it may be different). But ScriptableObject is a class, and we have a reference/pointer (memory address to the allocated location). And how much memory is a reference/pointer? 8 bytes. So you are increasing the memory usage. And if you have more than 1 common float & not multiple values of that variable, it is better to make is static or const. is the same thing, with no overhead, because it is global to the class itself. But if you have multiple values of multiple global variables, it is still better to leave it as class field. it is only a good optimization if you have multiple values for the global variables & have a lot of them (>= 5 to 10). BTW, keep learning & teaching 😎😎😀😀

Another upside of this is that you can tune the values in SOs in play mode and the changes will persist (unlike fields on a Monobehaviour). Good vid!

It's incredible to see someone following basic coding standards like doing early returns. It's weirdly rare to see in a unity video.

Great video mate, would love to have a better example of how to use this, maybe using switch statements too.

Although it's always a good idea to use ScriptableObjects for shared data, in this particular case (floats / value types) there's no memory savings happening at all, because each time you access the SO.float property, you get a new stack allocated copy of the value, not a reference to it.

Great video, never really considered that this pattern would qualify as a Flyweight lol It's used in a bunch of Unity games as a kind of Config-Presenter pair, where all the configuration (including adding models, behaviour, etc) of an entity is done at design time in scriptableobjects, and a monobehaviour just presents all the data at runtime. Pretty cool

Never seen a video explained scriptable objects good and clean like that, i will use in all my projects, thanks! 😊

TL;DR: use static variables, they are faster to access and don't need an object instance and reference, therefore you won't loose 4 bytes for holding a reference to SO. "We've lost nothing here" - Hm, actually you did. You lost some performance and introduced a few levels of indirection. Before you had a class with local vars, and every access of local var is just a memory lookup. Yes, now every instance will have 4-24 more bytes. First question: is that really a problem? If your game is memory-bound, then answer is yes. If it's not, and most of the games are not, then we don't need to optimize anything. Okay, let's pretend, that our game has 1000's of enemies and we loose some memory (24 bytes * 100_000 enemies gives us 2.4 MB, for example). Now we use reference to ScriptableObject as a memory-optimization technique, and now every enemy has a reference (4 bytes instead of 24). Here comes the problem: enemies shoot a lot, and they have their internal logic which is now slower. How? Every time we need to access weapon parameters, we have to take a reference, then de-reference it under the hood (AFAIK C# does that automatically), and then take the desired variable. 3 steps instead of 1, and de-reference step is slower than a memory lookup. So it's not x3 times slower, but a little bit more. So, we've traded our CPU-cycles for memory. It's quite uncommon, because modern PC's and consoles have a lot of memory, and always we are trying to cache things to prevent unnecessary CPU work. Okay, but if we still want to optimize it? Here comes a better option: static namespaces with constants, or static namespace with static variables. Instead of Scriptable Object we can create a class with just static variables. Accessing it would be slower than accessing local variable (nothing beats that), but still faster than using reference to an object. Some people suggest that C# JIT can optimize static variables like local variables, making them on par, but it needs real profiling. The most important thing is that using static variables doesn't require an instance of a class. Which means that we get the memory optimization too: we don't need 4 bytes no more. And speaking of memory, statics in C# are being stored in High Frequency Heap, which is a special area inside regular heap. Hope it would help.

Wtf since when can you serialize properties?

Amazing tutorial i wanted to lear the flyweight pattern for quit some time. Now you vid made it clear

Hi Gabe - Robert accidentally shut down his computer while you were finishing zoom- sorry about that! he says thank you and sorry we couldn't figure out another way to contact you 😂

❤ Groover is so groovy!!!

Great content! Thanks for sharing

Very educational I recommend this channel

Cool!

Hi, you used to code me for RP4K, I was the kid who put the games on a website.

Great video!

Awesome concept!

Brilliant!

That's epic and stuff, but how do you start the game!? I pressed every key and it didn't work. The controls aren't on the itch.io page, bruh!

Game Link: flamingoezpz.itch.io/fishing-game