I work on a physics-heavy project with a lot of rigid-bodies which is also code-heavy. I have a lot of scripts, that create forces, manage joints and so on.
For some reason, sometimes a randomly a certain Object is destroyed. It just disappears and is gone. I can't figure out which script causes that. Is there a way to find out which script called Ondestroy or something.
Thanks for you help.
Put a brakpoint in the OnDestroy() method of your monobehaviour and check the call stack.
To debug your project you can check Debugging C# code in Unity. Once you figure that out and check how to attack unity and stop execution at the set breakpoints you can do with Window->Debug->Callstack to see the call stack with the execution stopped at your breakpoint and see what is being called that leads to your object destruction.
Simply have a component like e.g.
public class DestroyDebug : MonoBehaviour
{
void OnDestroy ()
{
Debug.Log($"{name} was just destroyed");
}
}
Either put a breakpoint there while Debugging your code if you need the exact instances and circumstances or also in the console you already can at least see the entire stacktrace of which classes and calls exactly led to destroy of this object.
If this is still an issue for you (or if anyone else has this issue), I had the same issue and found the solution here, which is to check gameObject.activeInHierarchy in OnDisable like so:
void OnDisable()
{
// If object will destroy in the end of current frame...
if (gameObject.activeInHierarchy)
{
Debug.LogError("Log an error with a stack trace in debug mode");
}
// If object just deactivated..
else
{
}
}
Related
I am following a specific Unity tutorial and are told to put a specific line of code in one of my "scene initialization routines". Can anyone elaborate on what this means specifically? Where should I put this line.
maybe he means before scene load?
if yes, try use RuntimeInitializeOnLoadMethod like this example
public class Main : MonoBehaviour
{
// Runs before a scene gets loaded
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
public static void LoadMain()
{
// type your script here
}
}
I'm currently working on a basic AI for enemies in my space shooter project.
In my EnemyAI script, I've a public Transform target that I set when I instantiate a enemy. In the Update loop, I'm looking at the target, then moving using transform.towards and everything works fine. The problem is, the target can die, so I need to check if it is not null before doing all that. Problem is : apparently doing a simple if(target == null) is really bad performance wise, and I need to do it in Update. What should be the best approach to achieve that without having performance problems (let say I want 500 enemies at once). Should I still do it every X frame, cache the position of the target till the next check and move toward that cached result ? That could work but it would introduce jitter if the time between two check if too long.
I couldn't find any "easy" way but I hope there is one, it looks like something really simple and it's causing a lot of troubles :/
Null checks are not that expensive.
Coroutines can help spread the load over multiple frames. But carefully read about their memory usage / garbage collection problems.
You could speed that up using the ECS system (Entity Component System) in combination with C# Jobs (multithreaded)
Use the Profiler (Window -> Profiler) or (Window -> Analysis -> Profiler in 2018.3) to analyse what's actually taking long.
A for-each is bad (garbage-collection wise) compared to a normal for.
If you set position and rotation, group the two calls by using SetPositionAndRotation
Note null check with UnityEngine.Object children are NOT the standard C# null checks. This description that Jetbrains provides in relation to the Rider IDE and analysis tool gets into the details. The basic idea is that the C# script hands off the null check to the underlying C++ engine structure.
I have not had the need for it but I have seen other's code that keeps a simple list of UnityEngine.Object references. They add a reference to the object to the list when it is created. Then remove it from the list on destruction. Update() can then use a faster test in the list. Where speed is critical, you just test the list not the object. Of course, an approach other than a list could be used.
I looked it up and tested it and yes you can do this with a callback function which will be registered to your target's OnDestroy method. Your Player script should access target script and delegate the method like this:
public GameObject target;
private TargetScript myTargetScript;
void Start () {
myTargetScript = target.GetComponent<TargetScript>();
myTargetScript.OnDestroyEvnt += OnDestroyListener;
}
private void OnDestroyListener(MonoBehaviour instance)
{
Debug.Log("Callback is called");
}
Also Target script should be like this:
public event OnDestroyDelegate OnDestroyEvnt;
public delegate void OnDestroyDelegate(MonoBehaviour instance);
void Start () {
StartCoroutine(DestroyCoroutine());
}
private void OnDestroy()
{
if (this.OnDestroyEvnt != null)
{
this.OnDestroyEvnt(this);
}
}
IEnumerator DestroyCoroutine()
{
yield return new WaitForSeconds(5);
Destroy(gameObject);
}
I used a coroutine to destroy the object after 5 secs. It is actually irrelevant in your case. I adopted this code from here.
You can avoid it logic-wise, make a coroutine that only runs when you assign the target, and if the target is null, end the coroutine, that coroutine should have a...
yield return new WaitForEndOfFrame();
that way it will act as a kind of LateUpdate.
And check every frame...
while (target != null)
You would be still checking every frame the null, but you will only check the target = null once.
I have a script component on a GameObject (simplified here) which is disabled upon creation, using testObject.setActive(false).
using UnityEngine;
public TestObject : MonoBehaviour {
public int testValue = 5;
void Start() {
testValue = 0;
}
public int GetTestValue() {
return testValue;
}
}
Before disabling, the return of GetTestValue is 0. Once I re-enable the object, the return is 5.
The Unity docs say:
Making a GameObject inactive will disable every component ... Any scripts that you have attached to the GameObject will no longer have Update() called ...
However the behaviour of the Component suggests to me that the MonoBehaviour made by the script is not really 'disabled', but rather is destroyed. If it were only Update() that stopped being called, how does that explain the loss of state?
The underlying question here is: what is the intended way to temporarily disable a script without destroying it?
Well what actually happens is that the Start() function is only called once in the lifetime of an object. So at the beginning its called and sets the value to 0. But when you disable it and reactivate it, it isn't called.
This doesn't change the fact that even after deactivating and reactivating the script your value should still be the same (as we figured out in the comments section).
One way you could make this work is by using OnEnable() which will be called each time the Script is setActive. More info on OnEnable:
This function is called when the object becomes enabled and active.
So in your script you would have :
private void OnEnable()
{
testValue = 0;
}
If you know this object will be Activated and deactivated many times and that you absolutely need to do something each time this happens.
Which brings me to my second point and my advice:
Dont keep important values on scripts that will get deactivated and reactivated.
Keep important information on a script that will never be deactivated so in that way you're always sure the value is always the correct one. So that way you don't always need to regenerate that correct value and check each time if it's actually the good value you got.
The problem, it turns out, was a race condition. TestObject was being deactivated before Start() could complete, and this prevented the object from being initialized properly. By moving the initialization code to Awake(), the object correctly set its state before deactivating.
I have the opposite situation..I tried to set an animator parameter in Awake() and deactivate immediately. the parameter value did not changed. But if i put it in Start(), the value is set.
I would like to populate the UI when I load a scene, with the correct data, instead of placeholders.
When I call "LoadSceneAsync", what would be the first object that is called, so I can fill the UI label with the correct data? I know that there is a scene GameObject, but I am not sure if that would fit my needs.
I am looking for some sort of constructor, called when a new scene object is loaded; to plug in my setup function.
You say
Indeed I did use "onlevelwasloaded" but the UI element may not be there, ready to go, when I invoke it, which lead to errors
That would be an incredibly sever bug in Unity! :)
Could it be that you are mixing-up Awake and Start somewhere?
One way to think of it is once you call Start, you know all the Awake have already run.
When I call "LoadSceneAsync", what would be the first object that is called, so I can fill the UI label with the correct data
You are still within the same frame.
Once you see LoadSceneAsync you can be absolutely assured everything is Awake 'd.
Or indeed once you use Start you can be absolutely assured everything is Awake 'd.
1) could it be that in some of your UI elements (or whatever) you are doing something in Start which you should do in Awake?
2) if (for some reason) you want to "wait until the next frame", perhaps just during development - then do that, wait a frame. You'll see a flicker, but if that's what you want to do (for some reason) do that.
3) note that if you mean you want to go to the net to get something, well of course you have to wait frames (use Update/coroutine) until the information comes back from the net, obviously. (How else could it be?)
Note that in practice, one should be using UnityEngine.Events.UnityEvent everywhere.
Maybe this is what you are looking for http://docs.unity3d.com/ScriptReference/MonoBehaviour.OnLevelWasLoaded.html
Relying on Unity internal functioning is not always the way to go. Particularly when dealing with RESTApi (which is somehow what you are dealing with here).
You cannot assume one object will be ready before another except if you control it.
Add a Controller script that uses Awake. In the Awake, call all the methods you are needing and use some callback to generate secondary code when primary is ready.
public class MyController: MonoBehaviour{
private ServerRequestController serverCtrl = null;
private UIController uiCtrl = null;
private void Awake(){
serverCtrl = this.gameObject.AddComponent<ServerRequestController>();
uiCtrl =this.gameObject.AddComponent<UIController>();
serverCtrl.GetData(uiCtrl.SetUI);
}
}
public class UIController:MonoBehaviour{
public void SetUI(Data data)
{
SetTopImage(data.topImage);
SetBottomImage(data.bottomImage);
// And so on
}
}
public class ServerRequestController:MonoBehaviour{
public void GetData(Action onCompletion){
// This may be a coroutine if you fetch from server
Data data = GetDataFromSomewhere();
// At this point, your data is ready
onCompletion(data);
}
}
Thanks to this, you are now able to know exactly when a piece of code is ready.
I see that we can initialize Variable in Awake() or Start() and Awake() will be called before Start().
When should we initialize in Awake and Start to have the best performance?
Usually Awake() is used to initialize if certain values or script are dependent on each other and would cause errors if one of them is initialized too late (awake runs before the game starts).
Awake is also called only once for every script instance.
Let me quote the Documentation:
[...] Awake is called after all objects are initialized so you can safely speak to other objects or query them using eg. GameObject.FindWithTag. Each GameObject's Awake is called in a random order between objects. Because of this, you should use Awake to set up references between scripts, and use Start() to pass any information back and forth. Awake is always called before any Start functions. This allows you to order initialization of scripts. Awake can not act as a coroutine.
and about Start():
Start is called on the frame when a script is enabled just before any
of the Update methods is called the first time.
Like the Awake function, Start is called exactly once in the lifetime
of the script. However, Awake is called when the script object is
initialised, regardless of whether or not the script is enabled. Start
may not be called on the same frame as Awake if the script is not
enabled at initialisation time.
Where the last part makes one big difference
To get to your question:
If the script is NOT enabled at the beginning of your game, and you don't need the variables to be initialized, start would be saving performance as awake() would be called regardless...
every variable would be initialized at the very beginning. At least that's the logical assumption I make.
This topic is well described in the official docmentation (Awake and Start).
This section describes why you might need two functions:
The Awake function is called on all objects in the scene before any
object's Start function is called. This fact is useful in cases where
object A's initialisation code needs to rely on object B's already
being initialised; B's initialisation should be done in Awake while
A's should be done in Start.
The difference between Awake and Start is that Start is called only when a script is enabled.
These two functions are called before the first Update method and there is no performance difference between them. I would say that Awake is used to initialize all objects (like a constructor), and Start is used to link the objects or do something before a game starts.
Awake is the equivalent of the ctor. It is called when a MonoBehaviour is created, before any other method if the object is active.
Start is run the first time the MonoBehaviour is activated. This can be right after Awake or long after. This allows to perform actions that are related to the current state of the app or objects.
For instance, you create an enemy, in Awake, you place everything that is basic initialisation. Then, the enemy is deactivated at the end of Awake. Later on, the enemy is about to be activated but you want to make it red if player is having some specific weapon, then you do it in Start.
IMPORTANT: If a prefab is created and the game object is off by default in the prefab, the Awake is not called until set on. In the case of a pool creation where prefab may be off, the awake is happening first time the pooled object is activated.
OnEnable is similar to Start but happens on every SetActive(true) and on start if enabled. This can be a candidate for your enemy willing to change color over the level based on the player magna for instance.
There's not much difference in the performance. But I can tell you a difference between them.
Take a simple example. Say if you want to print "HELLO" in console even if you have not activated the script in inspector, using Awake() function, you can print it in the console. But if you had written the same thing in Start() function and the script wasn't activated, you don't get any output in the console. That's the difference.
Codes in Start() function get executed only if the script is activated while, codes in Awake() function get executed even if the script is not activated. Try it !
I'd claim there is no real performance difference at all.
What Minzkraut stated
If the script is NOT enabled at the beginning of your game, and you don't need the variables to be initialized, start would be saving performance as awake() would be called regardless...
every variable would be initialized at the very beginning. At least that's the logical assumption I make.
is only semi true. If you do everything only in Start the UX might be even worse since instead of one bigger lag when starting the app - which in my eyes is totally acceptable - it might lead to smaller but more lags during game play which I personally would avoid as much as possible.
In general it was already often explained in the other answers how and when Awake and Start are called and that basically it is "just" a timing difference.
For details refer to Execution Order of Events
Leaving disabled components and inactive GameObjects aside my personal thumb rule is
Use Awake for everything where you don't rely on any other component and references.
E.g. set default field values, populate things using GetComponent etc
Use Start for everything where you do rely on other components such as accessing the results of GetComponent
This way these other components supposedly did already receive their Awake call so they themselves are already linked up and ready to be used by others.
This solves timing and dependency issues in the most cases.
Where this is not enough you would start to tweak the Script execution order or use events.
And then there is another quite important difference in the use case of using Instantiate or AddComponent
Awake (and OnEnable except using Instantiate and the component is disabled) will be called right away during the instantiation and any code line after Instantiate will be executed after it is finished.
Start however will be delayed until the end of that frame (or until enabling if the component was disabled in Awake).
This allows you to have enough time to use Instantiate and modify some field values before Start is called and can now base its behavior on the modified field values.
For example this
public class Example : MonoBehaviour
{
private class X : MonoBehaviour
{
public int x = -1;
private void Awake()
{
Debug.Log($"Awake {x}");
x = 12;
}
private void OnEnable()
{
Debug.Log($"OnEnable {x}");
}
private void Start()
{
Debug.Log($"Start {x}");
}
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
Debug.Log("Instantiate");
var x = gameObject.AddComponent<X>();
Debug.Log("After instantiate");
x.x = 42;
}
}
}
will produce the output
Instantiate
Awake -1
OnEnable 12
After Instantiate
Start 42