Creati un script C# care la rulare sa:

• stearga un obiect trimis ca referinta in script
• dezactiveze componenta de MeshRenderer dintr-o lista de obiecte cu un anumit tag

Gasiti pe MS Teams

In Unity scripting, there are a number of event functions that get executed in a predetermined order as a script executes. This execution order is described below:

1. Awake(): This function is always called before any Start functions and also just after a prefabis instantiated.
2. OnEnable(): This function is called just after the object is enabled. This happens when a MonoBehaviour instance is created, such as when a level is loaded or a GameObjectwith the script componentis instantiated.
3. Start(): Start is called before the first frame update only if the script instance is enabled.
4. FixedUpdate(): FixedUpdate is often called more frequently than Update. It can be called multiple times per frame
5. Update(): Update is called once per frame. It is the main workhorse function for frame updates.
6. LateUpdate(): LateUpdate is called once per frame, after Update has finished. Any calculations that are performed in Update will have completed when LateUpdate begins.
7. OnGUI(): Called multiple times per frame in response to GUI events.
8. OnApplicationQuit(): This function is called on all game objects before the application is quit. In the editor it is called when the user stops playmode.
9. OnDisable(): This function is called when the behaviour becomes disabled or inactive.
10. OnDestroy(): This function is called after all frame updates for the last frame of the object's existence (the object might be destroyed in response to Object.Destroy or at the closure of a scene).

Difference between Start and Awake Unity Events

Awake as ” initialize me” and Start as ” initialize my connections to others.” You can't rely on the state of other objects during Awake, since they may not have Awoken themselves yet, so it's not safe to call their methods.

Start function is called only if the script component is enabled. Awake function called when the script instance is being loaded.

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.

Difference between Update, Fixed Update and Late Update.

Update: (Most things)

• Update is called once per frame from every script in which it is defined. Calling of Update function is dependent on the frame rate.
• The time interval to call update is not fixed; it depends on how much time required to complete the individual frame.

FixedUpdate:(Physics things)

• FixedUpdate is independent of the frame rate. The time interval is to call FixedUpdate is constant; as it is called on a reliable timer.
• FixedUpdate can be called multiple times per frame if frame rate is low or it may not be called per frame if the frame rate will be high.
• All the physics related calculations and updates are called immediately after FixedUpdate. So, its good to handle all physics related calculation inside FixedUpdate.

LateUpdate:(After update)

• LateUpdate is also called per frame. It is called after all other Update functions.
• This is useful to ensure all other Update related calculation is complete and other dependent calculation can be called.
• For example, if you need to integrate a third-person camera to follow any object; then it should be implemented inside the LateUpdate. It is make sure that camera will track the object after its movement and rotation update.

Script compilation order inside Unity

There are four separate phases of script compilation. The phase where a script is compiled is determined by its parent folder. In a script compilation, the basic rule is that anything that is compiled in a phase _after_ the current one cannot be referenced. Anything that is compiled in the current phase or an earlier phase is fully available.

The phases of compilation are as follows:

• Phase 1: Runtime scripts in folders called Standard Assets, Pro Standard Assets and Plugins
• Phase 2: Editor scripts in folders called Editor that are anywhere inside top-level folders called Standard Assets, Pro Standard Assets and Plugins.
• Phase 3: All other scripts that are not inside a folder called Editor.
• Phase 4: All remaining scripts (those that are inside a folder called Editor).

A common example of the significance of this order occurs when a UnityScript file needs to reference a class defined in a C# file. To achieve this, you need to place the C# file inside a Plugins folder, and the UnityScript file in a non-special folder. Because C# code is compiled before JS code, so in general, while JS code can access C# classes, the opposite is not possible If you don't do this, an error is thrown saying that the C# class cannot be found.

Static Classes and Singleton

Both can be invoked without instantiation, both provide only one “Instance” and neither of them is thread-safe.

A [static](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/static) class is basically the same as a non-static class, but there is one difference: a static class contains only static members and a private constructor and cannot be instantiated. In other words, you cannot use the [new](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/new) keyword to create a variable of the class type. The design style embodied in a static class is purely procedural.

Singleton, on the other hand, is a pattern specific to OO design. It is an instance of an object (with all the possibilities inherent in that, such as polymorphism), with a creation procedure that ensures that there is only ever one instance of that particular role over its entire lifetime.

The Virtual keyword

