We Keep Coding

Unity scripting Ambient light turns off but I can't turn it back on with the same button

I've tried a few ways of doing it. I've asked a few friends but, nothing seems to work so far. I have changed the script several times so I don't have the other ways that I have tried anymore. However, this is the one that gave me the least errors. Others I had to continuously change it to a recommended way by Unity but ended at a dead end and nothing worked.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class LightActivator : MonoBehaviour
{
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
gameObject.SetActive(false);
}
else if (Input.GetKeyDown(KeyCode.Space))
{
gameObject.SetActive(true);
}
}
}
I want to be able to turn on and off the ambient/directional light with just 1 button. Is that not possible?

two little flaws here
after you do
gameObject.SetActive(false);
this very same object is now inactive -> this component as well -> Update is no longer being called at all ;)
You always will ever only treat the first case .. the second one is never called at all since the condition will always match already with the first block!
Instead separate the logic from the target object and do e.g.
// This class should go to a different object that is always active in your scene
public class LightActivator : MonoBehaviour
{
// Here you reference the object you want to (de)activate via drag&drop in the Inspector
public GameObject theLight;
void Update()
{
// You only need one condition check
if (Input.GetKeyDown(KeyCode.Space))
{
// INVERT the active state of the light object whatever it currently is
theLight.SetActive(!theLight.activeSelf);
}
}
}
In order to keep things together you could e.g. simply make the according light object a child of the LightActivator object ;)

I'm studying the C# constructor and destructor with Unity, but I don't know why it works like this

I'm studying C#'s Constructer and destructor with unity component system.
I'm sorry if the English of this question is weird. I used a translator cause I am not good at English.
The log output came out like this.
The Constructor log was displayed without pressing the play button. Why?
When I pressed the play button, I saw a log of something being created and immediately disappearing. I didn't write a code to create an object after the game started, where does this phrase run?
This is my code.
project working structure
Pressing the space bar brings the pre-made pre-fab to the game world,
and Prefab has a component that attached to test the constructor and
destructor.
CubeFactory.cs / when Press the space bar, It creates Prefab.
this component was attached to "GameObject" Gameobject
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CubeFactory : MonoBehaviour
{
public GameObject obj;
private int pos = 1;
void Start()
{
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
Instantiate(obj,new Vector3(pos,0,0),Quaternion.identity);
pos++;
}
}
}
ClassTest.cs / Component for Testing Constructor and Destructor. It attached Cube prefab.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ClassTest : MonoBehaviour
{
public ClassTest(){
Debug.Log("I was born!");
}
~ClassTest(){
Debug.Log("I Died x0x");
}
}
This is my project file. (I'm sorry to compress it up. I haven't learned how to use Git yet.)<
https://github.com/Scincy/UnityStudy

Please change your ClassTest.cs script to use simpler functions. Never use constructors and finalizers in Unity. What I understood from your logic is that when you press Spacebar, an object is instantiated. The ClassTest.cs is attached to this object. Better use:
void Start()
{
Debug.Log("I was born!"); //Will be called when the gameObject is active for the first time
}
Now you also want to know if the gameObject is destroyed, you can do this with another script attached to an always-active gameObject such as:
public GameObject cube;
void Update()
{
cube= GameObject.Find("Cube(Clone)"); //Depending on how your object is called
if(cube == null)
{
Debug.Log("Either not created or is destroyed");
}
}
I have used Update() which is called every frame. You could use a different function that you would like to call from another script only once.

Ye olde wisdom says that you should only use C# finalizers if your class contains a handle (IntPtr) to an object in unmanaged memory. If you're unclear what that means, then you probably don't need to be using finalizers; either way, you should never need to use them in a UnityEngine.Object-derived class.
Instead, prefer either of these Unity messages:
void OnDestroy()
{
// (1) called when the Object is about to be fully destroyed.
}
void OnDisable()
{
// (1) called when the Object is disabled in the Scene hierarchy.
// OR
// (2) called right before OnDestroy() would be called.
}
These Unity messages are of course available on MonoBehaviours, but also on all ScriptableObjects too! (For the latter, OnDisable essentially resolves to the same thing as OnDestroy since they are not Scene-bound Objects.)
Similarly, you should also avoid using C# constructors on MonoBehaviours and ScriptableObjects. The messages to prefer instead are:
void Awake()
void Start()
void OnEnable()
Each has its own quirks, so you may want to familiarize yourself with the differences and write some tests.
You can refer to the relevant documentation here: (see section header "Messages")
MonoBehaviour docs
ScriptableObject docs