The 'virtual' keyword is used to modify a method, property, indexer, or event declaration and allow for it to be overridden in a derived class. By default, methods are non-virtual and you cannot override a non-virtual method. You cannot use the `virtual` modifier with the `static`, `abstract`, `private`, or `override`modifiers.

For example, this method can be overridden by any class that inherits it:

public virtual double Area()
{
    return x * y;
}

Abstract Classes and interfaces

An abstract class is a special kind of class that cannot be instantiated. An abstract class is only to be sub-classed (inherited from). In other words, it only allows other classes to inherit from it but cannot be instantiated.

When we create an interface, we are basically creating a set of methods without any implementation that must be overridden by the implemented classes. The advantage is that it provides a way for a class to be a part of two classes: one from inheritance hierarchy and one from the interface.

When we create an abstract class, we are creating a base class that might have one or more completed methods but at least one or more methods are left uncompleted and declared `abstract`. If all the methods of an abstract class are uncompleted then it is same as an interface. The purpose of an abstract class is to provide a base class definition for how a set of derived classes will work and then allow the programmers to fill the implementation in the derived classes.

There are some similarities and differences between an interface and an abstract class that I have arranged in a table for easier comparison:

Methods and functions

A function is a piece of code that is called by name. It can be passed data to operate on (i.e. the parameters) and can optionally return data (the return value). All data that is passed to a function is explicitly passed.

A method is a piece of code that is called by a name that is associated with an object. In most respects it is identical to a function except for two key differences:

1. A method is implicitly passed the object on which it was called.
2. A method is able to operate on data that is contained within the class (remembering that an object is an instance of a class – the class is the definition, the object is an instance of that data).

Generic Functions and Generic Classes

Generic classes encapsulate operations that are not specific to a particular data type. The most common use for generic classes is with collections like linked lists, hash tables, stacks, queues, trees, and so on. Operations such as adding and removing items from the collection are performed in basically the same way regardless of the type of data being stored.

Generic functions are similarly those which describe the algorithm without specifying a particular data type.

Variables and Parameters

Variables can be controlled from the Unity Editor as parameters, as long as they are defined public or serializable. We can use both simple variable or arrays.

public float speed;
public Sprite[] images;
private float internalBleed; //cannot be controller from Unity Editor interface

[SerializeField]
private Text scoreText;
    
[SerializeField]
private GameObject[] enemyTypes;

MonoBehaviour Event Execution Order

Ordered by first to last method to execute.

private void Awake() { /* Called when the script is being loaded */ }
private void OnEnable() { /* Called every time the object is enabled */ }
private void Start() { /* Called on the frame when the script is enabled */ }
private void Update() { /* Called once per frame */ }
private void LateUpdate() { /* Called every frame after Update */ }
private void OnBecameVisible() { /* Called when the renderer is visible by any Camera */ }
private void OnBecameInvisible() { /* Called when the renderer is no longer visible by any Camera */ }
private void OnDrawGizmos() { /* Allows you to draw Gizmos in the Scene View */ }
private void OnGUI() { /* Called multiple times per frame in response to GUI events */ }
private void OnApplicationPause() { /* Called at the end of a frame when a pause is detected */ }
private void OnDisable() { /* Called every time the object is disabled */ }
private void OnDestroy() { /* Only called on previously active GameObjects that have been destroyed */ }

Physics updates on a Fixed Timestep are defined under Edit ▸ Project Settings ▸ Time ▸ Fixed Timestep and may execute more or less than once per actual frame.

private void FixedUpdate() { /* Called every Fixed Timestep */ }

Debug

Debug.Log(transform.position);
Debug.Log("text");

GameObject Manipulation

/* Destroy a GameObject */
Destroy(gameObject);
 
/* Finding GameObjects */
GameObject myObj = GameObject.Find("NAME IN HIERARCHY");
GameObject myObj = GameObject.FindWithTag("TAG");
childObject=parentObject.GetChild("child_name");
parentObject.GetChild("child_name").GetComponent<SpriteRenderer>().sprite = image; 
 
/* Accessing Components */
Example myComponent = GetComponent<Example>();
AudioSource audioSource = GetComponent<AudioSource>();
Rigidbody rgbd = GetComponent<Rigidbody>();
GetComponent<SpriteRenderer>().sprite = image; //set image in child component
GetComponent<Text>().text = '123' //set text
 
/* Activate - can hide or how an element from the scene*/
myObject.SetActive(false); // hide
myObject.SetActive(true); // show
 
GetComponent<BoxCollider>().enabled = false; // hide component