Loading scene in Unity makes the references in that scene null

I am making my first game in Unity and I'm trying to load the first level of it when the cutscene at the start ends. I don't know if it's possible to make the script do something after a video clip ends, so I wrote my code like this:
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
public class CutsceneEnd : MonoBehaviour
{
// Start is called before the first frame update
void Start()
{
StartCoroutine("wait");
}
IEnumerator wait()
{
yield return new WaitForSeconds(36);
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex + 1);
}
}
But the problem is not with my method of waiting for the end of the video, it's with the scene it loads. I can't move my character because all the references in the scripts are null. I have no idea what I did wrong.

Unity references should be stored in the scene file. Are you using any source control like git? If someone else did not push the changes to the .unityscene file or the .meta files for the associated scripts/prefabs, it might break the references.

I think we need some more information here.
If you referring to references (public variables) to Assets/GameObjects in the loaded scene, then you may have simply never placed the references in the first place. Unity's public variables should be saved within the Scene file and should always load with the Scene.
Double check to see if the references are actually null. Are you using an animation when you load into the Scene? This can keep you from being able to manual move anything. For example, if you animate the character when loading the scene, it could get stuck in the animation clip and you won't be able to move it.
Lastly, if you are referring to references created within the code to other scripts, objects, or variables, then these may break between scenes if you don't utilize 'DontDestroyOnLoad'.
Just spit-balling here, I need more information to correctly find the solution.

Call a function in Unity Editor

I need a script, which takes a big amount of monobehaviors in children and arranges them to lists in parent script in a specific way to save parent as prefab. It would take a eternity doing in by hand. And i dont wanna do this in Start() on runtime, because these prefabs could be instanciated a bunch times per frame and causing mini lag spikes when searching for scripts in children. So how do i do this once in a editor to save all references to prefab? Never done something like that, but seen buttons in custom inspector that call functions for plugins. I tried [ExecuteInEditMode] which gives good result but it also continue to execute in runtime So asking what way would be simplest to just call a function in editor and make it not work in runtime?

Try something like this:
[ExecuteInEditMode]
public class YourClass : MonoBehaviour
{
void Update()
{
if (!Application.isPlaying)
{
Debug.Log("This should only run in edit mode.");
// More code
}
}
}
Depending on what you're trying to do exactly, there might be a better way to trigger this than ExecuteInEditMode, but this is the simplest way of getting the effect you requested. This won't run as long as Application.isPlaying returns true. So it will never run in playmode and never run in any builds.

Unity game manager. Script works only one time

I'm making simple game manager. I have a script, which will be accessible from all scenes in the game. And I need to check values of its variables after loading new scene. But my code runs only once after starting the simulation while an object with this script exists in all scenes. What is wrong? Why doesn't it work after loading a new scene?

In every Unity project you must have A PRELOAD SCENE.
It is quite confusing that Unity does not have a preload scene "built-in".
They will add this concept in the future.
Fort now you have to click to add a preload scene yourself.
This is the SINGLE GREATEST MISUNDERSTANDING for new programmers trying Unity!
Fortunately, it is extremely easy to have a preload scene.
Step 1.
Make a scene named "preload". It must be scene 0 in Build Manager.
Step 2.
In the "preload" scene make an empty GameObject called, say, "__app".
Simply, put DontDestroyOnLoad on '__app'.
Note:
This is the only place in the whole project you use DontDestroyOnLoad.
It's that simple.
In the example: the developers have made a one-line DDOL script.
Put that script on the "__app" object.
You never have to think about DDOL again.
Step 3
Your app will have (many) "general behaviors". So, things like database connectivity, sound effects, scoring, and so on.
You must, and can only, put your general behaviors on "_app".
It's really that simple.
The general behaviors are then - of course - available everywhere in the project, at all times, and in all scenes.
How else could you do it?
In the image example above, notice "Iap" ("in-app purchase") and the others.
All of your "generally-needed behaviors" - sound effects, scoring, and so on - are right there on that object.
Important...
This means that - of course, naturally -
...your general behaviors will have ordinary Inspectors, just like everything else in Unity.
You can use all the usual features of Unity, which you use on every other game object. Inspector variables, drag to connect, settings, and so on.
(Indeed: say you've been hired to work on an existing project. The first thing you will do, is glance at the preload scene. You will see all the "general behaviors" in the preload scene - sound effects, scoring, AI, etc etc. You will instantly see all the settings for those things as Inspector variables ... speech volume, playstore ID, etc etc.)
Here's an example "Sound effects" general behavior:
Looks like there's also a "voice over" general behavior, and a "music" general behavior".
To repeat. Regarding your "general behaviors". (Sound effects, scoring, social, etc etc.) These CAN ONLY GO on a game object in the preload scene.
This is not optional: there's no alternative!
It's that easy.
Sometimes engineers coming from other environments get caught up on this, because it seems like "it can't be that easy".
To repeat, Unity just plain forgot to "build-in" a preload scene. So, you simply click to add your preload scene. Don't forget to add the DDOL.
So, during development:
Always start your game from Preload scene.
It's that simple.
Important: Your app will certainly have "early" scenes. Examples:
"splash screen"
"menu"
Note. Tou CAN NOT use splash or menu as the preload scene. You have to literally have a separate preload scene.
The preload scene will then load your splash or menu or other early scene.
The central issue: "finding" those from other scripts:
So you have a preload scene.
All of your "general behaviors" are simply on the preload scene.
You next have the problem of, quite simply, finding say "SoundEffects".
You have to be able to find them easily, from, any script, on any game object, in any of your scenes.
Fortunately it is dead easy, it is one line of code.
Sound sound = Object.FindObjectOfType<Sound>();
Game game = Object.FindObjectOfType<Game>();
Do that in Awake, for any script that needs it.
It's honestly that simple. That's all there is to it.
Sound sound = Object.FindObjectOfType<Sound>();
Tremendous confusion arises because of the 100s of absolutely wrong code examples seen online.
It really is that easy - honest!
It's bizarre that Unity forgot to add a built-in "preload scene" - somewhere to attach your systems like SoundEffects, GameManager, etc. It's just one of those weird thing about Unity. So, the first thing you do in any Unity project is just click once to make a preload scene.
That's it!
A Detail...
Note that, if you really want to type even less (!) lines of code, it's remarkably easy - you can just use a global for each of these things!
This is explained in detail here , many folks now use something like this, a Grid.cs script ...
using Assets.scripts.network;
using UnityEngine;
static class Grid
{
public static Comms comms;
public static State state;
public static Launch launch;
public static INetworkCommunicator iNetworkCommunicator;
public static Sfx sfx;
static Grid()
{
GameObject g = GameObject.Find("_app");
comms = g.GetComponent<Comms>();
state = g.GetComponent<State>();
launch = g.GetComponent<Launch>();
iNetworkCommunicator = g.GetComponent<INetworkCommunicator>();
sfx = g.GetComponent<Sfx>();
}
}
Then, anywhere in the project you can say
Grid.sfx.Explosions();
It's just that easy, that's the whole thing.
Don't forget that each of those "general systems" is on, and can only be on, the DDOL game object in the preload scene.
DylanB asks: "During development it's quite annoying that you have to click to the preload scene every time before you click "Play". Can this be automated?"
Sure, every team has a different way to do this. Here's a trivial example:
// this should run absolutely first; use script-execution-order to do so.
// (of course, normally never use the script-execution-order feature,
// this is an unusual case, just for development.)
...
public class DevPreload:MonoBehaviour
{
void Awake()
{
GameObject check = GameObject.Find("__app");
if (check==null)
{ UnityEngine.SceneManagement.SceneManager.LoadScene("_preload"); }
}
}
But don't forget: what else can you do? Games have to start from a preload scene. What else can you do, other than click to go to the preload scene, to start the game? One may as well ask "it's annoying launching Unity to run Unity - how to avoid launching Unity?!" Games simply, of course, absolutely have to start from a preload scene - how else could it be? So sure, you have to "click to the preload scene before you click Play" when working in Unity - how else could it be?

#Fattie: Thanks for elaborating all this, it's great! There is a point though that people are trying to get through to you, and I'll just give it a go as well:
We do not want every instantiation of everything in our mobile games to do a "FindObjectOfType" for each and every every "global class"!
Instead you can just have it use an Instantiation of a static / a Singleton right away, without looking for it!
And it's as simple as this:
Write this in what class you want to access from anywhere, where XXXXX is the name of the class, for example "Sound"
public static XXXXX Instance { get; private set; }
void Awake()
{
if (Instance == null) { Instance = this; } else { Debug.Log("Warning: multiple " + this + " in scene!"); }
}
Now instead of your example
Sound sound = Object.FindObjectOfType<Sound>();
Just simply use it, without looking, and no extra variables, simply like this, right off from anywhere:
Sound.Instance.someWickedFunction();
Alternately (technically identical), just use one global class, usually called Grid, to "hold" each of those. Howto. So,
Grid.sound.someWickedFunction();
Grid.networking.blah();
Grid.ai.blah();

Here is how you can start whatever scene you like and be sure to reintegrate your _preload scene every time you hit play button in unity editor. There is new attribute available since Unity 2017 RuntimeInitializeOnLoadMethod, more about it here.
Basically you have a simple plane c# class and a static method with RuntimeInitializeOnLoadMethod on it. Now every time you start the game, this method will load the preload scene for you.
using UnityEngine;
using UnityEngine.SceneManagement;
public class LoadingSceneIntegration {
#if UNITY_EDITOR
public static int otherScene = -2;
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
static void InitLoadingScene()
{
Debug.Log("InitLoadingScene()");
int sceneIndex = SceneManager.GetActiveScene().buildIndex;
if (sceneIndex == 0) return;
Debug.Log("Loading _preload scene");
otherScene = sceneIndex;
//make sure your _preload scene is the first in scene build list
SceneManager.LoadScene(0);
}
#endif
}
Then in your _preload scene you have another script who will load back desired scene (from where you have started):
...
#if UNITY_EDITOR
private void Awake()
{
if (LoadingSceneIntegration.otherScene > 0)
{
Debug.Log("Returning again to the scene: " + LoadingSceneIntegration.otherScene);
SceneManager.LoadScene(LoadingSceneIntegration.otherScene);
}
}
#endif
...

An alternate solution from May 2019 without _preload:
https://low-scope.com/unity-tips-1-dont-use-your-first-scene-for-global-script-initialization/
I've paraphrased from the above blog to a how-to for it below:
Loading a Static Resource Prefab for all Scenes
In Project > Assets create a folder called Resources.
Create a Main Prefab from an empty GameObject and place in the Resources folder.
Create a Main.cs C# script in your Assets > Scripts or wherever.
using UnityEngine;
public class Main : MonoBehaviour
{
// Runs before a scene gets loaded
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
public static void LoadMain()
{
GameObject main = GameObject.Instantiate(Resources.Load("Main")) as GameObject;
GameObject.DontDestroyOnLoad(main);
}
// You can choose to add any "Service" component to the Main prefab.
// Examples are: Input, Saving, Sound, Config, Asset Bundles, Advertisements
}
Add Main.cs to the Main Prefab in your Resources folder.
Note how it uses RuntimeInitializeOnLoadMethod along with Resources.Load("Main") and DontDestroyOnLoad.
Attach any other scripts that need to be global across scenes to this prefab.
Note that if you link to other scene game objects to those scripts you probably want to use something like this in the Start function for those scripts:
if(score == null)
score = FindObjectOfType<Score>();
if(playerDamage == null)
playerDamage = GameObject.Find("Player").GetComponent<HitDamage>();
Or better yet, use an Asset management system like Addressable Assets or the Asset Bundles.

actually as a programmer who comes to unity world I see none of these approaches
standard
the most simplest and standard way: create a prefab, according to unity docs:
Unity’s Prefab system allows you to create, configure, and store a GameObject complete with all its components, property values, and child GameObjects
as a reusable Asset. The Prefab Asset acts as a template from which you can create new Prefab instances in the Scene.
Details:
Create a prefab within your Resources folder:
if you don't know how to create a prefab study this unity document
if you don't have resources directory create a folder and name it exactly Resources because it is a unity Special folder name
create a script with contents like below:
using UnityEngine;
public class Globals : MonoBehaviour // change Globals (it should be the same name of your script)
{
// loads before any other scene:
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
public static void LoadMain()
{
Debug.Log("i am before everything else");
}
}
assign it to your prefab
and you can make it even better:
use prefab and namespaces together:
in your prefab script:
using UnityEngine;
namespace Globals {
public class UserSettings
{
static string language = "per";
public static string GetLanguage()
{
return language;
}
public static void SetLanguage (string inputLang)
{
language = inputLang;
}
}
}
in your other scripts:
using Globals;
public class ManageInGameScene : MonoBehaviour
{
void Start()
{
string language = UserSettings.GetLanguage();
}
void Update()
{
}
}