├── Patterns
    ├── ChainOfResponsibility
    │   ├── Handlers
    │   │   ├── CutsceneInputHandler.cs
    │   │   ├── DialogInputHandler.cs
    │   │   ├── GameplayInputHandler.cs
    │   │   └── UIInputHandler.cs
    │   ├── InputData.cs
    │   ├── InputHandler.cs
    │   ├── InputManager.cs
    │   ├── InputState.cs
    │   └── README.md
    ├── StatePattern
    │   ├── IOnboardingState.cs
    │   ├── OnboardingManager.cs
    │   ├── README.md
    │   ├── StateMachine.cs
    │   └── States
    │   │   ├── CombatTutorialState.cs
    │   │   ├── InventoryTutorialState.cs
    │   │   └── MovementTutorialState.cs
    └── StrategyPattern
    │   ├── Character.cs
    │   ├── IAttackStrategy.cs
    │   ├── README.md
    │   └── Strategies
    │       ├── AreaAttackStrategy.cs
    │       ├── MeleeAttackStrategy.cs
    │       └── RangedAttackStrategy.cs
├── README.md
└── docs
    ├── .gitignore
    ├── .nojekyll
    ├── CNAME
    ├── README.md
    ├── _sidebar.md
    ├── ads.txt
    ├── assets
        └── favicon
        │   ├── apple-touch-icon.png
        │   ├── favicon-16x16.png
        │   ├── favicon-32x32.png
        │   ├── safari-pinned-tab.svg
        │   └── site.webmanifest
    ├── audio
        └── basic-audio-play.md
    ├── basics
        ├── euler-angles.md
        ├── monobehaviour.md
        ├── quaternion.md
        ├── transform.md
        └── vector3.md
    ├── design-patterns
        ├── chain-of-responsibility-pattern.md
        ├── command-pattern.md
        ├── factory-pattern.md
        ├── object-pooling-pattern.md
        ├── observer-pattern.md
        ├── singleton.md
        ├── state-pattern.md
        └── strategy-pattern.md
    ├── index.html
    ├── input
        ├── keyboard.md
        ├── mouse.md
        └── touch.md
    ├── movement-rotation
        ├── move-object.md
        └── rotate-object.md
    ├── package.json
    ├── physics
        ├── ignore-collision.md
        └── raycast.md
    ├── practical-use-cases
        ├── check-if-object-is-on-the-ground.md
        ├── get-the-transform-of-a-body-bone.md
        ├── load-next-scene.md
        └── make-object-look-at-the-camera.md
    ├── scripting
        ├── asyncawait.md
        ├── coroutines.md
        ├── custom-editor-scripts.md
        ├── event-systems.md
        └── scriptable-objects.md
    ├── scripts
        └── generate-docs.ts
    ├── shortcuts
        ├── hierarchy-management.md
        ├── layout.md
        ├── scene-view-editing.md
        └── scene-view-navigation.md
    ├── tbd-to-be-documented
        ├── input.md
        └── scripting.md
    ├── tsconfig.json
    └── ui
        ├── button.md
        └── slider.md


/Patterns/ChainOfResponsibility/Handlers/CutsceneInputHandler.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class CutsceneInputHandler : InputHandler
 4 | {
 5 |     private void Awake()
 6 |     {
 7 |         handledStates = new[] { InputState.Cutscene };
 8 |     }
 9 | 
10 |     protected override void ProcessInput(InputData input)
11 |     {
12 |         if (input.IsProcessed) return;
13 | 
14 |         // Only allow skipping cutscene with interact button
15 |         if (input.InteractPressed)
16 |         {
17 |             Debug.Log("Skip Cutscene");
18 |         }
19 | 
20 |         input.IsProcessed = true;
21 |     }
22 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/Handlers/DialogInputHandler.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class DialogInputHandler : InputHandler
 4 | {
 5 |     private void Awake()
 6 |     {
 7 |         handledStates = new[] { InputState.Dialog };
 8 |     }
 9 | 
10 |     protected override void ProcessInput(InputData input)
11 |     {
12 |         if (input.IsProcessed) return;
13 | 
14 |         // Handle dialog choices
15 |         if (input.Movement != Vector2.zero)
16 |         {
17 |             Debug.Log("Dialog Choice: " + input.Movement);
18 |         }
19 | 
20 |         // Handle advancing dialog
21 |         if (input.InteractPressed)
22 |         {
23 |             Debug.Log("Advance Dialog");
24 |         }
25 | 
26 |         input.IsProcessed = true;
27 |     }
28 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/Handlers/GameplayInputHandler.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class GameplayInputHandler : InputHandler
 4 | {
 5 |     private void Awake()
 6 |     {
 7 |         handledStates = new[] { InputState.Gameplay };
 8 |     }
 9 | 
10 |     protected override void ProcessInput(InputData input)
11 |     {
12 |         if (input.IsProcessed) return;
13 | 
14 |         // Handle movement
15 |         if (input.Movement != Vector2.zero)
16 |         {
17 |             Debug.Log("Movement: " + input.Movement);
18 |         }
19 | 
20 |         // Handle jump
21 |         if (input.JumpPressed)
22 |         {
23 |             Debug.Log("Jump");
24 |         }
25 | 
26 |         // Handle interaction
27 |         if (input.InteractPressed)
28 |         {
29 |             Debug.Log("Interact");
30 |         }
31 | 
32 |         input.IsProcessed = true;
33 |     }
34 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/Handlers/UIInputHandler.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class UIInputHandler : InputHandler
 4 | {
 5 |     private void Awake()
 6 |     {
 7 |         handledStates = new[] { InputState.UI };
 8 |     }
 9 | 
10 |     protected override void ProcessInput(InputData input)
11 |     {
12 |         if (input.IsProcessed) return;
13 | 
14 |         // Handle UI navigation
15 |         if (input.Movement != Vector2.zero)
16 |         {
17 |             Debug.Log("UI Navigation: " + input.Movement);
18 |         }
19 | 
20 |         // Handle UI selection
21 |         if (input.InteractPressed)
22 |         {
23 |             Debug.Log("UI Selection");
24 |         }
25 | 
26 |         input.IsProcessed = true;
27 |     }
28 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/InputData.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class InputData
 4 | {
 5 |     public Vector2 Movement { get; private set; }
 6 |     public bool JumpPressed { get; private set; }
 7 |     public bool InteractPressed { get; private set; }
 8 |     public bool IsProcessed { get; set; }
 9 | 
10 |     public InputData(Vector2 movement, bool jumpPressed, bool interactPressed)
11 |     {
12 |         Movement = movement;
13 |         JumpPressed = jumpPressed;
14 |         InteractPressed = interactPressed;
15 |         IsProcessed = false;
16 |     }
17 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/InputHandler.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public abstract class InputHandler : MonoBehaviour
 4 | {
 5 |     protected InputHandler nextHandler;
 6 |     protected InputState[] handledStates;
 7 |     protected InputState currentState;
 8 | 
 9 |     public void SetNextHandler(InputHandler handler)
10 |     {
11 |         nextHandler = handler;
12 |     }
13 | 
14 |     public virtual bool HandleInput(InputData input)
15 |     {
16 |         if (CanHandleState(currentState))
17 |         {
18 |             ProcessInput(input);
19 |             return true;
20 |         }
21 | 
22 |         return nextHandler != null && nextHandler.HandleInput(input);
23 |     }
24 | 
25 |     protected abstract void ProcessInput(InputData input);
26 | 
27 |     protected bool CanHandleState(InputState state)
28 |     {
29 |         foreach (var handledState in handledStates)
30 |         {
31 |             if (state == handledState) return true;
32 |         }
33 |         return false;
34 |     }
35 | 
36 |     public void SetState(InputState newState)
37 |     {
38 |         currentState = newState;
39 |     }
40 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/InputManager.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | public class InputManager : MonoBehaviour
 4 | {
 5 |     private GameplayInputHandler gameplayHandler;
 6 |     private UIInputHandler uiHandler;
 7 |     private CutsceneInputHandler cutsceneHandler;
 8 |     private DialogInputHandler dialogHandler;
 9 | 
10 |     private InputState currentState = InputState.Gameplay;
11 | 
12 |     void Start()
13 |     {
14 |         // Initialize handlers
15 |         gameplayHandler = gameObject.AddComponent<GameplayInputHandler>();
16 |         uiHandler = gameObject.AddComponent<UIInputHandler>();
17 |         cutsceneHandler = gameObject.AddComponent<CutsceneInputHandler>();
18 |         dialogHandler = gameObject.AddComponent<DialogInputHandler>();
19 | 
20 |         // Set up the chain
21 |         gameplayHandler.SetNextHandler(uiHandler);
22 |         uiHandler.SetNextHandler(cutsceneHandler);
23 |         cutsceneHandler.SetNextHandler(dialogHandler);
24 | 
25 |         // Set initial state
26 |         SetGameState(InputState.Gameplay);
27 |     }
28 | 
29 |     void Update()
30 |     {
31 |         // Gather input
32 |         Vector2 movement = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
33 |         bool jumpPressed = Input.GetButtonDown("Jump");
34 |         bool interactPressed = Input.GetButtonDown("Interact");
35 | 
36 |         // Create input data
37 |         var inputData = new InputData(movement, jumpPressed, interactPressed);
38 | 
39 |         // Process input through chain
40 |         gameplayHandler.HandleInput(inputData);
41 |     }
42 | 
43 |     public void SetGameState(InputState newState)
44 |     {
45 |         currentState = newState;
46 |         
47 |         // Update all handlers with new state
48 |         gameplayHandler.SetState(newState);
49 |         uiHandler.SetState(newState);
50 |         cutsceneHandler.SetState(newState);
51 |         dialogHandler.SetState(newState);
52 |     }
53 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/InputState.cs:
--------------------------------------------------------------------------------
1 | public enum InputState
2 | {
3 |     Gameplay,
4 |     UI,
5 |     Cutscene,
6 |     Dialog
7 | } 


--------------------------------------------------------------------------------
/Patterns/ChainOfResponsibility/README.md:
--------------------------------------------------------------------------------
 1 | # Chain of Responsibility Pattern Example
 2 | 
 3 | A Unity example demonstrating the Chain of Responsibility pattern with a game input handling system.
 4 | 
 5 | ## Overview
 6 | 
 7 | The Chain of Responsibility pattern manages input handling across different game states (gameplay, UI, cutscenes, dialog). Each handler processes input based on the current game state, ensuring inputs are handled appropriately in each context.
 8 | 
 9 | ## Implementation
10 | 
11 | - [`InputState.cs`](InputState.cs): Defines the possible game states
12 | - [`InputData.cs`](InputData.cs): Contains all input information (movement, buttons)
13 | - [`InputHandler.cs`](InputHandler.cs): Base handler class with chain logic
14 | - Game States:
15 |   - [`GameplayInputHandler.cs`](Handlers/GameplayInputHandler.cs): Handles player movement and actions
16 |   - [`UIInputHandler.cs`](Handlers/UIInputHandler.cs): Handles UI navigation and selection
17 |   - [`CutsceneInputHandler.cs`](Handlers/CutsceneInputHandler.cs): Handles cutscene controls
18 |   - [`DialogInputHandler.cs`](Handlers/DialogInputHandler.cs): Handles dialog system input
19 | - [`InputManager.cs`](InputManager.cs): Sets up the chain and manages game states
20 | 
21 | ## Usage
22 | 
23 | ```csharp
24 | // Setup is automatic - just add to a GameObject
25 | InputManager manager = gameObject.AddComponent<InputManager>();
26 | 
27 | // Change states as needed
28 | manager.SetGameState(InputState.Dialog);    // When entering dialog
29 | manager.SetGameState(InputState.Gameplay);  // When returning to gameplay
30 | ```
31 | 
32 | ## Benefits
33 | 
34 | - Clean separation of input handling by game state
35 | - Easy to add new input states and handlers
36 | - Prevents input conflicts between states
37 | - Centralized input management
38 | 


--------------------------------------------------------------------------------
/Patterns/StatePattern/IOnboardingState.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StatePattern
 4 | {
 5 |     public interface IState
 6 |     {
 7 |         void Enter();
 8 |         void Update();
 9 |         void Exit();
10 |     }
11 | } 


--------------------------------------------------------------------------------
/Patterns/StatePattern/OnboardingManager.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | 
 5 | namespace UnityCheatSheet.Patterns.StatePattern
 6 | {
 7 |     public class OnboardingManager : MonoBehaviour
 8 |     {
 9 |         private StateMachine stateMachine;
10 |         private Dictionary<string, bool> directionsTriedMap = new Dictionary<string, bool>();
11 |         private bool onboardingComplete = false;
12 | 
13 |         private void Start()
14 |         {
15 |             InitializeDirectionsMap();
16 |             stateMachine = gameObject.AddComponent<StateMachine>();
17 |         }
18 | 
19 |         private void InitializeDirectionsMap()
20 |         {
21 |             directionsTriedMap["up"] = false;
22 |             directionsTriedMap["down"] = false;
23 |             directionsTriedMap["left"] = false;
24 |             directionsTriedMap["right"] = false;
25 |         }
26 | 
27 |         public void SetDirectionTried(string direction, bool tried)
28 |         {
29 |             if (directionsTriedMap.ContainsKey(direction))
30 |             {
31 |                 directionsTriedMap[direction] = tried;
32 |             }
33 |         }
34 | 
35 |         public bool HasTriedAllDirections()
36 |         {
37 |             return directionsTriedMap.All(kvp => kvp.Value);
38 |         }
39 | 
40 |         public void CompleteOnboarding()
41 |         {
42 |             onboardingComplete = true;
43 |             Debug.Log("Onboarding completed! The player is ready to start the game.");
44 |         }
45 |     }
46 | } 


--------------------------------------------------------------------------------
/Patterns/StatePattern/README.md:
--------------------------------------------------------------------------------
 1 | # State Pattern Example
 2 | 
 3 | A Unity example demonstrating the State Pattern with a game onboarding system.
 4 | 
 5 | ## Overview
 6 | 
 7 | The State Pattern allows an object to alter its behavior when its internal state changes. In this example, we use it to manage different states of a game onboarding system, where each state represents a different tutorial phase.
 8 | 
 9 | ## Implementation
10 | 
11 | - [`IState.cs`](IState.cs): Base interface for all states
12 | - [`StateMachine.cs`](StateMachine.cs): Manages state transitions
13 | - [`OnboardingManager.cs`](OnboardingManager.cs): Handles onboarding logic
14 | - States:
15 |   - [`MovementTutorialState.cs`](States/MovementTutorialState.cs): Teaches basic movement
16 |   - [`CombatTutorialState.cs`](States/CombatTutorialState.cs): Teaches combat mechanics
17 |   - [`InventoryTutorialState.cs`](States/InventoryTutorialState.cs): Teaches inventory usage
18 | 
19 | ## Usage
20 | 
21 | ```csharp
22 | // Setup is automatic - just add to a GameObject
23 | OnboardingManager manager = gameObject.AddComponent<OnboardingManager>();
24 | 
25 | // States will transition automatically as player completes each tutorial phase
26 | // You can also manually transition if needed:
27 | manager.ChangeState(new CombatTutorialState());
28 | ```
29 | 
30 | ## Benefits
31 | 
32 | - Clean separation of tutorial phases
33 | - Easy to add new tutorial states
34 | - Clear state transitions
35 | - Centralized tutorial management
36 | ``` 


--------------------------------------------------------------------------------
/Patterns/StatePattern/StateMachine.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StatePattern
 4 | {
 5 |     public class StateMachine : MonoBehaviour
 6 |     {
 7 |         private IState currentState;
 8 | 
 9 |         private void Start()
10 |         {
11 |             // Start with the first state in your sequence
12 |             ChangeState(new States.MovementTutorialState(this));
13 |         }
14 | 
15 |         private void Update()
16 |         {
17 |             if (currentState != null)
18 |             {
19 |                 currentState.Update();
20 |             }
21 |         }
22 | 
23 |         public void ChangeState(IState newState)
24 |         {
25 |             if (currentState != null)
26 |             {
27 |                 currentState.Exit();
28 |             }
29 | 
30 |             currentState = newState;
31 |             currentState.Enter();
32 |         }
33 |     }
34 | } 


--------------------------------------------------------------------------------
/Patterns/StatePattern/States/CombatTutorialState.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace UnityCheatSheet.Patterns.StatePattern.States
 5 | {
 6 |     public class CombatTutorialState : IState
 7 |     {
 8 |         private readonly OnboardingManager manager;
 9 |         private bool attackPerformed = false;
10 |         private bool blockPerformed = false;
11 | 
12 |         public CombatTutorialState(OnboardingManager manager)
13 |         {
14 |             this.manager = manager;
15 |         }
16 | 
17 |         public void Enter()
18 |         {
19 |             Debug.Log("Welcome to combat training! Press Left Mouse Button to attack, Right Mouse Button to block.");
20 |         }
21 | 
22 |         public void Update()
23 |         {
24 |             if (Input.GetMouseButtonDown(0) && !attackPerformed)
25 |             {
26 |                 attackPerformed = true;
27 |                 Debug.Log("Excellent attack!");
28 |             }
29 | 
30 |             if (Input.GetMouseButtonDown(1) && !blockPerformed)
31 |             {
32 |                 blockPerformed = true;
33 |                 Debug.Log("Perfect block!");
34 |             }
35 | 
36 |             if (attackPerformed && blockPerformed)
37 |             {
38 |                 manager.StartCoroutine(TransitionToNextState());
39 |             }
40 |         }
41 | 
42 |         public void Exit()
43 |         {
44 |             Debug.Log("Combat tutorial completed!");
45 |         }
46 | 
47 |         private IEnumerator TransitionToNextState()
48 |         {
49 |             yield return new WaitForSeconds(2f);
50 |             manager.ChangeState(new InventoryTutorialState(manager));
51 |         }
52 |     }
53 | } 


--------------------------------------------------------------------------------
/Patterns/StatePattern/States/InventoryTutorialState.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace UnityCheatSheet.Patterns.StatePattern.States
 5 | {
 6 |     public class InventoryTutorialState : IState
 7 |     {
 8 |         private readonly OnboardingManager manager;
 9 |         private bool inventoryOpened = false;
10 |         private bool itemSelected = false;
11 | 
12 |         public InventoryTutorialState(OnboardingManager manager)
13 |         {
14 |             this.manager = manager;
15 |         }
16 | 
17 |         public void Enter()
18 |         {
19 |             Debug.Log("Let's learn about inventory management! Press 'I' to open inventory.");
20 |         }
21 | 
22 |         public void Update()
23 |         {
24 |             if (Input.GetKeyDown(KeyCode.I))
25 |             {
26 |                 inventoryOpened = true;
27 |                 Debug.Log("Inventory opened! Try selecting the Health Potion.");
28 |             }
29 | 
30 |             // Simulated item selection (press Space to simulate selecting the item)
31 |             if (inventoryOpened && Input.GetKeyDown(KeyCode.Space))
32 |             {
33 |                 itemSelected = true;
34 |                 Debug.Log("Perfect! You've completed the basic tutorials!");
35 |                 manager.StartCoroutine(CompleteOnboarding());
36 |             }
37 |         }
38 | 
39 |         public void Exit()
40 |         {
41 |             Debug.Log("Inventory tutorial completed!");
42 |         }
43 | 
44 |         private IEnumerator CompleteOnboarding()
45 |         {
46 |             yield return new WaitForSeconds(3f);
47 |             manager.CompleteOnboarding();
48 |         }
49 |     }
50 | } 


--------------------------------------------------------------------------------
/Patterns/StatePattern/States/MovementTutorialState.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace UnityCheatSheet.Patterns.StatePattern.States
 5 | {
 6 |     public class MovementTutorialState : IState
 7 |     {
 8 |         private readonly OnboardingManager manager;
 9 |         private bool movementCompleted = false;
10 | 
11 |         public MovementTutorialState(OnboardingManager manager)
12 |         {
13 |             this.manager = manager;
14 |         }
15 | 
16 |         public void Enter()
17 |         {
18 |             Debug.Log("Welcome to the movement tutorial! Use WASD or arrow keys to move.");
19 |         }
20 | 
21 |         public void Update()
22 |         {
23 |             if (Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.UpArrow))
24 |             {
25 |                 manager.SetDirectionTried("up", true);
26 |                 Debug.Log("Moved up!");
27 |             }
28 |             if (Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.DownArrow))
29 |             {
30 |                 manager.SetDirectionTried("down", true);
31 |                 Debug.Log("Moved down!");
32 |             }
33 |             if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow))
34 |             {
35 |                 manager.SetDirectionTried("left", true);
36 |                 Debug.Log("Moved left!");
37 |             }
38 |             if (Input.GetKeyDown(KeyCode.D) || Input.GetKeyDown(KeyCode.RightArrow))
39 |             {
40 |                 manager.SetDirectionTried("right", true);
41 |                 Debug.Log("Moved right!");
42 |             }
43 | 
44 |             if (manager.HasTriedAllDirections() && !movementCompleted)
45 |             {
46 |                 movementCompleted = true;
47 |                 Debug.Log("Great job! You've mastered movement.");
48 |                 manager.StartCoroutine(TransitionToNextState());
49 |             }
50 |         }
51 | 
52 |         public void Exit()
53 |         {
54 |             Debug.Log("Movement tutorial completed!");
55 |         }
56 | 
57 |         private IEnumerator TransitionToNextState()
58 |         {
59 |             yield return new WaitForSeconds(2f);
60 |             manager.ChangeState(new CombatTutorialState(manager));
61 |         }
62 |     }
63 | } 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/Character.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using UnityCheatSheet.Patterns.StrategyPattern.Strategies;
 3 | 
 4 | namespace UnityCheatSheet.Patterns.StrategyPattern
 5 | {
 6 |     public class Character : MonoBehaviour
 7 |     {
 8 |         private IAttackStrategy attackStrategy;
 9 |         public Transform target;
10 | 
11 |         private void Start()
12 |         {
13 |             // Default to melee attack
14 |             SetAttackStrategy(new MeleeAttackStrategy());
15 |         }
16 | 
17 |         public void SetAttackStrategy(IAttackStrategy strategy)
18 |         {
19 |             attackStrategy = strategy;
20 |             Debug.Log($"Changed to {strategy.GetType().Name} - Range: {strategy.GetRange()}, Damage: {strategy.GetDamage()}");
21 |         }
22 | 
23 |         public void PerformAttack()
24 |         {
25 |             if (attackStrategy != null && target != null)
26 |             {
27 |                 attackStrategy.Attack(transform, target);
28 |             }
29 |             else
30 |             {
31 |                 Debug.LogWarning("Cannot attack: Missing strategy or target");
32 |             }
33 |         }
34 |     }
35 | } 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/IAttackStrategy.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StrategyPattern
 4 | {
 5 |     public interface IAttackStrategy
 6 |     {
 7 |         void Attack(Transform attacker, Transform target);
 8 |         float GetDamage();
 9 |         float GetRange();
10 |     }
11 | } 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/README.md:
--------------------------------------------------------------------------------
 1 | # Strategy Pattern Example
 2 | 
 3 | A Unity example demonstrating the Strategy Pattern with a combat system.
 4 | 
 5 | ## Overview
 6 | 
 7 | The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. In this example, we use it to implement different attack strategies that a character can switch between during gameplay.
 8 | 
 9 | ## Implementation
10 | 
11 | - [`IAttackStrategy.cs`](IAttackStrategy.cs): Base interface for all attack strategies
12 | - [`Character.cs`](Character.cs): Context class that uses the strategies
13 | - Strategies:
14 |   - [`MeleeAttackStrategy.cs`](Strategies/MeleeAttackStrategy.cs): Close-range attack
15 |   - [`RangedAttackStrategy.cs`](Strategies/RangedAttackStrategy.cs): Long-range attack
16 |   - [`AreaAttackStrategy.cs`](Strategies/AreaAttackStrategy.cs): Area-of-effect attack
17 | 
18 | ## Usage
19 | 
20 | ```csharp
21 | // Add Character component to a GameObject
22 | Character character = gameObject.AddComponent<Character>();
23 | 
24 | // Switch between different attack strategies
25 | character.SetAttackStrategy(new MeleeAttackStrategy());
26 | character.SetAttackStrategy(new RangedAttackStrategy());
27 | character.SetAttackStrategy(new AreaAttackStrategy());
28 | 
29 | // Perform attack with current strategy
30 | character.PerformAttack();
31 | ```
32 | 
33 | ## Benefits
34 | 
35 | - Easy to add new attack strategies
36 | - Switch strategies at runtime
37 | - Clean separation of attack algorithms
38 | - Encapsulated attack behavior 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/Strategies/AreaAttackStrategy.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
 4 | {
 5 |     public class AreaAttackStrategy : IAttackStrategy
 6 |     {
 7 |         private readonly float damage = 10f;
 8 |         private readonly float range = 5f;
 9 | 
10 |         public void Attack(Transform attacker, Transform target)
11 |         {
12 |             Debug.Log($"Performing area attack at {attacker.position} with radius {range}!");
13 |             Debug.Log($"All enemies within range take {damage} damage!");
14 |         }
15 | 
16 |         public float GetDamage() => damage;
17 |         public float GetRange() => range;
18 |     }
19 | } 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/Strategies/MeleeAttackStrategy.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
 4 | {
 5 |     public class MeleeAttackStrategy : IAttackStrategy
 6 |     {
 7 |         private readonly float damage = 20f;
 8 |         private readonly float range = 2f;
 9 | 
10 |         public void Attack(Transform attacker, Transform target)
11 |         {
12 |             if (Vector3.Distance(attacker.position, target.position) <= range)
13 |             {
14 |                 Debug.Log($"Performing melee attack for {damage} damage!");
15 |             }
16 |             else
17 |             {
18 |                 Debug.Log("Target is too far for melee attack");
19 |             }
20 |         }
21 | 
22 |         public float GetDamage() => damage;
23 |         public float GetRange() => range;
24 |     }
25 | } 


--------------------------------------------------------------------------------
/Patterns/StrategyPattern/Strategies/RangedAttackStrategy.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | 
 3 | namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
 4 | {
 5 |     public class RangedAttackStrategy : IAttackStrategy
 6 |     {
 7 |         private readonly float damage = 15f;
 8 |         private readonly float range = 10f;
 9 | 
10 |         public void Attack(Transform attacker, Transform target)
11 |         {
12 |             if (Vector3.Distance(attacker.position, target.position) <= range)
13 |             {
14 |                 Vector3 direction = (target.position - attacker.position).normalized;
15 |                 Debug.Log($"Firing projectile in direction {direction} for {damage} damage!");
16 |             }
17 |             else
18 |             {
19 |                 Debug.Log("Target is out of range for ranged attack");
20 |             }
21 |         }
22 | 
23 |         public float GetDamage() => damage;
24 |         public float GetRange() => range;
25 |     }
26 | } 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
   1 | # Unity Cheat Sheet
   2 | 
   3 | ## Table of Contents
   4 | 
   5 | - [Basics](#basics)
   6 |   - [MonoBehaviour](#monobehaviour)
   7 |   - [Transform](#transform)
   8 |   - [Vector3](#vector3)
   9 |   - [Quaternion](#quaternion)
  10 |   - [Euler Angles](#euler-angles)
  11 | - [Movement & Rotation](#movement--rotation)
  12 |   - [Move Object](#move-object)
  13 |     - [Transform.Translate()](#transformtranslate)
  14 |     - [Vector3.MoveTowards()](#vector3movetowards)
  15 |     - [Vector3.Lerp()](#vector3lerp)
  16 |     - [Vector3.SmoothDamp()](#vector3smoothdamp)
  17 |   - [Rotate Object](#rotate-object)
  18 |     - [Transform.rotation](#transformrotation)
  19 |     - [Transform.eulerAngles](#transformeulerangles)
  20 |     - [Transform.Rotate()](#transformrotate)
  21 |     - [Transform.RotateAround()](#transformrotatearound)
  22 |     - [Transform.LookAt()](#transformlookat)
  23 |     - [Quaternion.LookRotation()](#quaternionlookrotation)
  24 |     - [Quaternion.FromToRotation()](#quaternionfromtorotation)
  25 |     - [Quaternion.ToAngleAxis()](#quaterniontoangleaxis)
  26 | - [Physics](#physics)
  27 |   - [Raycast](#raycast)
  28 |   - [Ignore Collision](#ignorecollision)
  29 | - [Input](#input)
  30 |   - [Keyboard](#keyboard)
  31 |   - [Mouse](#mouse)
  32 |   - [Touch](#touch)
  33 | - [UI](#ui)
  34 |   - [Button](#button)
  35 |   - [Slider](#slider)
  36 | - [Audio](#audio)
  37 |   - [Basic Audio Play](#basic-audio-play)
  38 | - [Scripting](#scripting)
  39 |   - [Coroutines](#coroutines)
  40 |   - [Async/Await](#asyncawait)
  41 |     - [Basic Structure](#basic-structure)
  42 |     - [Loading Resources](#loading-resources)
  43 |     - [Web Requests](#web-requests)
  44 |     - [Scene Loading](#scene-loading)
  45 |     - [Parallel Operations](#parallel-operations)
  46 |     - [Timeout Handling](#timeout-handling)
  47 |     - [Best Practices](#best-practices)
  48 |   - [Event Systems](#event-systems)
  49 |   - [Scriptable Objects](#scriptable-objects)
  50 |   - [Custom Editor Scripts](#custom-editor-scripts)
  51 | - [Design Patterns](#design-patterns)
  52 |   - [Singleton](#singleton)
  53 |   - [Factory Pattern](#factory-pattern)
  54 |   - [Observer Pattern](#observer-pattern)
  55 |   - [Command Pattern](#command-pattern)
  56 |   - [State Pattern](#state-pattern)
  57 |     - [Basic Example](#basic-example)
  58 |     - [Detailed Example - Game Onboarding System](#detailed-example---game-onboarding-system)
  59 |   - [Strategy Pattern](#strategy-pattern)
  60 |     - [Basic Example](#basic-example-1)
  61 |     - [Detailed Example - Combat System](#detailed-example---combat-system)
  62 |   - [Object Pooling Pattern](#object-pooling-pattern)
  63 |   - [Chain of Responsibility Pattern](#chain-of-responsibility-pattern)
  64 |     - [Basic Example](#basic-example-2)
  65 |     - [Detailed Example - Input Handling System](#detailed-example---input-handling-system)
  66 | - [Shortcuts](#shortcuts)
  67 |   - [Scene View Editing](#scene-view-editing)
  68 |   - [Scene View Navigation](#scene-view-navigation)
  69 |   - [Hierarchy Management](#hierarchy-management)
  70 |   - [Layout](#layout)
  71 | - [Practical Use Cases](#practical-use-cases)
  72 |   - [Check if object is on the ground](#check-if-object-is-on-the-ground)
  73 |   - [Get the transform of a Body Bone](#get-the-transform-of-a-body-bone)
  74 |   - [Make object look at the camera](#make-object-look-at-the-camera)
  75 |   - [Load next scene](#load-next-scene)
  76 | - [TBD (To Be Documented)](#tbd-to-be-documented)
  77 |   - [Input](#input-1)
  78 |   - [Scripting](#scripting-1)
  79 | 
  80 | ## Basics
  81 | 
  82 | ### [MonoBehaviour](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html)
  83 | [MonoBehaviour Life Cycle Flow Chart](https://docs.unity3d.com/uploads/Main/monobehaviour_flowchart.svg)
  84 | ```csharp
  85 | // MonoBehaviour is the base class from which every Unity script derives.
  86 | // Offers some life cycle functions that are easier for you to develop your game.
  87 | 
  88 | // Some of the most frequently used ones are as follows;
  89 | Awake()
  90 | Start()
  91 | Update()
  92 | FixedUpdate()
  93 | LateUpdate()
  94 | OnGUI()
  95 | OnEnable()
  96 | OnDisable()
  97 | ```
  98 | 
  99 | ### [Transform](https://docs.unity3d.com/ScriptReference/Transform.html)
 100 | ```csharp
 101 | // Transform is a fundamental component in Unity that every GameObject has.
 102 | // It defines the object's Position, Rotation, and Scale in the game world.
 103 | 
 104 | // Access the transform component
 105 | Transform transform = gameObject.transform;
 106 | 
 107 | // Position: Vector3 representing world space coordinates (x, y, z)
 108 | transform.position = new Vector3(0, 2, 0);      // Set absolute position
 109 | transform.localPosition = Vector3.zero;         // Position relative to parent
 110 | 
 111 | // Rotation: Can be set using Euler angles (degrees) or Quaternions
 112 | transform.rotation = Quaternion.identity;       // No rotation
 113 | transform.eulerAngles = new Vector3(0, 90, 0);  // Rotate 90 degrees around Y axis
 114 | transform.localRotation = Quaternion.identity;  // Rotation relative to parent
 115 | 
 116 | // Scale: Vector3 representing scale on each axis
 117 | transform.localScale = Vector3.one;             // Normal scale (1, 1, 1)
 118 | transform.localScale = new Vector3(2, 2, 2);    // Double size on all axes
 119 | 
 120 | // Parent-Child Relationships
 121 | transform.parent = anotherObject.transform;     // Set parent
 122 | transform.SetParent(null);                      // Remove parent (make root)
 123 | ```
 124 | 
 125 | ### [Vector3](https://docs.unity3d.com/ScriptReference/Vector3.html)
 126 | ```csharp
 127 | // Vector3 is representation of 3D vectors and points
 128 | // It's used to represent 3D positions,considering x,y & z axis.
 129 | 
 130 | Vector3 v = new Vector3(0f, 0f, 0f);
 131 | ```
 132 | 
 133 | ### [Quaternion](https://docs.unity3d.com/ScriptReference/Quaternion.html)
 134 | ```csharp
 135 | // A Quaternion stores the rotation of the Transform in world space.
 136 | // Quaternions are based on complex numbers and don't suffer from gimbal lock.
 137 | // Unity internally uses Quaternions to represent all rotations.
 138 | // You almost never access or modify individual Quaternion components (x,y,z,w); 
 139 | 
 140 | // A rotation 30 degrees around the y-axis
 141 | Quaternion rotation = Quaternion.Euler(0, 30, 0);
 142 | ```
 143 | 
 144 | ### Euler Angles
 145 | ```csharp
 146 | // Euler angles are "degree angles" like 90, 180, 45, 30 degrees.
 147 | // Quaternions differ from Euler angles in that they represent a point on a Unit Sphere (the radius is 1 unit).
 148 | 
 149 | // Create a quaternion that represents 30 degrees about X, 10 degrees about Y
 150 | Quaternion rotation = Quaternion.Euler(30, 10, 0);
 151 | 
 152 | // Using a Vector
 153 | Vector3 EulerRotation = new Vector3(30, 10, 0);
 154 | Quaternion rotation = Quaternion.Euler(EulerRotation);
 155 | 
 156 | // Convert a transform's Quaternion angles to Euler angles
 157 | Quaternion quaternionAngles = transform.rotation;
 158 | Vector3 eulerAngles = quaternionAngles.eulerAngles;
 159 | ```
 160 | 
 161 | ## Movement & Rotation
 162 | 
 163 | ### Move Object
 164 | #### Transform.Translate()
 165 | ```csharp
 166 | // Moves the transform in the direction and distance of translation.
 167 | public void Translate(Vector3 translation);
 168 | public void Translate(Vector3 translation, Space relativeTo = Space.Self);
 169 | 
 170 | transform.Translate(Vector3.right * movementSpeed);
 171 | ```
 172 | 
 173 | #### Vector3.MoveTowards()
 174 | ```csharp
 175 | // Calculate a position between the points specified by current and target
 176 | // Moving no farther than the distance specified by maxDistanceDelta
 177 | public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta);
 178 | 
 179 | Vector3 targetPosition;
 180 | transform.position = Vector3.MoveTowards(transform.position, targetPosition, Time.deltaTime);
 181 | ```
 182 | 
 183 | #### Vector3.Lerp()
 184 | ```csharp
 185 | // Linearly interpolates between two points. Results in a smooth transition.
 186 | public static Vector3 Lerp(Vector3 startValue, Vector3 endValue, float interpolationRatio);
 187 | 
 188 | Vector3 targetPosition;
 189 | float t = 0;
 190 | t += Time.deltaTime * speed;
 191 | transform.position = Vector3.Lerp(transform.position, targetPosition, t);
 192 | ```
 193 | 
 194 | #### Vector3.SmoothDamp()
 195 | ```csharp
 196 | // Gradually changes a vector towards a desired goal over time.
 197 | // The vector is smoothed by some spring-damper like function, which will never overshoot.
 198 | // The most common use is for smoothing a follow camera.
 199 | public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime);
 200 | 
 201 | float smoothTime = 1f;
 202 | Vector3 velocity;
 203 | Vector3 targetPosition = target.TransformPoint(new Vector3(0, 5, -10));
 204 | // Smoothly move the camera towards that target position
 205 | transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, smoothTime);
 206 | ```
 207 | 
 208 | ### Rotate Object
 209 | #### Transform.rotation
 210 | ```csharp
 211 | // A Quaternion stores the rotation of the Transform in world space.
 212 | // Quaternions are based on complex numbers and don't suffer from gimbal lock.
 213 | // Unity internally uses Quaternions to represent all rotations.
 214 | 
 215 | transform.rotation = new Quaternion(rotx, roty, rotz, rotw);
 216 | ```
 217 | 
 218 | #### Transform.eulerAngles
 219 | ```csharp
 220 | // Transform.eulerAngles represents rotation in world space. 
 221 | // It is important to understand that although you are providing X, Y, and Z rotation values to describe your rotation
 222 | // those values are not stored in the rotation. Instead, the X, Y & Z values are converted to the Quaternion's internal format.
 223 | 
 224 | transform.eulerAngles = Vector3(rotx, roty, rotz);
 225 | ```
 226 | 
 227 | #### Transform.Rotate()
 228 | ```csharp
 229 | // Applies rotation around all the given axes.
 230 | public void Rotate(Vector3 eulers, Space relativeTo = Space.Self);
 231 | public void Rotate(float xAngle, float yAngle, float zAngle, Space relativeTo = Space.Self);
 232 | 
 233 | transform.Rotate(rotx, roty, rotz);
 234 | ```
 235 | 
 236 | #### Transform.RotateAround()
 237 | ```csharp
 238 | // Rotates the transform about axis passing through point in world coordinates by angle degrees.
 239 | public void RotateAround(Vector3 point, Vector3 axis, float angle);
 240 | 
 241 | // Spin the object around the target at 20 degrees/second.
 242 | Transform target;
 243 | transform.RotateAround(target.position, Vector3.up, 20 * Time.deltaTime);
 244 | ```
 245 | 
 246 | #### Transform.LookAt()
 247 | ```csharp
 248 | // Points the positive 'Z' (forward) side of an object at a position in world space.
 249 | public void LookAt(Transform target);
 250 | public void LookAt(Transform target, Vector3 worldUp = Vector3.up);
 251 | 
 252 | // Rotate the object's forward vector to point at the target Transform.
 253 | Transform target;
 254 | transform.LookAt(target);
 255 | 
 256 | // Same as above, but setting the worldUp parameter to Vector3.left in this example turns the object on its side.
 257 | transform.LookAt(target, Vector3.left);
 258 | ```
 259 | 
 260 | #### Quaternion.LookRotation()
 261 | ```csharp
 262 | // Creates a rotation with the specified forward and upwards directions.
 263 | public static Quaternion LookRotation(Vector3 forward, Vector3 upwards = Vector3.up);
 264 | 
 265 | // The following code rotates the object towards a target object.
 266 | Vector3 direction = target.position - transform.position;
 267 | Quaternion rotation = Quaternion.LookRotation(direction);
 268 | transform.rotation = rotation;
 269 | ```
 270 | 
 271 | #### Quaternion.FromToRotation()
 272 | ```csharp
 273 | // Creates a rotation (a Quaternion) which rotates from fromDirection to toDirection.
 274 | public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection);
 275 | 
 276 | // Sets the rotation so that the transform's y-axis goes along the z-axis.
 277 | transform.rotation = Quaternion.FromToRotation(Vector3.up, transform.forward);
 278 | ```
 279 | 
 280 | #### Quaternion.ToAngleAxis()
 281 | ```csharp
 282 | // Converts a rotation to angle-axis representation (angles in degrees).
 283 | // In other words, extracts the angle as well as the axis that this quaternion represents.
 284 | public void ToAngleAxis(out float angle, out Vector3 axis);
 285 | 
 286 | // Extracts the angle - axis rotation from the transform rotation
 287 | float angle = 0.0f;
 288 | Vector3 axis = Vector3.zero;
 289 | transform.rotation.ToAngleAxis(out angle, out axis);
 290 | ```
 291 | 
 292 | ## Physics
 293 | ### Raycast
 294 | 
 295 | ```csharp
 296 | void FixedUpdate() {
 297 |     // Bit shift the index of the layer (8) to get a bit mask
 298 |     int layerMask = 1 << 8;
 299 | 
 300 |     // This would cast rays only against colliders in layer 8.
 301 |     // But instead we want to collide against everything except layer 8. The ~ operator does this, it inverts a bitmask.
 302 |     layerMask = ~layerMask;
 303 | 
 304 |     RaycastHit hit;
 305 |     // Does the ray intersect any objects excluding the player layer
 306 |     if (Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), out hit, Mathf.Infinity, layerMask)) {
 307 |         Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * hit.distance, Color.yellow);
 308 |         Debug.Log("Did Hit");
 309 |     }
 310 | }
 311 | ```
 312 | 
 313 | ### Ignore Collision
 314 | ```csharp
 315 | // Makes the collision detection system ignore all collisions between collider1 and collider2.
 316 | public static void IgnoreCollision(Collider collider1, Collider collider2, bool ignore = true);
 317 | 
 318 | // Here we're disabling the collision detection between the colliders of ally and bullet objects.
 319 | Transform bullet;
 320 | Transform ally;
 321 | Physics.IgnoreCollision(bullet.GetComponent<Collider>(), ally.GetComponent<Collider>());
 322 | ```
 323 | 
 324 | ## Input
 325 | 
 326 | ### Keyboard
 327 | 
 328 | ```csharp
 329 | // Returns true during the frame the user starts pressing down the key
 330 | if (Input.GetKeyDown(KeyCode.Space)) {
 331 |     Debug.Log("Space key was pressed");
 332 | }
 333 | 
 334 | // Jump is also set to space in Input Manager
 335 | if (Input.GetButtonDown("Jump")) {
 336 |     Debug.Log("Do something");
 337 | }
 338 | ```
 339 | 
 340 | ### Mouse
 341 | 
 342 | ```csharp
 343 | if (Input.GetAxis("Mouse X") < 0) {
 344 |     Debug.Log("Mouse moved left");
 345 | }
 346 | 
 347 | if (Input.GetAxis("Mouse Y") > 0) {
 348 |     Debug.Log("Mouse moved up");
 349 | }
 350 | 
 351 | if (Input.GetMouseButtonDown(0)) {
 352 |     Debug.Log("Pressed primary button.");
 353 | }
 354 | 
 355 | if (Input.GetMouseButtonDown(1)) {
 356 |     Debug.Log("Pressed secondary button.");
 357 | }
 358 | 
 359 | if (Input.GetMouseButtonDown(2)) {
 360 |     Debug.Log("Pressed middle click.");
 361 | }
 362 | ```
 363 | 
 364 | ### Touch
 365 | ```csharp
 366 | if (Input.touchCount > 0) {
 367 |     touch = Input.GetTouch(0);
 368 | 
 369 |     if (touch.phase == TouchPhase.Began) {
 370 |         Debug.Log("Touch began");
 371 |     }
 372 | 
 373 |     if (touch.phase == TouchPhase.Moved) {
 374 |         Debug.Log("Touch moves");
 375 |     }
 376 | 
 377 |     if (touch.phase == TouchPhase.Ended) {
 378 |         Debug.Log("Touch ended");
 379 |     }
 380 | }
 381 | ```
 382 | 
 383 | ## UI
 384 | 
 385 | ### Button
 386 | 
 387 | ```csharp
 388 | // Button is used to handle user clicks and interactions.
 389 | // Attach this script to a Button component to respond to button clicks.
 390 | 
 391 | using UnityEngine.UI;
 392 | 
 393 | Button myButton = GetComponent<Button>();
 394 | myButton.onClick.AddListener(MyButtonClickHandler);
 395 | 
 396 | void MyButtonClickHandler() {
 397 |     Debug.Log("Button Clicked!");
 398 | }
 399 | ```
 400 | 
 401 | ### Slider
 402 | ```csharp
 403 | // Slider is used for selecting a value within a range.
 404 | // Attach this script to a Slider component to respond to value changes.
 405 | 
 406 | using UnityEngine.UI;
 407 | 
 408 | Slider mySlider = GetComponent<Slider>();
 409 | mySlider.onValueChanged.AddListener(MySliderValueChangedHandler);
 410 | 
 411 | void MySliderValueChangedHandler(float value) {
 412 |     Debug.Log("Slider Value: " + value);
 413 | }
 414 | ```
 415 | 
 416 | ## Audio
 417 | 
 418 | ### Basic Audio Play
 419 | 
 420 | ```csharp
 421 | public class PlayAudio : MonoBehaviour {
 422 |     public AudioSource audioSource;
 423 | 
 424 |     void Start() {
 425 |         // Calling Play on an Audio Source that is already playing will make it start from the beginning
 426 |         audioSource.Play();
 427 |     }
 428 | }
 429 | ```
 430 | 
 431 | ## Scripting
 432 | 
 433 | ### Coroutines
 434 | Coroutines in Unity are a powerful feature that allows you to pause the execution of a function and resume it later. This is particularly useful for tasks that need to be spread over several frames, such as animations, waiting for a condition to be met, or handling asynchronous operations.
 435 | 
 436 | #### Basic Coroutine Example
 437 | ```csharp
 438 | using UnityEngine;
 439 | using System.Collections;
 440 | 
 441 | public class CoroutineExample : MonoBehaviour {
 442 |     void Start() {
 443 |         // Start the coroutine
 444 |         StartCoroutine(ExampleCoroutine());
 445 |     }
 446 | 
 447 |     IEnumerator ExampleCoroutine() {
 448 |         Debug.Log("Coroutine started");
 449 | 
 450 |         // Wait for 2 seconds
 451 |         yield return new WaitForSeconds(2);
 452 | 
 453 |         Debug.Log("Coroutine resumed after 2 seconds");
 454 |     }
 455 | }
 456 | ```
 457 | 
 458 | #### Using Coroutines for Repeated Actions
 459 | Coroutines can be used to perform repeated actions with a delay between each iteration.
 460 | 
 461 | ```csharp
 462 | IEnumerator RepeatActionCoroutine() {
 463 |     while (true) {
 464 |         Debug.Log("Action performed");
 465 |         
 466 |         // Wait for 1 second before repeating
 467 |         yield return new WaitForSeconds(1);
 468 |     }
 469 | }
 470 | 
 471 | // Start the coroutine
 472 | StartCoroutine(RepeatActionCoroutine());
 473 | ```
 474 | 
 475 | #### Waiting for a Condition
 476 | Coroutines can also wait for a condition to be true before continuing execution.
 477 | 
 478 | ```csharp
 479 | IEnumerator WaitForConditionCoroutine() {
 480 |     Debug.Log("Waiting for condition...");
 481 | 
 482 |     // Wait until the condition is met
 483 |     yield return new WaitUntil(() => SomeConditionIsTrue());
 484 | 
 485 |     Debug.Log("Condition met, resuming coroutine");
 486 | }
 487 | 
 488 | bool SomeConditionIsTrue() {
 489 |     // Replace with your actual condition
 490 |     return Time.time > 5;
 491 | }
 492 | 
 493 | // Start the coroutine
 494 | StartCoroutine(WaitForConditionCoroutine());
 495 | ```
 496 | 
 497 | #### Using Coroutines with Unity Events
 498 | Coroutines can be used to handle events over time, such as fading out a UI element.
 499 | 
 500 | ```csharp
 501 | IEnumerator FadeOutCoroutine(CanvasGroup canvasGroup, float duration) {
 502 |     float startAlpha = canvasGroup.alpha;
 503 |     float rate = 1.0f / duration;
 504 |     float progress = 0.0f;
 505 | 
 506 |     while (progress < 1.0f) {
 507 |         canvasGroup.alpha = Mathf.Lerp(startAlpha, 0, progress);
 508 |         progress += rate * Time.deltaTime;
 509 | 
 510 |         yield return null; // Wait for the next frame
 511 |     }
 512 | 
 513 |     canvasGroup.alpha = 0;
 514 | }
 515 | 
 516 | // Usage
 517 | CanvasGroup myCanvasGroup = GetComponent<CanvasGroup>();
 518 | StartCoroutine(FadeOutCoroutine(myCanvasGroup, 2.0f));
 519 | ```
 520 | 
 521 | #### Stopping Coroutines
 522 | You can stop a coroutine using `StopCoroutine()` or `StopAllCoroutines()`.
 523 | 
 524 | ```csharp
 525 | Coroutine myCoroutine;
 526 | 
 527 | void Start() {
 528 |     myCoroutine = StartCoroutine(ExampleCoroutine());
 529 | }
 530 | 
 531 | void StopMyCoroutine() {
 532 |     if (myCoroutine != null) {
 533 |         StopCoroutine(myCoroutine);
 534 |     }
 535 | }
 536 | 
 537 | void StopAllMyCoroutines() {
 538 |     StopAllCoroutines();
 539 | }
 540 | ```
 541 | 
 542 | #### Important Notes
 543 | - Coroutines are not threads. They run on the main thread and are subject to the same performance constraints.
 544 | - Use `yield return null;` to wait for the next frame.
 545 | - Use `yield return new WaitForSeconds(seconds);` to wait for a specific amount of time.
 546 | - Use `yield return new WaitUntil(() => condition);` to wait until a condition is true.
 547 | - Coroutines can be nested, and you can yield return other coroutines.
 548 | 
 549 | ### Event Systems
 550 | Unity provides several ways to handle events in your games. Here are the main approaches:
 551 | 
 552 | #### UnityEvents
 553 | UnityEvents are serializable events that can be configured in the Inspector and used in scripts.
 554 | 
 555 | ```csharp
 556 | using UnityEngine;
 557 | using UnityEngine.Events;
 558 | 
 559 | // Basic UnityEvent
 560 | public class BasicEventExample : MonoBehaviour {
 561 |     // This will show up in the inspector
 562 |     public UnityEvent onGameStart;
 563 |     
 564 |     void Start() {
 565 |         // Invoke the event
 566 |         onGameStart?.Invoke();
 567 |     }
 568 | }
 569 | 
 570 | // UnityEvent with parameters
 571 | [System.Serializable]
 572 | public class ScoreEvent : UnityEvent<int> { }
 573 | 
 574 | public class ParameterizedEventExample : MonoBehaviour {
 575 |     public ScoreEvent onScoreChanged;
 576 |     private int score = 0;
 577 | 
 578 |     public void AddScore(int points) {
 579 |         score += points;
 580 |         onScoreChanged?.Invoke(score);
 581 |     }
 582 | }
 583 | ```
 584 | 
 585 | #### C# Events and Delegates
 586 | Traditional C# events provide a more code-based approach to event handling.
 587 | 
 588 | 
 589 | Delegates are type-safe function pointers, and events are a way to broadcast messages to multiple listeners.
 590 | 
 591 | ```csharp
 592 | public class GameEvents : MonoBehaviour {
 593 |     // Delegate definition
 594 |     public delegate void GameStateHandler();
 595 |     public delegate void ScoreHandler(int newScore);
 596 | 
 597 |     // Event declaration
 598 |     public static event GameStateHandler OnGameStart;
 599 |     public static event GameStateHandler OnGameOver;
 600 |     public static event ScoreHandler OnScoreChanged;
 601 | 
 602 |     // Methods to trigger events
 603 |     public static void TriggerGameStart() {
 604 |         OnGameStart?.Invoke();
 605 |     }
 606 | 
 607 |     public static void TriggerGameOver() {
 608 |         OnGameOver?.Invoke();
 609 |     }
 610 | 
 611 |     public static void TriggerScoreChanged(int newScore) {
 612 |         OnScoreChanged?.Invoke(newScore);
 613 |     }
 614 | }
 615 | 
 616 | // Example usage in another class
 617 | public class Player : MonoBehaviour {
 618 |     void OnEnable() {
 619 |         // Subscribe to events
 620 |         GameEvents.OnGameStart += HandleGameStart;
 621 |         GameEvents.OnGameOver += HandleGameOver;
 622 |     }
 623 | 
 624 |     void OnDisable() {
 625 |         // Unsubscribe from events
 626 |         GameEvents.OnGameStart -= HandleGameStart;
 627 |         GameEvents.OnGameOver -= HandleGameOver;
 628 |     }
 629 | 
 630 |     private void HandleGameStart() {
 631 |         Debug.Log("Game Started!");
 632 |     }
 633 | 
 634 |     private void HandleGameOver() {
 635 |         Debug.Log("Game Over!");
 636 |     }
 637 | }
 638 | ```
 639 | 
 640 | ### Scriptable Objects
 641 | ```csharp
 642 | // ScriptableObjects are data containers that you can use to save large amounts of data, independent of class instances.
 643 | [CreateAssetMenu(fileName = "NewData", menuName = "ScriptableObjects/Data")]
 644 | public class Data : ScriptableObject {
 645 |     public string dataName;
 646 |     public int dataValue;
 647 | }
 648 | 
 649 | // Usage
 650 | Data myData = ScriptableObject.CreateInstance<Data>();
 651 | ```
 652 | 
 653 | ### Custom Editor Scripts
 654 | ```csharp
 655 | // Custom Editor scripts allow you to create custom inspectors and windows in the Unity Editor.
 656 | using UnityEditor;
 657 | using UnityEngine;
 658 | 
 659 | [CustomEditor(typeof(MyComponent))]
 660 | public class MyComponentEditor : Editor {
 661 |     public override void OnInspectorGUI() {
 662 |         DrawDefaultInspector();
 663 | 
 664 |         MyComponent myComponent = (MyComponent)target;
 665 |         if (GUILayout.Button("Do Something")) {
 666 |             myComponent.DoSomething();
 667 |         }
 668 |     }
 669 | }
 670 | ```
 671 | 
 672 | ### Async/Await
 673 | Async/await is a programming pattern that simplifies asynchronous programming. It allows you to write asynchronous code that looks and behaves like synchronous code. This is particularly useful for operations that might take time, such as:
 674 | - Loading resources
 675 | - Network requests
 676 | - File operations
 677 | - Scene loading
 678 | 
 679 | #### Basic Structure
 680 | ```csharp
 681 | using UnityEngine;
 682 | using System.Threading.Tasks;
 683 | using System;
 684 | 
 685 | public class AsyncAwaitExample : MonoBehaviour
 686 | {
 687 |     // Basic async/await structure in Unity
 688 |     private async void Start()
 689 |     {
 690 |         Debug.Log("Starting async operation");
 691 |         await Task.Delay(1000); // Wait for 1 second
 692 |         Debug.Log("Async operation completed");
 693 |     }
 694 | 
 695 |     // IMPORTANT: Unity's Update loop and MonoBehaviour methods must be void
 696 |     // They cannot be async Task
 697 |     private void Update() { }      // Correct
 698 |     // private async Task Update() {} // Wrong!
 699 | }
 700 | ```
 701 | 
 702 | #### Loading Resources
 703 | ```csharp
 704 | // Loading resources asynchronously with progress tracking
 705 | private async Task<Texture2D> LoadTextureAsync()
 706 | {
 707 |     var resourcePath = "Textures/MyTexture";
 708 |     var request = Resources.LoadAsync<Texture2D>(resourcePath);
 709 |     
 710 |     while (!request.isDone)
 711 |     {
 712 |         // Report progress
 713 |         Debug.Log($"Loading: {request.progress * 100}%");
 714 |         await Task.Yield(); // Let other operations continue
 715 |     }
 716 | 
 717 |     return request.asset as Texture2D;
 718 | }
 719 | ```
 720 | 
 721 | #### Web Requests
 722 | ```csharp
 723 | // Making web requests with progress tracking
 724 | private async Task<string> FetchDataAsync(string url)
 725 | {
 726 |     using var request = UnityWebRequest.Get(url);
 727 |     var operation = request.SendWebRequest();
 728 | 
 729 |     while (!operation.isDone)
 730 |     {
 731 |         Debug.Log($"Downloading: {request.downloadProgress * 100}%");
 732 |         await Task.Yield();
 733 |     }
 734 | 
 735 |     if (request.result != UnityWebRequest.Result.Success)
 736 |         throw new Exception($"Failed to fetch data: {request.error}");
 737 | 
 738 |     return request.downloadHandler.text;
 739 | }
 740 | ```
 741 | 
 742 | #### Scene Loading
 743 | ```csharp
 744 | // Loading scenes asynchronously with progress tracking
 745 | private async Task LoadSceneAsync(string sceneName)
 746 | {
 747 |     var operation = SceneManager.LoadSceneAsync(sceneName);
 748 |     operation.allowSceneActivation = false; // Don't activate immediately
 749 | 
 750 |     while (operation.progress < 0.9f) // 0.9 is the progress before activation
 751 |     {
 752 |         Debug.Log($"Loading scene: {operation.progress * 100}%");
 753 |         await Task.Yield();
 754 |     }
 755 | 
 756 |     Debug.Log("Scene ready to activate");
 757 |     operation.allowSceneActivation = true;
 758 | }
 759 | ```
 760 | 
 761 | #### Parallel Operations
 762 | ```csharp
 763 | // Running multiple async operations in parallel
 764 | private async Task LoadGameAssetsAsync()
 765 | {
 766 |     try
 767 |     {
 768 |         // Start multiple operations simultaneously
 769 |         var textureTask = LoadTextureAsync();
 770 |         var dataTask = FetchDataAsync("https://api.example.com/gamedata");
 771 |         var sceneTask = LoadSceneAsync("Level1");
 772 | 
 773 |         // Wait for all tasks to complete
 774 |         await Task.WhenAll(textureTask, dataTask, sceneTask);
 775 |         
 776 |         // All assets are now loaded
 777 |         Debug.Log("All assets loaded successfully");
 778 |     }
 779 |     catch (Exception e)
 780 |     {
 781 |         Debug.LogError($"Failed to load assets: {e.Message}");
 782 |     }
 783 | }
 784 | ```
 785 | 
 786 | #### Timeout Handling
 787 | ```csharp
 788 | // Implementing timeout for async operations
 789 | private async Task<T> WithTimeout<T>(Task<T> task, TimeSpan timeout)
 790 | {
 791 |     var timeoutTask = Task.Delay(timeout);
 792 |     var completedTask = await Task.WhenAny(task, timeoutTask);
 793 |     
 794 |     if (completedTask == timeoutTask)
 795 |         throw new TimeoutException("Operation timed out");
 796 |             
 797 |     return await task; // Unwrap the result or propagate the exception
 798 | }
 799 | 
 800 | // Complete example using timeout handling
 801 | private async Task InitializeGameAsync()
 802 | {
 803 |     try
 804 |     {
 805 |         // Show loading screen
 806 |         ShowLoadingUI();
 807 | 
 808 |         // Start multiple loading operations with timeout
 809 |         var loadingTask = Task.WhenAll(
 810 |             LoadTextureAsync(),
 811 |             FetchDataAsync("https://api.example.com/gamedata"),
 812 |             LoadSceneAsync("MainLevel")
 813 |         );
 814 | 
 815 |         // Wait for all operations with a 30-second timeout
 816 |         await WithTimeout(loadingTask, TimeSpan.FromSeconds(30));
 817 | 
 818 |         // Hide loading screen
 819 |         HideLoadingUI();
 820 |         Debug.Log("Game initialized successfully");
 821 |     }
 822 |     catch (TimeoutException)
 823 |     {
 824 |         Debug.LogError("Game initialization timed out");
 825 |         ShowRetryButton();
 826 |     }
 827 |     catch (Exception e)
 828 |     {
 829 |         Debug.LogError($"Failed to initialize game: {e.Message}");
 830 |         ShowErrorUI();
 831 |     }
 832 | }
 833 | ```
 834 | 
 835 | #### Best Practices
 836 | When using async/await in Unity, follow these best practices:
 837 | 
 838 | 1. Always handle exceptions in async methods
 839 | 2. Use Task.Yield() instead of Task.Delay() for frame-by-frame operations
 840 | 3. Remember that async void should only be used for event handlers and MonoBehaviour methods
 841 | 4. Use CancellationToken when possible to support cancellation
 842 | 5. Implement timeout handling for network operations
 843 | 6. Don't block the main thread with .Result or .Wait()
 844 | 7. Use Task.WhenAll for parallel operations
 845 | 
 846 | ## Design Patterns
 847 | ### Singleton
 848 | 
 849 | ```csharp
 850 | // Define singleton class
 851 | public class SingletonClass: MonoBehaviour {
 852 |     private static SingletonClass instance;
 853 | 
 854 |     public static SingletonClass Instance { get { return instance; } }
 855 | 
 856 |     private void Awake() {
 857 |         if (instance != null && instance != this) {
 858 |             Destroy(this.gameObject);
 859 |         } else {
 860 |             instance = this;
 861 |         }
 862 |     }
 863 | 
 864 |     public void SomeFunction() {
 865 |     }
 866 | }
 867 | 
 868 | // Use it in another class
 869 | public class AnotherClass: MonoBehaviour {
 870 | 
 871 |     private void Awake() {
 872 |        SingletonClass.Instance.SomeFunction();
 873 |     }
 874 | }
 875 | ```
 876 | 
 877 | ### Factory Pattern
 878 | ```csharp
 879 | // Interface for the enemy
 880 | public interface IEnemy {
 881 |     void Attack();
 882 |     void TakeDamage(int damage);
 883 | }
 884 | 
 885 | // Concrete implementation of the enemy: Goblin
 886 | public class Goblin : IEnemy {
 887 |     public void Attack() => Debug.Log("Goblin attacking!");
 888 |     public void TakeDamage(int damage) => Debug.Log($"Goblin taking {damage} damage.");
 889 | }
 890 | 
 891 | // Concrete implementation of the enemy: Orc
 892 | public class Orc : IEnemy {
 893 |     public void Attack() => Debug.Log("Orc attacking!");
 894 |     public void TakeDamage(int damage) => Debug.Log($"Orc taking {damage} damage.");
 895 | }
 896 | 
 897 | // Factory interface for creating enemies
 898 | public interface IEnemyFactory {
 899 |     IEnemy CreateEnemy();
 900 | }
 901 | 
 902 | // Concrete implementation of the factory: GoblinFactory
 903 | public class GoblinFactory : IEnemyFactory {
 904 |     public IEnemy CreateEnemy() => new Goblin();
 905 | }
 906 | 
 907 | // Concrete implementation of the factory: OrcFactory
 908 | public class OrcFactory : IEnemyFactory {
 909 |     public IEnemy CreateEnemy() => new Orc();
 910 | }
 911 | 
 912 | // Client class using the factory to create and interact with enemies
 913 | public class GameManager : MonoBehaviour {
 914 |     private void Start() {
 915 |         InteractWithEnemy(new GoblinFactory());
 916 |         InteractWithEnemy(new OrcFactory());
 917 | 
 918 |         // You can introduce new concrete implementations of IEnemy
 919 |         // without modifying existing client code
 920 |         // adhering to the open/closed principle of SOLID design 
 921 |     }
 922 | 
 923 |     private void InteractWithEnemy(IEnemyFactory factory) {
 924 |         IEnemy enemy = factory.CreateEnemy();
 925 | 
 926 |         // Consistent interaction regardless of the enemy type
 927 |         enemy.Attack();
 928 |         enemy.TakeDamage(20);
 929 |     }
 930 | }
 931 | ```
 932 | 
 933 | ### Observer Pattern
 934 | ```csharp
 935 | // Observer interface
 936 | public interface IObserver {
 937 |     void UpdateObserver(string message);
 938 | }
 939 | 
 940 | // Concrete implementation of the observer
 941 | public class ConcreteObserver : IObserver {
 942 |     private string name;
 943 | 
 944 |     public ConcreteObserver(string name) {
 945 |         this.name = name;
 946 |     }
 947 | 
 948 |     public void UpdateObserver(string message) {
 949 |         Debug.Log($"{name} received message: {message}");
 950 |     }
 951 | }
 952 | 
 953 | // Subject class
 954 | public class Subject {
 955 |     private List<IObserver> observers = new List<IObserver>();
 956 | 
 957 |     public void AddObserver(IObserver observer) {
 958 |         observers.Add(observer);
 959 |     }
 960 | 
 961 |     public void RemoveObserver(IObserver observer) {
 962 |         observers.Remove(observer);
 963 |     }
 964 | 
 965 |     public void NotifyObservers(string message) {
 966 |         foreach (var observer in observers) {
 967 |             observer.UpdateObserver(message);
 968 |         }
 969 |     }
 970 | }
 971 | 
 972 | // Example of usage
 973 | public class ObserverExample : MonoBehaviour {
 974 |     private void Start() {
 975 |         Subject subject = new Subject();
 976 | 
 977 |         ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
 978 |         ConcreteObserver observer2 = new ConcreteObserver("Observer 2");
 979 | 
 980 |         subject.AddObserver(observer1);
 981 |         subject.AddObserver(observer2);
 982 | 
 983 |         // Notify all observers
 984 |         subject.NotifyObservers("Hello Observers!");
 985 |     }
 986 | }
 987 | 
 988 | ```
 989 | 
 990 | ### Command Pattern
 991 | ```csharp
 992 | // Command interface
 993 | public interface ICommand {
 994 |     void Execute();
 995 | }
 996 | 
 997 | // Concrete command classes
 998 | public class MoveCommand : ICommand {
 999 |     private Transform transform;
1000 |     private Vector3 direction;
1001 |     private float distance;
1002 | 
1003 |     public MoveCommand(Transform transform, Vector3 direction, float distance) {
1004 |         this.transform = transform;
1005 |         this.direction = direction;
1006 |         this.distance = distance;
1007 |     }
1008 | 
1009 |     public void Execute() {
1010 |         transform.Translate(direction * distance);
1011 |     }
1012 | }
1013 | 
1014 | // Invoker class
1015 | public class CommandInvoker {
1016 |     private Stack<ICommand> commandStack = new Stack<ICommand>();
1017 | 
1018 |     public void ExecuteCommand(ICommand command) {
1019 |         commandStack.Push(command);
1020 |         command.Execute();
1021 |     }
1022 | 
1023 |     public void Undo() {
1024 |         if (commandStack.Count > 0) {
1025 |             var command = commandStack.Pop();
1026 |             // Implement an undo method if necessary
1027 |         }
1028 |     }
1029 | }
1030 | 
1031 | // Usage
1032 | public class CommandUser : MonoBehaviour {
1033 |     private CommandInvoker invoker = new CommandInvoker();
1034 | 
1035 |     void Update() {
1036 |         if (Input.GetKeyDown(KeyCode.UpArrow)) {
1037 |             ICommand moveUp = new MoveCommand(transform, Vector3.up, 1.0f);
1038 |             invoker.ExecuteCommand(moveUp);
1039 |         }
1040 | 
1041 |         // Add other directions and invoker.Undo() for undos
1042 |     }
1043 | }
1044 | ```
1045 | 
1046 | ### State Pattern
1047 | The State Pattern allows an object to alter its behavior when its internal state changes. It encapsulates state-specific behavior and makes state transitions explicit.
1048 | 
1049 | #### Basic Example
1050 | ```csharp
1051 | // State interface
1052 | public interface IState {
1053 |     void Enter();
1054 |     void Update();
1055 |     void Exit();
1056 | }
1057 | 
1058 | // Example state implementation
1059 | public class IdleState : IState {
1060 |     public void Enter() => Debug.Log("Entered Idle State");
1061 |     public void Update() => Debug.Log("Updating Idle State");
1062 |     public void Exit() => Debug.Log("Exited Idle State");
1063 | }
1064 | 
1065 | // State machine that manages state transitions
1066 | public class StateMachine : MonoBehaviour {
1067 |     private IState currentState;
1068 | 
1069 |     public void ChangeState(IState newState) {
1070 |         currentState?.Exit();
1071 |         currentState = newState;
1072 |         currentState?.Enter();
1073 |     }
1074 | 
1075 |     private void Update() {
1076 |         currentState?.Update();
1077 |     }
1078 | }
1079 | ```
1080 | 
1081 | #### Detailed Example - Game Onboarding System
1082 | A complete example showing how to implement a game onboarding/tutorial system using the State Pattern. This implementation demonstrates how to:
1083 | - Manage different tutorial states (movement, combat, inventory)
1084 | - Handle state transitions
1085 | - Track player progress through the tutorial
1086 | 
1087 | 👉 [View Full Implementation](Patterns/StatePattern/README.md)
1088 | 
1089 | ### Strategy Pattern
1090 | The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern lets the algorithm vary independently from clients that use it.
1091 | 
1092 | #### Basic Example
1093 | ```csharp
1094 | // Strategy interface
1095 | public interface IStrategy {
1096 |     void Execute();
1097 | }
1098 | 
1099 | // Example strategy implementation
1100 | public class AttackStrategy : IStrategy {
1101 |     public void Execute() => Debug.Log("Performing attack!");
1102 | }
1103 | 
1104 | // Context class that uses the strategy
1105 | public class Character : MonoBehaviour {
1106 |     private IStrategy strategy;
1107 | 
1108 |     public void SetStrategy(IStrategy newStrategy) {
1109 |         strategy = newStrategy;
1110 |     }
1111 | 
1112 |     public void ExecuteStrategy() {
1113 |         strategy?.Execute();
1114 |     }
1115 | }
1116 | ```
1117 | 
1118 | #### Detailed Example - Combat System
1119 | A complete example showing how to implement a flexible combat system using the Strategy Pattern. This implementation demonstrates how to:
1120 | - Define different attack strategies (melee, ranged, area)
1121 | - Switch between strategies at runtime
1122 | - Encapsulate combat algorithms
1123 | 
1124 | 👉 [View Full Implementation](Patterns/StrategyPattern/README.md)
1125 | 
1126 | ### Object Pooling Pattern
1127 | ```csharp
1128 | using System.Collections.Generic;
1129 | using UnityEngine;
1130 | 
1131 | public class ObjectPool : MonoBehaviour
1132 | {
1133 |     [System.Serializable]
1134 |     public class Pool
1135 |     {
1136 |         public string tag;
1137 |         public GameObject prefab;
1138 |         public int size;
1139 |     }
1140 | 
1141 |     public List<Pool> pools;
1142 |     public Dictionary<string, Queue<GameObject>> poolDictionary;
1143 | 
1144 |     private void Start()
1145 |     {
1146 |         poolDictionary = new Dictionary<string, Queue<GameObject>>();
1147 | 
1148 |         foreach (Pool pool in pools)
1149 |         {
1150 |             Queue<GameObject> objectPool = new Queue<GameObject>();
1151 | 
1152 |             for (int i = 0; i < pool.size; i++)
1153 |             {
1154 |                 GameObject obj = Instantiate(pool.prefab);
1155 |                 obj.SetActive(false);
1156 |                 objectPool.Enqueue(obj);
1157 |             }
1158 | 
1159 |             poolDictionary.Add(pool.tag, objectPool);
1160 |         }
1161 |     }
1162 | 
1163 |     public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation)
1164 |     {
1165 |         if (!poolDictionary.ContainsKey(tag))
1166 |         {
1167 |             Debug.LogWarning("Pool with tag " + tag + " doesn't exist.");
1168 |             return null;
1169 |         }
1170 | 
1171 |         GameObject objectToSpawn = poolDictionary[tag].Dequeue();
1172 | 
1173 |         objectToSpawn.SetActive(true);
1174 |         objectToSpawn.transform.position = position;
1175 |         objectToSpawn.transform.rotation = rotation;
1176 | 
1177 |         poolDictionary[tag].Enqueue(objectToSpawn);
1178 | 
1179 |         return objectToSpawn;
1180 |     }
1181 | }
1182 | 
1183 | // Usage example
1184 | public class GameManager : MonoBehaviour
1185 | {
1186 |     public ObjectPool objectPool;
1187 | 
1188 |     private void Update()
1189 |     {
1190 |         if (Input.GetKeyDown(KeyCode.Space))
1191 |         {
1192 |             objectPool.SpawnFromPool("Bullet", transform.position, Quaternion.identity);
1193 |         }
1194 |     }
1195 | }
1196 | ```
1197 | 
1198 | ### Chain of Responsibility Pattern
1199 | The Chain of Responsibility pattern creates a chain of handler objects for a request. Each handler contains a reference to the next handler in the chain and decides either to handle the request or pass it to the next handler.
1200 | 
1201 | #### Basic Example
1202 | ```csharp
1203 | // Handler interface
1204 | public interface IHandler {
1205 |     void SetNext(IHandler handler);
1206 |     void HandleRequest(string request);
1207 | }
1208 | 
1209 | // Base handler class
1210 | public abstract class BaseHandler : IHandler {
1211 |     protected IHandler nextHandler;
1212 | 
1213 |     public void SetNext(IHandler handler) {
1214 |         nextHandler = handler;
1215 |     }
1216 | 
1217 |     public virtual void HandleRequest(string request) {
1218 |         if (nextHandler != null) {
1219 |             nextHandler.HandleRequest(request);
1220 |         }
1221 |     }
1222 | }
1223 | 
1224 | // Concrete handlers
1225 | public class UIHandler : BaseHandler {
1226 |     public override void HandleRequest(string request) {
1227 |         if (request == "UI_CLICK") {
1228 |             Debug.Log("UI Handler: Handling UI click");
1229 |         } else {
1230 |             base.HandleRequest(request);
1231 |         }
1232 |     }
1233 | }
1234 | 
1235 | public class GameplayHandler : BaseHandler {
1236 |     public override void HandleRequest(string request) {
1237 |         if (request == "PLAYER_MOVE") {
1238 |             Debug.Log("Gameplay Handler: Handling player movement");
1239 |         } else {
1240 |             base.HandleRequest(request);
1241 |         }
1242 |     }
1243 | }
1244 | 
1245 | // Usage
1246 | public class InputManager : MonoBehaviour {
1247 |     private IHandler handlerChain;
1248 | 
1249 |     private void Start() {
1250 |         // Set up the chain
1251 |         var uiHandler = new UIHandler();
1252 |         var gameplayHandler = new GameplayHandler();
1253 |         
1254 |         uiHandler.SetNext(gameplayHandler);
1255 |         handlerChain = uiHandler;
1256 |     }
1257 | 
1258 |     private void Update() {
1259 |         // Example: Process different types of input
1260 |         if (Input.GetMouseButtonDown(0)) {
1261 |             handlerChain.HandleRequest("UI_CLICK");
1262 |         }
1263 |         if (Input.GetKeyDown(KeyCode.W)) {
1264 |             handlerChain.HandleRequest("PLAYER_MOVE");
1265 |         }
1266 |     }
1267 | }
1268 | ```
1269 | 
1270 | #### Detailed Example - Input Handling System
1271 | A complete example showing how to implement a robust input handling system using the Chain of Responsibility Pattern. This implementation demonstrates how to:
1272 | - Handle different types of input (UI, gameplay, cutscenes)
1273 | - Process input based on game state
1274 | - Chain multiple handlers together
1275 | 
1276 | 👉 [View Full Implementation](Patterns/ChainOfResponsibility/README.md)
1277 | 
1278 | ## Shortcuts
1279 | 
1280 | ### Scene View Editing
1281 | ```
1282 | Q - Pan tool
1283 | W - Move tool
1284 | E - Rotate tool
1285 | R - Scale tool
1286 | T - Rect tool
1287 | Y - Transform tool
1288 | 
1289 | CTRL/CMD + Z - Undo
1290 | CTRL/CMD + Y - Redo
1291 | CTRL/CMD + S - Save
1292 | CTRL/CMD + P - Play/Stop
1293 | CTRL/CMD + SHIFT + P - Pause
1294 | ```
1295 | 
1296 | ### Scene View Navigation
1297 | ```
1298 | Alt + Left Click - Orbit around scene view pivot
1299 | Alt + Right Click - Zoom in/out
1300 | Middle Mouse - Orbit
1301 | Middle Mouse + Alt - Zoom
1302 | F - Focus on selected object
1303 | CTRL/CMD + ALT + F - Frame selected
1304 | Hold Right Click - Free look (FPS style)
1305 | ```
1306 | 
1307 | ### Hierarchy Management
1308 | ```
1309 | CTRL/CMD + SHIFT + N - Create empty GameObject
1310 | ALT + SHIFT + N - Create empty child GameObject
1311 | CTRL/CMD + D - Duplicate selected
1312 | CTRL/CMD + ALT + F - Frame selected object
1313 | F2 - Rename selected
1314 | Delete - Delete selected
1315 | ```
1316 | 
1317 | ### Layout
1318 | ```
1319 | CTRL/CMD + 1-5 - Switch between layouts
1320 | SHIFT + Space - Toggle maximize current window
1321 | ```
1322 | 
1323 | ## Practical Use Cases
1324 | 
1325 | ### Check if object is on the ground
1326 | 
1327 | ```csharp
1328 | RaycastHit hit;
1329 | 
1330 | // Unlike this example, most of the time you should pass a layerMask as the last option to hit only to the ground
1331 | if (Physics.Raycast(transform.position, Vector3.down, out hit, 0.5f)) {
1332 |    Debug.log("Hit something below!");
1333 | }
1334 | ```
1335 | 
1336 | ### Get the transform of a Body Bone
1337 | 
1338 | ```csharp
1339 | Animator animator;
1340 | 
1341 | Transform transform = animator.GetBoneTransform(HumanBodyBones.Head);
1342 | ```
1343 | 
1344 | ### Make object look at the camera
1345 | 
1346 | ```csharp
1347 | var camPosition = Camera.main.transform.position;
1348 | 
1349 | transform.rotation = Quaternion.LookRotation(transform.position - camPosition);
1350 | ```
1351 | 
1352 | ### Load next scene
1353 | 
1354 | ```csharp
1355 | var nextSceneToLoad = SceneManager.GetActiveScene().buildIndex + 1;
1356 | var totalSceneCount = SceneManager.sceneCountInBuildSettings;
1357 | 
1358 | if (nextSceneToLoad < totalSceneCount) {
1359 |   SceneManager.LoadScene(nextSceneToLoad);
1360 | }
1361 | ```
1362 | 
1363 | ## TBD (To Be Documented)
1364 | 
1365 | The following topics are planned to be added to the documentation:
1366 | 
1367 | ### Input
1368 | - [ ] New Input System
1369 |   - [ ] Input Actions
1370 |   - [ ] Input Action Assets
1371 |   - [ ] Player Input Component
1372 |   - [ ] Input System Events


--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
 1 | # Dependencies
 2 | node_modules/
 3 | package-lock.json
 4 | 
 5 | # IDE and OS files
 6 | .DS_Store
 7 | .idea/
 8 | .vscode/
 9 | *.swp
10 | *.swo
11 | 
12 | # Build output
13 | dist/
14 | build/
15 | 
16 | # Logs
17 | *.log
18 | npm-debug.log*
19 | yarn-debug.log*
20 | yarn-error.log* 


--------------------------------------------------------------------------------
/docs/.nojekyll:
--------------------------------------------------------------------------------
1 |  


--------------------------------------------------------------------------------
/docs/CNAME:
--------------------------------------------------------------------------------
1 | unitycheatsheet.com


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
 1 | # Unity Cheat Sheet
 2 | 
 3 | A comprehensive guide to Unity development patterns and practices.
 4 | 
 5 | ## Table of Contents
 6 | 
 7 | ### Basics
 8 | 
 9 | - [MonoBehaviour](basics/monobehaviour.md)
10 | - [Transform](basics/transform.md)
11 | - [Vector3](basics/vector3.md)
12 | - [Quaternion](basics/quaternion.md)
13 | - [Euler Angles](basics/euler-angles.md)
14 | 
15 | ### Movement & Rotation
16 | 
17 | - [Move Object](movement-rotation/move-object.md)
18 | - [Rotate Object](movement-rotation/rotate-object.md)
19 | 
20 | ### Physics
21 | 
22 | - [Raycast](physics/raycast.md)
23 | - [Ignore Collision](physics/ignore-collision.md)
24 | 
25 | ### Input
26 | 
27 | - [Keyboard](input/keyboard.md)
28 | - [Mouse](input/mouse.md)
29 | - [Touch](input/touch.md)
30 | 
31 | ### UI
32 | 
33 | - [Button](ui/button.md)
34 | - [Slider](ui/slider.md)
35 | 
36 | ### Audio
37 | 
38 | - [Basic Audio Play](audio/basic-audio-play.md)
39 | 
40 | ### Scripting
41 | 
42 | - [Coroutines](scripting/coroutines.md)
43 | - [Async/Await](scripting/asyncawait.md)
44 | - [Event Systems](scripting/event-systems.md)
45 | - [Scriptable Objects](scripting/scriptable-objects.md)
46 | - [Custom Editor Scripts](scripting/custom-editor-scripts.md)
47 | 
48 | ### Design Patterns
49 | 
50 | - [Singleton](design-patterns/singleton.md)
51 | - [Factory Pattern](design-patterns/factory-pattern.md)
52 | - [Observer Pattern](design-patterns/observer-pattern.md)
53 | - [Command Pattern](design-patterns/command-pattern.md)
54 | - [State Pattern](design-patterns/state-pattern.md)
55 | - [Strategy Pattern](design-patterns/strategy-pattern.md)
56 | - [Object Pooling Pattern](design-patterns/object-pooling-pattern.md)
57 | - [Chain of Responsibility Pattern](design-patterns/chain-of-responsibility-pattern.md)
58 | 
59 | ### Shortcuts
60 | 
61 | - [Scene View Editing](shortcuts/scene-view-editing.md)
62 | - [Scene View Navigation](shortcuts/scene-view-navigation.md)
63 | - [Hierarchy Management](shortcuts/hierarchy-management.md)
64 | - [Layout](shortcuts/layout.md)
65 | 
66 | ### Practical Use Cases
67 | 
68 | - [Check if object is on the ground](practical-use-cases/check-if-object-is-on-the-ground.md)
69 | - [Get the transform of a Body Bone](practical-use-cases/get-the-transform-of-a-body-bone.md)
70 | - [Make object look at the camera](practical-use-cases/make-object-look-at-the-camera.md)
71 | - [Load next scene](practical-use-cases/load-next-scene.md)
72 | 
73 | ### TBD (To Be Documented)
74 | 
75 | - [Input](tbd-to-be-documented/input.md)
76 | - [Scripting](tbd-to-be-documented/scripting.md)
77 | 
78 | 


--------------------------------------------------------------------------------
/docs/_sidebar.md:
--------------------------------------------------------------------------------
 1 | <!-- docs/_sidebar.md -->
 2 | 
 3 | * [Home](README.md)
 4 | 
 5 | * Basics
 6 |   * [MonoBehaviour](basics/monobehaviour.md)
 7 |   * [Transform](basics/transform.md)
 8 |   * [Vector3](basics/vector3.md)
 9 |   * [Quaternion](basics/quaternion.md)
10 |   * [Euler Angles](basics/euler-angles.md)
11 | * Movement & Rotation
12 |   * [Move Object](movement-rotation/move-object.md)
13 |     * [Transform.Translate()](movement-rotation/move-object.md#transformtranslate)
14 |     * [Vector3.MoveTowards()](movement-rotation/move-object.md#vector3movetowards)
15 |     * [Vector3.Lerp()](movement-rotation/move-object.md#vector3lerp)
16 |     * [Vector3.SmoothDamp()](movement-rotation/move-object.md#vector3smoothdamp)
17 |   * [Rotate Object](movement-rotation/rotate-object.md)
18 |     * [Transform.rotation](movement-rotation/rotate-object.md#transformrotation)
19 |     * [Transform.eulerAngles](movement-rotation/rotate-object.md#transformeulerangles)
20 |     * [Transform.Rotate()](movement-rotation/rotate-object.md#transformrotate)
21 |     * [Transform.RotateAround()](movement-rotation/rotate-object.md#transformrotatearound)
22 |     * [Transform.LookAt()](movement-rotation/rotate-object.md#transformlookat)
23 |     * [Quaternion.LookRotation()](movement-rotation/rotate-object.md#quaternionlookrotation)
24 |     * [Quaternion.FromToRotation()](movement-rotation/rotate-object.md#quaternionfromtorotation)
25 |     * [Quaternion.ToAngleAxis()](movement-rotation/rotate-object.md#quaterniontoangleaxis)
26 | * Physics
27 |   * [Raycast](physics/raycast.md)
28 |   * [Ignore Collision](physics/ignore-collision.md)
29 | * Input
30 |   * [Keyboard](input/keyboard.md)
31 |   * [Mouse](input/mouse.md)
32 |   * [Touch](input/touch.md)
33 | * UI
34 |   * [Button](ui/button.md)
35 |   * [Slider](ui/slider.md)
36 | * Audio
37 |   * [Basic Audio Play](audio/basic-audio-play.md)
38 | * Scripting
39 |   * [Coroutines](scripting/coroutines.md)
40 |     * [Basic Coroutine Example](scripting/coroutines.md#basic-coroutine-example)
41 |     * [Using Coroutines for Repeated Actions](scripting/coroutines.md#using-coroutines-for-repeated-actions)
42 |     * [Waiting for a Condition](scripting/coroutines.md#waiting-for-a-condition)
43 |     * [Using Coroutines with Unity Events](scripting/coroutines.md#using-coroutines-with-unity-events)
44 |     * [Stopping Coroutines](scripting/coroutines.md#stopping-coroutines)
45 |     * [Important Notes](scripting/coroutines.md#important-notes)
46 |   * [Async/Await](scripting/asyncawait.md)
47 |     * [Basic Structure](scripting/asyncawait.md#basic-structure)
48 |     * [Loading Resources](scripting/asyncawait.md#loading-resources)
49 |     * [Web Requests](scripting/asyncawait.md#web-requests)
50 |     * [Scene Loading](scripting/asyncawait.md#scene-loading)
51 |     * [Parallel Operations](scripting/asyncawait.md#parallel-operations)
52 |     * [Timeout Handling](scripting/asyncawait.md#timeout-handling)
53 |     * [Best Practices](scripting/asyncawait.md#best-practices)
54 |   * [Event Systems](scripting/event-systems.md)
55 |     * [UnityEvents](scripting/event-systems.md#unityevents)
56 |     * [C# Events and Delegates](scripting/event-systems.md#c-events-and-delegates)
57 |   * [Scriptable Objects](scripting/scriptable-objects.md)
58 |   * [Custom Editor Scripts](scripting/custom-editor-scripts.md)
59 | * Design Patterns
60 |   * [Singleton](design-patterns/singleton.md)
61 |   * [Factory Pattern](design-patterns/factory-pattern.md)
62 |   * [Observer Pattern](design-patterns/observer-pattern.md)
63 |   * [Command Pattern](design-patterns/command-pattern.md)
64 |   * [State Pattern](design-patterns/state-pattern.md)
65 |     * [Basic Example](design-patterns/state-pattern.md#basic-example)
66 |     * [Detailed Example - Game Onboarding System](design-patterns/state-pattern.md#detailed-example-game-onboarding-system)
67 |   * [Strategy Pattern](design-patterns/strategy-pattern.md)
68 |     * [Basic Example](design-patterns/strategy-pattern.md#basic-example)
69 |     * [Detailed Example - Combat System](design-patterns/strategy-pattern.md#detailed-example-combat-system)
70 |   * [Object Pooling Pattern](design-patterns/object-pooling-pattern.md)
71 |   * [Chain of Responsibility Pattern](design-patterns/chain-of-responsibility-pattern.md)
72 |     * [Basic Example](design-patterns/chain-of-responsibility-pattern.md#basic-example)
73 |     * [Detailed Example - Input Handling System](design-patterns/chain-of-responsibility-pattern.md#detailed-example-input-handling-system)
74 | * Shortcuts
75 |   * [Scene View Editing](shortcuts/scene-view-editing.md)
76 |   * [Scene View Navigation](shortcuts/scene-view-navigation.md)
77 |   * [Hierarchy Management](shortcuts/hierarchy-management.md)
78 |   * [Layout](shortcuts/layout.md)
79 | * Practical Use Cases
80 |   * [Check if object is on the ground](practical-use-cases/check-if-object-is-on-the-ground.md)
81 |   * [Get the transform of a Body Bone](practical-use-cases/get-the-transform-of-a-body-bone.md)
82 |   * [Make object look at the camera](practical-use-cases/make-object-look-at-the-camera.md)
83 |   * [Load next scene](practical-use-cases/load-next-scene.md)
84 | * TBD (To Be Documented)
85 |   * [Input](tbd-to-be-documented/input.md)
86 |   * [Scripting](tbd-to-be-documented/scripting.md)
87 | 


--------------------------------------------------------------------------------
/docs/ads.txt:
--------------------------------------------------------------------------------
1 | google.com, pub-4199226001427614, DIRECT, f08c47fec0942fa0 


--------------------------------------------------------------------------------
/docs/assets/favicon/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ozankasikci/unity-cheat-sheet/ae4bac41dc7b3e4c5d0a2ea2f96e1e1468d30af8/docs/assets/favicon/apple-touch-icon.png


--------------------------------------------------------------------------------
/docs/assets/favicon/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ozankasikci/unity-cheat-sheet/ae4bac41dc7b3e4c5d0a2ea2f96e1e1468d30af8/docs/assets/favicon/favicon-16x16.png


--------------------------------------------------------------------------------
/docs/assets/favicon/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ozankasikci/unity-cheat-sheet/ae4bac41dc7b3e4c5d0a2ea2f96e1e1468d30af8/docs/assets/favicon/favicon-32x32.png


--------------------------------------------------------------------------------
/docs/assets/favicon/safari-pinned-tab.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
 3 | <svg version="1.0" xmlns="http://www.w3.org/2000/svg"
 4 |      width="700pt" height="700pt" viewBox="0 0 700 700"
 5 |      preserveAspectRatio="xMidYMid meet">
 6 |   <g transform="translate(0.000000,700.000000) scale(0.100000,-0.100000)" fill="#000000" stroke="none">
 7 |     <path d="M3330 6994 c-19 -2 -84 -9 -145 -15 -700 -67 -1431 -397 -1980 -892
 8 |     -521 -470 -880 -1089 -1027 -1772 -49 -228 -61 -351 -61 -615 0 -264 12 -387
 9 |     61 -615 147 -683 506 -1302 1027 -1772 470 -424 1029 -705 1665 -837 228 -47
10 |     351 -59 615 -59 264 0 387 12 615 59 683 147 1302 506 1772 1027 424 470 705
11 |     1029 837 1665 47 228 59 351 59 615 0 264 -12 387 -59 615 -132 636 -413
12 |     1195 -837 1665 -470 521 -1089 880 -1772 1027 -203 44 -325 56 -570 59 -129
13 |     2 -253 1 -275 -1z m-445 -1649 c83 -21 198 -76 266 -127 l57 -43 53 40 c29
14 |     22 89 57 133 77 71 33 91 37 176 41 171 7 314 -48 436 -170 123 -122 178
15 |     -265 171 -436 -4 -85 -8 -105 -41 -176 -20 -44 -55 -104 -77 -133 l-40 -53
16 |     43 -57 c51 -68 106 -183 127 -266 32 -128 24 -297 -20 -417 -91 -246 -304
17 |     -423 -559 -463 -85 -14 -116 -14 -201 0 -106 17 -188 47 -276 101 -33 20 -63
18 |     37 -66 37 -3 0 -33 -17 -66 -37 -88 -54 -170 -84 -276 -101 -85 -14 -116 -14
19 |     -201 0 -255 40 -468 217 -559 463 -44 120 -52 289 -20 417 21 83 76 198 127
20 |     266 l43 57 -40 53 c-22 29 -57 89 -77 133 -33 71 -37 91 -41 176 -7 171 48
21 |     314 170 436 122 122 265 177 436 170 85 -4 105 -8 176 -41 44 -20 104 -55
22 |     133 -77 l53 -40 57 43 c92 69 262 126 374 126 39 0 106 -9 149 -19z"/>
23 |     <path d="M2885 4595 c-16 -15 -25 -36 -25 -55 0 -19 9 -40 25 -55 24 -25 28
24 |     -25 190 -25 162 0 166 0 190 25 16 15 25 36 25 55 0 19 -9 40 -25 55 -24 25
25 |     -28 25 -190 25 -162 0 -166 0 -190 -25z"/>
26 |     <path d="M3735 4595 c-16 -15 -25 -36 -25 -55 0 -19 9 -40 25 -55 24 -25 28
27 |     -25 190 -25 162 0 166 0 190 25 16 15 25 36 25 55 0 19 -9 40 -25 55 -24 25
28 |     -28 25 -190 25 -162 0 -166 0 -190 -25z"/>
29 |     <path d="M2885 3795 c-16 -15 -25 -36 -25 -55 0 -19 9 -40 25 -55 24 -25 28
30 |     -25 190 -25 162 0 166 0 190 25 16 15 25 36 25 55 0 19 -9 40 -25 55 -24 25
31 |     -28 25 -190 25 -162 0 -166 0 -190 -25z"/>
32 |     <path d="M3735 3795 c-16 -15 -25 -36 -25 -55 0 -19 9 -40 25 -55 24 -25 28
33 |     -25 190 -25 162 0 166 0 190 25 16 15 25 36 25 55 0 19 -9 40 -25 55 -24 25
34 |     -28 25 -190 25 -162 0 -166 0 -190 -25z"/>
35 |   </g>
36 | </svg> 


--------------------------------------------------------------------------------
/docs/assets/favicon/site.webmanifest:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "Unity Cheat Sheet",
 3 |     "short_name": "Unity CS",
 4 |     "icons": [
 5 |         {
 6 |             "src": "/assets/favicon/android-chrome-192x192.png",
 7 |             "sizes": "192x192",
 8 |             "type": "image/png"
 9 |         },
10 |         {
11 |             "src": "/assets/favicon/android-chrome-512x512.png",
12 |             "sizes": "512x512",
13 |             "type": "image/png"
14 |         }
15 |     ],
16 |     "theme_color": "#ffffff",
17 |     "background_color": "#ffffff",
18 |     "display": "standalone"
19 | } 


--------------------------------------------------------------------------------
/docs/audio/basic-audio-play.md:
--------------------------------------------------------------------------------
 1 | # Basic Audio Play
 2 | 
 3 | ```csharp
 4 | public class PlayAudio : MonoBehaviour {
 5 |     public AudioSource audioSource;
 6 | 
 7 |     void Start() {
 8 |         // Calling Play on an Audio Source that is already playing will make it start from the beginning
 9 |         audioSource.Play();
10 |     }
11 | }
12 | ```
13 | 
14 | 


--------------------------------------------------------------------------------
/docs/basics/euler-angles.md:
--------------------------------------------------------------------------------
 1 | # Euler Angles
 2 | 
 3 | ```csharp
 4 | // Euler angles are "degree angles" like 90, 180, 45, 30 degrees.
 5 | // Quaternions differ from Euler angles in that they represent a point on a Unit Sphere (the radius is 1 unit).
 6 | 
 7 | // Create a quaternion that represents 30 degrees about X, 10 degrees about Y
 8 | Quaternion rotation = Quaternion.Euler(30, 10, 0);
 9 | 
10 | // Using a Vector
11 | Vector3 EulerRotation = new Vector3(30, 10, 0);
12 | Quaternion rotation = Quaternion.Euler(EulerRotation);
13 | 
14 | // Convert a transform's Quaternion angles to Euler angles
15 | Quaternion quaternionAngles = transform.rotation;
16 | Vector3 eulerAngles = quaternionAngles.eulerAngles;
17 | ```
18 | 
19 | 


--------------------------------------------------------------------------------
/docs/basics/monobehaviour.md:
--------------------------------------------------------------------------------
 1 | # MonoBehaviour
 2 | 
 3 | [MonoBehaviour Life Cycle Flow Chart](https://docs.unity3d.com/uploads/Main/monobehaviour_flowchart.svg)
 4 | ```csharp
 5 | // MonoBehaviour is the base class from which every Unity script derives.
 6 | // Offers some life cycle functions that are easier for you to develop your game.
 7 | 
 8 | // Some of the most frequently used ones are as follows;
 9 | Awake()
10 | Start()
11 | Update()
12 | FixedUpdate()
13 | LateUpdate()
14 | OnGUI()
15 | OnEnable()
16 | OnDisable()
17 | ```
18 | 
19 | 


--------------------------------------------------------------------------------
/docs/basics/quaternion.md:
--------------------------------------------------------------------------------
 1 | # Quaternion
 2 | 
 3 | ```csharp
 4 | // A Quaternion stores the rotation of the Transform in world space.
 5 | // Quaternions are based on complex numbers and don't suffer from gimbal lock.
 6 | // Unity internally uses Quaternions to represent all rotations.
 7 | // You almost never access or modify individual Quaternion components (x,y,z,w); 
 8 | 
 9 | // A rotation 30 degrees around the y-axis
10 | Quaternion rotation = Quaternion.Euler(0, 30, 0);
11 | ```
12 | 
13 | 


--------------------------------------------------------------------------------
/docs/basics/transform.md:
--------------------------------------------------------------------------------
 1 | # Transform
 2 | 
 3 | ```csharp
 4 | // Transform is a fundamental component in Unity that every GameObject has.
 5 | // It defines the object's Position, Rotation, and Scale in the game world.
 6 | 
 7 | // Access the transform component
 8 | Transform transform = gameObject.transform;
 9 | 
10 | // Position: Vector3 representing world space coordinates (x, y, z)
11 | transform.position = new Vector3(0, 2, 0);      // Set absolute position
12 | transform.localPosition = Vector3.zero;         // Position relative to parent
13 | 
14 | // Rotation: Can be set using Euler angles (degrees) or Quaternions
15 | transform.rotation = Quaternion.identity;       // No rotation
16 | transform.eulerAngles = new Vector3(0, 90, 0);  // Rotate 90 degrees around Y axis
17 | transform.localRotation = Quaternion.identity;  // Rotation relative to parent
18 | 
19 | // Scale: Vector3 representing scale on each axis
20 | transform.localScale = Vector3.one;             // Normal scale (1, 1, 1)
21 | transform.localScale = new Vector3(2, 2, 2);    // Double size on all axes
22 | 
23 | // Parent-Child Relationships
24 | transform.parent = anotherObject.transform;     // Set parent
25 | transform.SetParent(null);                      // Remove parent (make root)
26 | ```
27 | 
28 | 


--------------------------------------------------------------------------------
/docs/basics/vector3.md:
--------------------------------------------------------------------------------
 1 | # Vector3
 2 | 
 3 | ```csharp
 4 | // Vector3 is representation of 3D vectors and points
 5 | // It's used to represent 3D positions,considering x,y & z axis.
 6 | 
 7 | Vector3 v = new Vector3(0f, 0f, 0f);
 8 | ```
 9 | 
10 | 


--------------------------------------------------------------------------------
/docs/design-patterns/chain-of-responsibility-pattern.md:
--------------------------------------------------------------------------------
 1 | # Chain of Responsibility Pattern
 2 | 
 3 | The Chain of Responsibility pattern creates a chain of handler objects for a request. Each handler contains a reference to the next handler in the chain and decides either to handle the request or pass it to the next handler.
 4 | 
 5 | #### Basic Example
 6 | ```csharp
 7 | // Handler interface
 8 | public interface IHandler {
 9 |     void SetNext(IHandler handler);
10 |     void HandleRequest(string request);
11 | }
12 | 
13 | // Base handler class
14 | public abstract class BaseHandler : IHandler {
15 |     protected IHandler nextHandler;
16 | 
17 |     public void SetNext(IHandler handler) {
18 |         nextHandler = handler;
19 |     }
20 | 
21 |     public virtual void HandleRequest(string request) {
22 |         if (nextHandler != null) {
23 |             nextHandler.HandleRequest(request);
24 |         }
25 |     }
26 | }
27 | 
28 | // Concrete handlers
29 | public class UIHandler : BaseHandler {
30 |     public override void HandleRequest(string request) {
31 |         if (request == "UI_CLICK") {
32 |             Debug.Log("UI Handler: Handling UI click");
33 |         } else {
34 |             base.HandleRequest(request);
35 |         }
36 |     }
37 | }
38 | 
39 | public class GameplayHandler : BaseHandler {
40 |     public override void HandleRequest(string request) {
41 |         if (request == "PLAYER_MOVE") {
42 |             Debug.Log("Gameplay Handler: Handling player movement");
43 |         } else {
44 |             base.HandleRequest(request);
45 |         }
46 |     }
47 | }
48 | 
49 | // Usage
50 | public class InputManager : MonoBehaviour {
51 |     private IHandler handlerChain;
52 | 
53 |     private void Start() {
54 |         // Set up the chain
55 |         var uiHandler = new UIHandler();
56 |         var gameplayHandler = new GameplayHandler();
57 |         
58 |         uiHandler.SetNext(gameplayHandler);
59 |         handlerChain = uiHandler;
60 |     }
61 | 
62 |     private void Update() {
63 |         // Example: Process different types of input
64 |         if (Input.GetMouseButtonDown(0)) {
65 |             handlerChain.HandleRequest("UI_CLICK");
66 |         }
67 |         if (Input.GetKeyDown(KeyCode.W)) {
68 |             handlerChain.HandleRequest("PLAYER_MOVE");
69 |         }
70 |     }
71 | }
72 | ```
73 | 
74 | #### Detailed Example - Input Handling System
75 | A complete example showing how to implement a robust input handling system using the Chain of Responsibility Pattern. This implementation demonstrates how to:
76 | - Handle different types of input (UI, gameplay, cutscenes)
77 | - Process input based on game state
78 | - Chain multiple handlers together
79 | 
80 | 👉 [View Full Implementation](https://github.com/ozankasikci/unity-cheat-sheet/tree/master/Patterns/ChainOfResponsibility/README.md)
81 | 
82 | 


--------------------------------------------------------------------------------
/docs/design-patterns/command-pattern.md:
--------------------------------------------------------------------------------
 1 | # Command Pattern
 2 | 
 3 | ```csharp
 4 | // Command interface
 5 | public interface ICommand {
 6 |     void Execute();
 7 | }
 8 | 
 9 | // Concrete command classes
10 | public class MoveCommand : ICommand {
11 |     private Transform transform;
12 |     private Vector3 direction;
13 |     private float distance;
14 | 
15 |     public MoveCommand(Transform transform, Vector3 direction, float distance) {
16 |         this.transform = transform;
17 |         this.direction = direction;
18 |         this.distance = distance;
19 |     }
20 | 
21 |     public void Execute() {
22 |         transform.Translate(direction * distance);
23 |     }
24 | }
25 | 
26 | // Invoker class
27 | public class CommandInvoker {
28 |     private Stack<ICommand> commandStack = new Stack<ICommand>();
29 | 
30 |     public void ExecuteCommand(ICommand command) {
31 |         commandStack.Push(command);
32 |         command.Execute();
33 |     }
34 | 
35 |     public void Undo() {
36 |         if (commandStack.Count > 0) {
37 |             var command = commandStack.Pop();
38 |             // Implement an undo method if necessary
39 |         }
40 |     }
41 | }
42 | 
43 | // Usage
44 | public class CommandUser : MonoBehaviour {
45 |     private CommandInvoker invoker = new CommandInvoker();
46 | 
47 |     void Update() {
48 |         if (Input.GetKeyDown(KeyCode.UpArrow)) {
49 |             ICommand moveUp = new MoveCommand(transform, Vector3.up, 1.0f);
50 |             invoker.ExecuteCommand(moveUp);
51 |         }
52 | 
53 |         // Add other directions and invoker.Undo() for undos
54 |     }
55 | }
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/docs/design-patterns/factory-pattern.md:
--------------------------------------------------------------------------------
 1 | # Factory Pattern
 2 | 
 3 | ```csharp
 4 | // Interface for the enemy
 5 | public interface IEnemy {
 6 |     void Attack();
 7 |     void TakeDamage(int damage);
 8 | }
 9 | 
10 | // Concrete implementation of the enemy: Goblin
11 | public class Goblin : IEnemy {
12 |     public void Attack() => Debug.Log("Goblin attacking!");
13 |     public void TakeDamage(int damage) => Debug.Log($"Goblin taking {damage} damage.");
14 | }
15 | 
16 | // Concrete implementation of the enemy: Orc
17 | public class Orc : IEnemy {
18 |     public void Attack() => Debug.Log("Orc attacking!");
19 |     public void TakeDamage(int damage) => Debug.Log($"Orc taking {damage} damage.");
20 | }
21 | 
22 | // Factory interface for creating enemies
23 | public interface IEnemyFactory {
24 |     IEnemy CreateEnemy();
25 | }
26 | 
27 | // Concrete implementation of the factory: GoblinFactory
28 | public class GoblinFactory : IEnemyFactory {
29 |     public IEnemy CreateEnemy() => new Goblin();
30 | }
31 | 
32 | // Concrete implementation of the factory: OrcFactory
33 | public class OrcFactory : IEnemyFactory {
34 |     public IEnemy CreateEnemy() => new Orc();
35 | }
36 | 
37 | // Client class using the factory to create and interact with enemies
38 | public class GameManager : MonoBehaviour {
39 |     private void Start() {
40 |         InteractWithEnemy(new GoblinFactory());
41 |         InteractWithEnemy(new OrcFactory());
42 | 
43 |         // You can introduce new concrete implementations of IEnemy
44 |         // without modifying existing client code
45 |         // adhering to the open/closed principle of SOLID design 
46 |     }
47 | 
48 |     private void InteractWithEnemy(IEnemyFactory factory) {
49 |         IEnemy enemy = factory.CreateEnemy();
50 | 
51 |         // Consistent interaction regardless of the enemy type
52 |         enemy.Attack();
53 |         enemy.TakeDamage(20);
54 |     }
55 | }
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/docs/design-patterns/object-pooling-pattern.md:
--------------------------------------------------------------------------------
 1 | # Object Pooling Pattern
 2 | 
 3 | ```csharp
 4 | using System.Collections.Generic;
 5 | using UnityEngine;
 6 | 
 7 | public class ObjectPool : MonoBehaviour
 8 | {
 9 |     [System.Serializable]
10 |     public class Pool
11 |     {
12 |         public string tag;
13 |         public GameObject prefab;
14 |         public int size;
15 |     }
16 | 
17 |     public List<Pool> pools;
18 |     public Dictionary<string, Queue<GameObject>> poolDictionary;
19 | 
20 |     private void Start()
21 |     {
22 |         poolDictionary = new Dictionary<string, Queue<GameObject>>();
23 | 
24 |         foreach (Pool pool in pools)
25 |         {
26 |             Queue<GameObject> objectPool = new Queue<GameObject>();
27 | 
28 |             for (int i = 0; i < pool.size; i++)
29 |             {
30 |                 GameObject obj = Instantiate(pool.prefab);
31 |                 obj.SetActive(false);
32 |                 objectPool.Enqueue(obj);
33 |             }
34 | 
35 |             poolDictionary.Add(pool.tag, objectPool);
36 |         }
37 |     }
38 | 
39 |     public GameObject SpawnFromPool(string tag, Vector3 position, Quaternion rotation)
40 |     {
41 |         if (!poolDictionary.ContainsKey(tag))
42 |         {
43 |             Debug.LogWarning("Pool with tag " + tag + " doesn't exist.");
44 |             return null;
45 |         }
46 | 
47 |         GameObject objectToSpawn = poolDictionary[tag].Dequeue();
48 | 
49 |         objectToSpawn.SetActive(true);
50 |         objectToSpawn.transform.position = position;
51 |         objectToSpawn.transform.rotation = rotation;
52 | 
53 |         poolDictionary[tag].Enqueue(objectToSpawn);
54 | 
55 |         return objectToSpawn;
56 |     }
57 | }
58 | 
59 | // Usage example
60 | public class GameManager : MonoBehaviour
61 | {
62 |     public ObjectPool objectPool;
63 | 
64 |     private void Update()
65 |     {
66 |         if (Input.GetKeyDown(KeyCode.Space))
67 |         {
68 |             objectPool.SpawnFromPool("Bullet", transform.position, Quaternion.identity);
69 |         }
70 |     }
71 | }
72 | ```
73 | 
74 | 


--------------------------------------------------------------------------------
/docs/design-patterns/observer-pattern.md:
--------------------------------------------------------------------------------
 1 | # Observer Pattern
 2 | 
 3 | ```csharp
 4 | // Observer interface
 5 | public interface IObserver {
 6 |     void UpdateObserver(string message);
 7 | }
 8 | 
 9 | // Concrete implementation of the observer
10 | public class ConcreteObserver : IObserver {
11 |     private string name;
12 | 
13 |     public ConcreteObserver(string name) {
14 |         this.name = name;
15 |     }
16 | 
17 |     public void UpdateObserver(string message) {
18 |         Debug.Log($"{name} received message: {message}");
19 |     }
20 | }
21 | 
22 | // Subject class
23 | public class Subject {
24 |     private List<IObserver> observers = new List<IObserver>();
25 | 
26 |     public void AddObserver(IObserver observer) {
27 |         observers.Add(observer);
28 |     }
29 | 
30 |     public void RemoveObserver(IObserver observer) {
31 |         observers.Remove(observer);
32 |     }
33 | 
34 |     public void NotifyObservers(string message) {
35 |         foreach (var observer in observers) {
36 |             observer.UpdateObserver(message);
37 |         }
38 |     }
39 | }
40 | 
41 | // Example of usage
42 | public class ObserverExample : MonoBehaviour {
43 |     private void Start() {
44 |         Subject subject = new Subject();
45 | 
46 |         ConcreteObserver observer1 = new ConcreteObserver("Observer 1");
47 |         ConcreteObserver observer2 = new ConcreteObserver("Observer 2");
48 | 
49 |         subject.AddObserver(observer1);
50 |         subject.AddObserver(observer2);
51 | 
52 |         // Notify all observers
53 |         subject.NotifyObservers("Hello Observers!");
54 |     }
55 | }
56 | 
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/docs/design-patterns/singleton.md:
--------------------------------------------------------------------------------
 1 | # Singleton
 2 | 
 3 | ```csharp
 4 | // Define singleton class
 5 | public class SingletonClass: MonoBehaviour {
 6 |     private static SingletonClass instance;
 7 | 
 8 |     public static SingletonClass Instance { get { return instance; } }
 9 | 
10 |     private void Awake() {
11 |         if (instance != null && instance != this) {
12 |             Destroy(this.gameObject);
13 |         } else {
14 |             instance = this;
15 |         }
16 |     }
17 | 
18 |     public void SomeFunction() {
19 |     }
20 | }
21 | 
22 | // Use it in another class
23 | public class AnotherClass: MonoBehaviour {
24 | 
25 |     private void Awake() {
26 |        SingletonClass.Instance.SomeFunction();
27 |     }
28 | }
29 | ```
30 | 
31 | 


--------------------------------------------------------------------------------
/docs/design-patterns/state-pattern.md:
--------------------------------------------------------------------------------
 1 | # State Pattern
 2 | 
 3 | The State Pattern allows an object to alter its behavior when its internal state changes. It encapsulates state-specific behavior and makes state transitions explicit.
 4 | 
 5 | #### Basic Example
 6 | ```csharp
 7 | // State interface
 8 | public interface IState {
 9 |     void Enter();
10 |     void Update();
11 |     void Exit();
12 | }
13 | 
14 | // Example state implementation
15 | public class IdleState : IState {
16 |     public void Enter() => Debug.Log("Entered Idle State");
17 |     public void Update() => Debug.Log("Updating Idle State");
18 |     public void Exit() => Debug.Log("Exited Idle State");
19 | }
20 | 
21 | // State machine that manages state transitions
22 | public class StateMachine : MonoBehaviour {
23 |     private IState currentState;
24 | 
25 |     public void ChangeState(IState newState) {
26 |         currentState?.Exit();
27 |         currentState = newState;
28 |         currentState?.Enter();
29 |     }
30 | 
31 |     private void Update() {
32 |         currentState?.Update();
33 |     }
34 | }
35 | ```
36 | 
37 | #### Detailed Example - Game Onboarding System
38 | A complete example showing how to implement a game onboarding/tutorial system using the State Pattern. This implementation demonstrates how to:
39 | - Manage different tutorial states (movement, combat, inventory)
40 | - Handle state transitions
41 | - Track player progress through the tutorial
42 | 
43 | 👉 [View Full Implementation](https://github.com/ozankasikci/unity-cheat-sheet/tree/master/Patterns/StatePattern/README.md)
44 | 
45 | 


--------------------------------------------------------------------------------
/docs/design-patterns/strategy-pattern.md:
--------------------------------------------------------------------------------
 1 | # Strategy Pattern
 2 | 
 3 | The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern lets the algorithm vary independently from clients that use it.
 4 | 
 5 | #### Basic Example
 6 | ```csharp
 7 | // Strategy interface
 8 | public interface IStrategy {
 9 |     void Execute();
10 | }
11 | 
12 | // Example strategy implementation
13 | public class AttackStrategy : IStrategy {
14 |     public void Execute() => Debug.Log("Performing attack!");
15 | }
16 | 
17 | // Context class that uses the strategy
18 | public class Character : MonoBehaviour {
19 |     private IStrategy strategy;
20 | 
21 |     public void SetStrategy(IStrategy newStrategy) {
22 |         strategy = newStrategy;
23 |     }
24 | 
25 |     public void ExecuteStrategy() {
26 |         strategy?.Execute();
27 |     }
28 | }
29 | ```
30 | 
31 | #### Detailed Example - Combat System
32 | A complete example showing how to implement a flexible combat system using the Strategy Pattern. This implementation demonstrates how to:
33 | - Define different attack strategies (melee, ranged, area)
34 | - Switch between strategies at runtime
35 | - Encapsulate combat algorithms
36 | 
37 | 👉 [View Full Implementation](https://github.com/ozankasikci/unity-cheat-sheet/tree/master/Patterns/StrategyPattern/README.md)
38 | 
39 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |   <!-- Google tag (gtag.js) -->
  5 |   <script async src="https://www.googletagmanager.com/gtag/js?id=G-CBSK1QXVZL"></script>
  6 |   <script>
  7 |     window.dataLayer = window.dataLayer || [];
  8 |     function gtag(){dataLayer.push(arguments);}
  9 |     gtag('js', new Date());
 10 | 
 11 |     gtag('config', 'G-CBSK1QXVZL');
 12 |   </script>
 13 |   <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-4199226001427614"
 14 |   crossorigin="anonymous"></script>
 15 |   <meta charset="UTF-8">
 16 |   <title>Unity Cheat Sheet - Complete Guide to Unity Development Patterns and Practices</title>
 17 |   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
 18 |   
 19 |   <!-- Primary Meta Tags -->
 20 |   <meta name="title" content="Unity Cheat Sheet - A Guide to Unity Development Patterns and Practices">
 21 |   <meta name="description" content="A comprehensive guide to Unity game development, including design patterns, best practices, code examples, and practical use cases for game developers.">
 22 |   <meta name="keywords" content="unity, game development, design patterns, unity3d, c#, programming, game design, unity tutorial, unity guide">
 23 |   <meta name="author" content="Ozan Kaşıkçı">
 24 |   <meta name="robots" content="index, follow">
 25 |   
 26 |   <!-- Open Graph / Facebook -->
 27 |   <meta property="og:type" content="website">
 28 |   <meta property="og:url" content="https://ozankasikci.github.io/unity-cheat-sheet/">
 29 |   <meta property="og:title" content="Unity Cheat Sheet - Complete Guide to Unity Development Patterns and Practices">
 30 |   <meta property="og:description" content="A comprehensive guide to Unity game development, including design patterns, best practices, code examples, and practical use cases for game developers.">
 31 |   <meta property="og:image" content="https://ozankasikci.github.io/unity-cheat-sheet/assets/og-image.png">
 32 | 
 33 |   <!-- Twitter -->
 34 |   <meta property="twitter:card" content="summary_large_image">
 35 |   <meta property="twitter:url" content="https://ozankasikci.github.io/unity-cheat-sheet/">
 36 |   <meta property="twitter:title" content="Unity Cheat Sheet - Complete Guide to Unity Development Patterns and Practices">
 37 |   <meta property="twitter:description" content="A comprehensive guide to Unity game development, including design patterns, best practices, code examples, and practical use cases for game developers.">
 38 |   <meta property="twitter:image" content="https://ozankasikci.github.io/unity-cheat-sheet/assets/og-image.png">
 39 | 
 40 |   <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0">
 41 |   <link rel="canonical" href="https://ozankasikci.github.io/unity-cheat-sheet/">
 42 |   
 43 |   <!-- Theme -->
 44 |   <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify-darklight-theme@latest/dist/style.min.css" title="docsify-darklight-theme" type="text/css">
 45 |   
 46 |   <!-- Favicons -->
 47 |   <link rel="apple-touch-icon" sizes="180x180" href="assets/favicon/apple-touch-icon.png">
 48 |   <link rel="icon" type="image/png" sizes="32x32" href="assets/favicon/favicon-32x32.png">
 49 |   <link rel="icon" type="image/png" sizes="16x16" href="assets/favicon/favicon-16x16.png">
 50 |   <link rel="manifest" href="assets/favicon/site.webmanifest">
 51 |   <link rel="mask-icon" href="assets/favicon/safari-pinned-tab.svg" color="#000000">
 52 |   <meta name="msapplication-TileColor" content="#ffffff">
 53 |   <meta name="theme-color" content="#ffffff">
 54 | 
 55 |   <!-- Schema.org markup for Google -->
 56 |   <script type="application/ld+json">
 57 |     {
 58 |       "@context": "https://schema.org",
 59 |       "@type": "TechnicalArticle",
 60 |       "headline": "Unity Cheat Sheet - Complete Guide to Unity Development Patterns and Practices",
 61 |       "description": "A comprehensive guide to Unity game development, including design patterns, best practices, code examples, and practical use cases for game developers.",
 62 |       "author": {
 63 |         "@type": "Person",
 64 |         "name": "Ozan Kasikci"
 65 |       },
 66 |       "publisher": {
 67 |         "@type": "Organization",
 68 |         "name": "Unity Cheat Sheet",
 69 |         "logo": {
 70 |           "@type": "ImageObject",
 71 |           "url": "https://ozankasikci.github.io/unity-cheat-sheet/assets/favicon/android-chrome-512x512.png"
 72 |         }
 73 |       },
 74 |       "datePublished": "2023-01-01",
 75 |       "dateModified": "2024-01-21",
 76 |       "image": "https://ozankasikci.github.io/unity-cheat-sheet/assets/og-image.png",
 77 |       "url": "https://ozankasikci.github.io/unity-cheat-sheet/",
 78 |       "programmingLanguage": ["C#", "Unity"],
 79 |       "about": ["Game Development", "Unity3D", "Design Patterns", "Programming"]
 80 |     }
 81 |   </script>
 82 | </head>
 83 | <body>
 84 |   <div id="app"></div>
 85 |   <a href="https://github.com/ozankasikci/unity-cheat-sheet" class="github-corner" aria-label="View source on GitHub">
 86 |     <svg width="80" height="80" viewBox="0 0 250 250" style="fill:#151513; color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
 87 |       <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
 88 |       <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
 89 |       <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path>
 90 |     </svg>
 91 |   </a>
 92 |   <style>
 93 |     .github-corner:hover .octo-arm {
 94 |       animation: octocat-wave 560ms ease-in-out;
 95 |     }
 96 |     @keyframes octocat-wave {
 97 |       0%, 100% { transform: rotate(0); }
 98 |       20%, 60% { transform: rotate(-25deg); }
 99 |       40%, 80% { transform: rotate(10deg); }
100 |     }
101 |     @media (max-width: 500px) {
102 |       .github-corner:hover .octo-arm {
103 |         animation: none;
104 |       }
105 |       .github-corner .octo-arm {
106 |         animation: octocat-wave 560ms ease-in-out;
107 |       }
108 |     }
109 | 
110 |     /* Edit link styling */
111 |     .markdown-section a[href*="github.com/ozankasikci/unity-cheat-sheet/blob/master"] {
112 |       float: right;
113 |       text-decoration: none;
114 |       color: #42b983;
115 |       font-weight: 600;
116 |       transition: color 0.3s;
117 |       padding-top: 3px;
118 |       margin-top: 10px;
119 |     }
120 |     .markdown-section a[href*="github.com/ozankasikci/unity-cheat-sheet/blob/master"]:hover {
121 |       color: #3aa876;
122 |     }
123 |   </style>
124 |   <script>
125 |     window.$docsify = {
126 |       name: 'Unity Cheat Sheet',
127 |       repo: 'ozankasikci/unity-cheat-sheet',
128 |       loadSidebar: true,
129 |       subMaxLevel: 3,
130 |       auto2top: true,
131 |       search: {
132 |         maxAge: 86400000,
133 |         paths: 'auto',
134 |         placeholder: 'Search Unity Cheat Sheet',
135 |         noData: 'No Results Found',
136 |         depth: 6,
137 |         hideOtherSidebarContent: false,
138 |       },
139 |       pagination: {
140 |         previousText: 'Previous',
141 |         nextText: 'Next',
142 |         crossChapter: true,
143 |         crossChapterText: true,
144 |       },
145 |       copyCode: {
146 |         buttonText: 'Copy',
147 |         errorText: 'Error',
148 |         successText: 'Copied!'
149 |       },
150 |       alias: {
151 |         '/.*/_sidebar.md': '/_sidebar.md'
152 |       },
153 |       plugins: [
154 |         function(hook, vm) {
155 |           hook.beforeEach(function(html) {
156 |             var url = 'https://github.com/ozankasikci/unity-cheat-sheet/blob/master/docs/' + vm.route.file;
157 |             var editHtml = '[:memo: Edit Document on GitHub](' + url + ')\n';
158 |             return html + '\n\n\n' + editHtml;
159 |           });
160 |         }
161 |       ],
162 |       darklightTheme: {
163 |         defaultTheme: 'light',
164 |         siteFont: 'Source Sans Pro, Helvetica Neue',
165 |         codeFontFamily: 'Roboto Mono, Monaco, courier, monospace',
166 |         bodyFontSize: '15px',
167 |         dark: {
168 |           accent: '#42b983',
169 |           background: '#091a28',
170 |           toogleBackground: '#ffffff',
171 |           textColor: '#b4b4b4'
172 |         },
173 |         light: {
174 |           accent: '#42b983',
175 |           background: '#ffffff',
176 |           toogleBackground: '#091a28',
177 |           textColor: '#34495e'
178 |         }
179 |       }
180 |     }
181 |   </script>
182 |   <script src="//cdn.jsdelivr.net/npm/docsify@4"></script>
183 |   <script src="//cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js"></script>
184 |   <script src="//cdn.jsdelivr.net/npm/docsify-pagination/dist/docsify-pagination.min.js"></script>
185 |   <script src="//cdn.jsdelivr.net/npm/docsify-copy-code/dist/docsify-copy-code.min.js"></script>
186 |   <script src="//cdn.jsdelivr.net/npm/prismjs@1/components/prism-csharp.min.js"></script>
187 |   <script src="//cdn.jsdelivr.net/npm/docsify-updated/src/time-updater.min.js"></script>
188 |   <script src="//cdn.jsdelivr.net/npm/docsify-darklight-theme@latest/dist/index.min.js"></script>
189 | </body>
190 | </html> 


--------------------------------------------------------------------------------
/docs/input/keyboard.md:
--------------------------------------------------------------------------------
 1 | # Keyboard
 2 | 
 3 | ```csharp
 4 | // Returns true during the frame the user starts pressing down the key
 5 | if (Input.GetKeyDown(KeyCode.Space)) {
 6 |     Debug.Log("Space key was pressed");
 7 | }
 8 | 
 9 | // Jump is also set to space in Input Manager
10 | if (Input.GetButtonDown("Jump")) {
11 |     Debug.Log("Do something");
12 | }
13 | ```
14 | 
15 | 


--------------------------------------------------------------------------------
/docs/input/mouse.md:
--------------------------------------------------------------------------------
 1 | # Mouse
 2 | 
 3 | ```csharp
 4 | if (Input.GetAxis("Mouse X") < 0) {
 5 |     Debug.Log("Mouse moved left");
 6 | }
 7 | 
 8 | if (Input.GetAxis("Mouse Y") > 0) {
 9 |     Debug.Log("Mouse moved up");
10 | }
11 | 
12 | if (Input.GetMouseButtonDown(0)) {
13 |     Debug.Log("Pressed primary button.");
14 | }
15 | 
16 | if (Input.GetMouseButtonDown(1)) {
17 |     Debug.Log("Pressed secondary button.");
18 | }
19 | 
20 | if (Input.GetMouseButtonDown(2)) {
21 |     Debug.Log("Pressed middle click.");
22 | }
23 | ```
24 | 
25 | 


--------------------------------------------------------------------------------
/docs/input/touch.md:
--------------------------------------------------------------------------------
 1 | # Touch
 2 | 
 3 | ```csharp
 4 | if (Input.touchCount > 0) {
 5 |     touch = Input.GetTouch(0);
 6 | 
 7 |     if (touch.phase == TouchPhase.Began) {
 8 |         Debug.Log("Touch began");
 9 |     }
10 | 
11 |     if (touch.phase == TouchPhase.Moved) {
12 |         Debug.Log("Touch moves");
13 |     }
14 | 
15 |     if (touch.phase == TouchPhase.Ended) {
16 |         Debug.Log("Touch ended");
17 |     }
18 | }
19 | ```
20 | 
21 | 


--------------------------------------------------------------------------------
/docs/movement-rotation/move-object.md:
--------------------------------------------------------------------------------
 1 | # Move Object
 2 | 
 3 | #### Transform.Translate()
 4 | ```csharp
 5 | // Moves the transform in the direction and distance of translation.
 6 | public void Translate(Vector3 translation);
 7 | public void Translate(Vector3 translation, Space relativeTo = Space.Self);
 8 | 
 9 | transform.Translate(Vector3.right * movementSpeed);
10 | ```
11 | 
12 | #### Vector3.MoveTowards()
13 | ```csharp
14 | // Calculate a position between the points specified by current and target
15 | // Moving no farther than the distance specified by maxDistanceDelta
16 | public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta);
17 | 
18 | Vector3 targetPosition;
19 | transform.position = Vector3.MoveTowards(transform.position, targetPosition, Time.deltaTime);
20 | ```
21 | 
22 | #### Vector3.Lerp()
23 | ```csharp
24 | // Linearly interpolates between two points. Results in a smooth transition.
25 | public static Vector3 Lerp(Vector3 startValue, Vector3 endValue, float interpolationRatio);
26 | 
27 | Vector3 targetPosition;
28 | float t = 0;
29 | t += Time.deltaTime * speed;
30 | transform.position = Vector3.Lerp(transform.position, targetPosition, t);
31 | ```
32 | 
33 | #### Vector3.SmoothDamp()
34 | ```csharp
35 | // Gradually changes a vector towards a desired goal over time.
36 | // The vector is smoothed by some spring-damper like function, which will never overshoot.
37 | // The most common use is for smoothing a follow camera.
38 | public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = Mathf.Infinity, float deltaTime = Time.deltaTime);
39 | 
40 | float smoothTime = 1f;
41 | Vector3 velocity;
42 | Vector3 targetPosition = target.TransformPoint(new Vector3(0, 5, -10));
43 | // Smoothly move the camera towards that target position
44 | transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, smoothTime);
45 | ```
46 | 
47 | 


--------------------------------------------------------------------------------
/docs/movement-rotation/rotate-object.md:
--------------------------------------------------------------------------------
 1 | # Rotate Object
 2 | 
 3 | #### Transform.rotation
 4 | ```csharp
 5 | // A Quaternion stores the rotation of the Transform in world space.
 6 | // Quaternions are based on complex numbers and don't suffer from gimbal lock.
 7 | // Unity internally uses Quaternions to represent all rotations.
 8 | 
 9 | transform.rotation = new Quaternion(rotx, roty, rotz, rotw);
10 | ```
11 | 
12 | #### Transform.eulerAngles
13 | ```csharp
14 | // Transform.eulerAngles represents rotation in world space. 
15 | // It is important to understand that although you are providing X, Y, and Z rotation values to describe your rotation
16 | // those values are not stored in the rotation. Instead, the X, Y & Z values are converted to the Quaternion's internal format.
17 | 
18 | transform.eulerAngles = Vector3(rotx, roty, rotz);
19 | ```
20 | 
21 | #### Transform.Rotate()
22 | ```csharp
23 | // Applies rotation around all the given axes.
24 | public void Rotate(Vector3 eulers, Space relativeTo = Space.Self);
25 | public void Rotate(float xAngle, float yAngle, float zAngle, Space relativeTo = Space.Self);
26 | 
27 | transform.Rotate(rotx, roty, rotz);
28 | ```
29 | 
30 | #### Transform.RotateAround()
31 | ```csharp
32 | // Rotates the transform about axis passing through point in world coordinates by angle degrees.
33 | public void RotateAround(Vector3 point, Vector3 axis, float angle);
34 | 
35 | // Spin the object around the target at 20 degrees/second.
36 | Transform target;
37 | transform.RotateAround(target.position, Vector3.up, 20 * Time.deltaTime);
38 | ```
39 | 
40 | #### Transform.LookAt()
41 | ```csharp
42 | // Points the positive 'Z' (forward) side of an object at a position in world space.
43 | public void LookAt(Transform target);
44 | public void LookAt(Transform target, Vector3 worldUp = Vector3.up);
45 | 
46 | // Rotate the object's forward vector to point at the target Transform.
47 | Transform target;
48 | transform.LookAt(target);
49 | 
50 | // Same as above, but setting the worldUp parameter to Vector3.left in this example turns the object on its side.
51 | transform.LookAt(target, Vector3.left);
52 | ```
53 | 
54 | #### Quaternion.LookRotation()
55 | ```csharp
56 | // Creates a rotation with the specified forward and upwards directions.
57 | public static Quaternion LookRotation(Vector3 forward, Vector3 upwards = Vector3.up);
58 | 
59 | // The following code rotates the object towards a target object.
60 | Vector3 direction = target.position - transform.position;
61 | Quaternion rotation = Quaternion.LookRotation(direction);
62 | transform.rotation = rotation;
63 | ```
64 | 
65 | #### Quaternion.FromToRotation()
66 | ```csharp
67 | // Creates a rotation (a Quaternion) which rotates from fromDirection to toDirection.
68 | public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection);
69 | 
70 | // Sets the rotation so that the transform's y-axis goes along the z-axis.
71 | transform.rotation = Quaternion.FromToRotation(Vector3.up, transform.forward);
72 | ```
73 | 
74 | #### Quaternion.ToAngleAxis()
75 | ```csharp
76 | // Converts a rotation to angle-axis representation (angles in degrees).
77 | // In other words, extracts the angle as well as the axis that this quaternion represents.
78 | public void ToAngleAxis(out float angle, out Vector3 axis);
79 | 
80 | // Extracts the angle - axis rotation from the transform rotation
81 | float angle = 0.0f;
82 | Vector3 axis = Vector3.zero;
83 | transform.rotation.ToAngleAxis(out angle, out axis);
84 | ```
85 | 
86 | 


--------------------------------------------------------------------------------
/docs/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "unity-cheat-sheet-docsify",
 3 |   "version": "1.0.0",
 4 |   "description": "Unity Cheat Sheet Documentation using Docsify",
 5 |   "scripts": {
 6 |     "start": "docsify serve .",
 7 |     "generate": "ts-node scripts/generate-docs.ts"
 8 |   },
 9 |   "devDependencies": {
10 |     "@types/node": "^20.10.6",
11 |     "docsify-cli": "^4.4.4",
12 |     "ts-node": "^10.9.2",
13 |     "typescript": "^5.3.3"
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/docs/physics/ignore-collision.md:
--------------------------------------------------------------------------------
 1 | # Ignore Collision
 2 | 
 3 | ```csharp
 4 | // Makes the collision detection system ignore all collisions between collider1 and collider2.
 5 | public static void IgnoreCollision(Collider collider1, Collider collider2, bool ignore = true);
 6 | 
 7 | // Here we're disabling the collision detection between the colliders of ally and bullet objects.
 8 | Transform bullet;
 9 | Transform ally;
10 | Physics.IgnoreCollision(bullet.GetComponent<Collider>(), ally.GetComponent<Collider>());
11 | ```
12 | 
13 | 


--------------------------------------------------------------------------------
/docs/physics/raycast.md:
--------------------------------------------------------------------------------
 1 | # Raycast
 2 | 
 3 | ```csharp
 4 | void FixedUpdate() {
 5 |     // Bit shift the index of the layer (8) to get a bit mask
 6 |     int layerMask = 1 << 8;
 7 | 
 8 |     // This would cast rays only against colliders in layer 8.
 9 |     // But instead we want to collide against everything except layer 8. The ~ operator does this, it inverts a bitmask.
10 |     layerMask = ~layerMask;
11 | 
12 |     RaycastHit hit;
13 |     // Does the ray intersect any objects excluding the player layer
14 |     if (Physics.Raycast(transform.position, transform.TransformDirection(Vector3.forward), out hit, Mathf.Infinity, layerMask)) {
15 |         Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * hit.distance, Color.yellow);
16 |         Debug.Log("Did Hit");
17 |     }
18 | }
19 | ```
20 | 
21 | 


--------------------------------------------------------------------------------
/docs/practical-use-cases/check-if-object-is-on-the-ground.md:
--------------------------------------------------------------------------------
 1 | # Check if object is on the ground
 2 | 
 3 | ```csharp
 4 | RaycastHit hit;
 5 | 
 6 | // Unlike this example, most of the time you should pass a layerMask as the last option to hit only to the ground
 7 | if (Physics.Raycast(transform.position, Vector3.down, out hit, 0.5f)) {
 8 |    Debug.log("Hit something below!");
 9 | }
10 | ```
11 | 
12 | 


--------------------------------------------------------------------------------
/docs/practical-use-cases/get-the-transform-of-a-body-bone.md:
--------------------------------------------------------------------------------
1 | # Get the transform of a Body Bone
2 | 
3 | ```csharp
4 | Animator animator;
5 | 
6 | Transform transform = animator.GetBoneTransform(HumanBodyBones.Head);
7 | ```
8 | 
9 | 


--------------------------------------------------------------------------------
/docs/practical-use-cases/load-next-scene.md:
--------------------------------------------------------------------------------
 1 | # Load next scene
 2 | 
 3 | ```csharp
 4 | var nextSceneToLoad = SceneManager.GetActiveScene().buildIndex + 1;
 5 | var totalSceneCount = SceneManager.sceneCountInBuildSettings;
 6 | 
 7 | if (nextSceneToLoad < totalSceneCount) {
 8 |   SceneManager.LoadScene(nextSceneToLoad);
 9 | }
10 | ```
11 | 
12 | 


--------------------------------------------------------------------------------
/docs/practical-use-cases/make-object-look-at-the-camera.md:
--------------------------------------------------------------------------------
1 | # Make object look at the camera
2 | 
3 | ```csharp
4 | var camPosition = Camera.main.transform.position;
5 | 
6 | transform.rotation = Quaternion.LookRotation(transform.position - camPosition);
7 | ```
8 | 
9 | 


--------------------------------------------------------------------------------
/docs/scripting/asyncawait.md:
--------------------------------------------------------------------------------
  1 | # Async/Await
  2 | 
  3 | Async/await is a programming pattern that simplifies asynchronous programming. It allows you to write asynchronous code that looks and behaves like synchronous code. This is particularly useful for operations that might take time, such as:
  4 | - Loading resources
  5 | - Network requests
  6 | - File operations
  7 | - Scene loading
  8 | 
  9 | #### Basic Structure
 10 | ```csharp
 11 | using UnityEngine;
 12 | using System.Threading.Tasks;
 13 | using System;
 14 | 
 15 | public class AsyncAwaitExample : MonoBehaviour
 16 | {
 17 |     // Basic async/await structure in Unity
 18 |     private async void Start()
 19 |     {
 20 |         Debug.Log("Starting async operation");
 21 |         await Task.Delay(1000); // Wait for 1 second
 22 |         Debug.Log("Async operation completed");
 23 |     }
 24 | 
 25 |     // IMPORTANT: Unity's Update loop and MonoBehaviour methods must be void
 26 |     // They cannot be async Task
 27 |     private void Update() { }      // Correct
 28 |     // private async Task Update() {} // Wrong!
 29 | }
 30 | ```
 31 | 
 32 | #### Loading Resources
 33 | ```csharp
 34 | // Loading resources asynchronously with progress tracking
 35 | private async Task<Texture2D> LoadTextureAsync()
 36 | {
 37 |     var resourcePath = "Textures/MyTexture";
 38 |     var request = Resources.LoadAsync<Texture2D>(resourcePath);
 39 |     
 40 |     while (!request.isDone)
 41 |     {
 42 |         // Report progress
 43 |         Debug.Log($"Loading: {request.progress * 100}%");
 44 |         await Task.Yield(); // Let other operations continue
 45 |     }
 46 | 
 47 |     return request.asset as Texture2D;
 48 | }
 49 | ```
 50 | 
 51 | #### Web Requests
 52 | ```csharp
 53 | // Making web requests with progress tracking
 54 | private async Task<string> FetchDataAsync(string url)
 55 | {
 56 |     using var request = UnityWebRequest.Get(url);
 57 |     var operation = request.SendWebRequest();
 58 | 
 59 |     while (!operation.isDone)
 60 |     {
 61 |         Debug.Log($"Downloading: {request.downloadProgress * 100}%");
 62 |         await Task.Yield();
 63 |     }
 64 | 
 65 |     if (request.result != UnityWebRequest.Result.Success)
 66 |         throw new Exception($"Failed to fetch data: {request.error}");
 67 | 
 68 |     return request.downloadHandler.text;
 69 | }
 70 | ```
 71 | 
 72 | #### Scene Loading
 73 | ```csharp
 74 | // Loading scenes asynchronously with progress tracking
 75 | private async Task LoadSceneAsync(string sceneName)
 76 | {
 77 |     var operation = SceneManager.LoadSceneAsync(sceneName);
 78 |     operation.allowSceneActivation = false; // Don't activate immediately
 79 | 
 80 |     while (operation.progress < 0.9f) // 0.9 is the progress before activation
 81 |     {
 82 |         Debug.Log($"Loading scene: {operation.progress * 100}%");
 83 |         await Task.Yield();
 84 |     }
 85 | 
 86 |     Debug.Log("Scene ready to activate");
 87 |     operation.allowSceneActivation = true;
 88 | }
 89 | ```
 90 | 
 91 | #### Parallel Operations
 92 | ```csharp
 93 | // Running multiple async operations in parallel
 94 | private async Task LoadGameAssetsAsync()
 95 | {
 96 |     try
 97 |     {
 98 |         // Start multiple operations simultaneously
 99 |         var textureTask = LoadTextureAsync();
100 |         var dataTask = FetchDataAsync("https://api.example.com/gamedata");
101 |         var sceneTask = LoadSceneAsync("Level1");
102 | 
103 |         // Wait for all tasks to complete
104 |         await Task.WhenAll(textureTask, dataTask, sceneTask);
105 |         
106 |         // All assets are now loaded
107 |         Debug.Log("All assets loaded successfully");
108 |     }
109 |     catch (Exception e)
110 |     {
111 |         Debug.LogError($"Failed to load assets: {e.Message}");
112 |     }
113 | }
114 | ```
115 | 
116 | #### Timeout Handling
117 | ```csharp
118 | // Implementing timeout for async operations
119 | private async Task<T> WithTimeout<T>(Task<T> task, TimeSpan timeout)
120 | {
121 |     var timeoutTask = Task.Delay(timeout);
122 |     var completedTask = await Task.WhenAny(task, timeoutTask);
123 |     
124 |     if (completedTask == timeoutTask)
125 |         throw new TimeoutException("Operation timed out");
126 |             
127 |     return await task; // Unwrap the result or propagate the exception
128 | }
129 | 
130 | // Complete example using timeout handling
131 | private async Task InitializeGameAsync()
132 | {
133 |     try
134 |     {
135 |         // Show loading screen
136 |         ShowLoadingUI();
137 | 
138 |         // Start multiple loading operations with timeout
139 |         var loadingTask = Task.WhenAll(
140 |             LoadTextureAsync(),
141 |             FetchDataAsync("https://api.example.com/gamedata"),
142 |             LoadSceneAsync("MainLevel")
143 |         );
144 | 
145 |         // Wait for all operations with a 30-second timeout
146 |         await WithTimeout(loadingTask, TimeSpan.FromSeconds(30));
147 | 
148 |         // Hide loading screen
149 |         HideLoadingUI();
150 |         Debug.Log("Game initialized successfully");
151 |     }
152 |     catch (TimeoutException)
153 |     {
154 |         Debug.LogError("Game initialization timed out");
155 |         ShowRetryButton();
156 |     }
157 |     catch (Exception e)
158 |     {
159 |         Debug.LogError($"Failed to initialize game: {e.Message}");
160 |         ShowErrorUI();
161 |     }
162 | }
163 | ```
164 | 
165 | #### Best Practices
166 | When using async/await in Unity, follow these best practices:
167 | 
168 | 1. Always handle exceptions in async methods
169 | 2. Use Task.Yield() instead of Task.Delay() for frame-by-frame operations
170 | 3. Remember that async void should only be used for event handlers and MonoBehaviour methods
171 | 4. Use CancellationToken when possible to support cancellation
172 | 5. Implement timeout handling for network operations
173 | 6. Don't block the main thread with .Result or .Wait()
174 | 7. Use Task.WhenAll for parallel operations
175 | 
176 | 


--------------------------------------------------------------------------------
/docs/scripting/coroutines.md:
--------------------------------------------------------------------------------
  1 | # Coroutines
  2 | 
  3 | Coroutines in Unity are a powerful feature that allows you to pause the execution of a function and resume it later. This is particularly useful for tasks that need to be spread over several frames, such as animations, waiting for a condition to be met, or handling asynchronous operations.
  4 | 
  5 | #### Basic Coroutine Example
  6 | ```csharp
  7 | using UnityEngine;
  8 | using System.Collections;
  9 | 
 10 | public class CoroutineExample : MonoBehaviour {
 11 |     void Start() {
 12 |         // Start the coroutine
 13 |         StartCoroutine(ExampleCoroutine());
 14 |     }
 15 | 
 16 |     IEnumerator ExampleCoroutine() {
 17 |         Debug.Log("Coroutine started");
 18 | 
 19 |         // Wait for 2 seconds
 20 |         yield return new WaitForSeconds(2);
 21 | 
 22 |         Debug.Log("Coroutine resumed after 2 seconds");
 23 |     }
 24 | }
 25 | ```
 26 | 
 27 | #### Using Coroutines for Repeated Actions
 28 | Coroutines can be used to perform repeated actions with a delay between each iteration.
 29 | 
 30 | ```csharp
 31 | IEnumerator RepeatActionCoroutine() {
 32 |     while (true) {
 33 |         Debug.Log("Action performed");
 34 |         
 35 |         // Wait for 1 second before repeating
 36 |         yield return new WaitForSeconds(1);
 37 |     }
 38 | }
 39 | 
 40 | // Start the coroutine
 41 | StartCoroutine(RepeatActionCoroutine());
 42 | ```
 43 | 
 44 | #### Waiting for a Condition
 45 | Coroutines can also wait for a condition to be true before continuing execution.
 46 | 
 47 | ```csharp
 48 | IEnumerator WaitForConditionCoroutine() {
 49 |     Debug.Log("Waiting for condition...");
 50 | 
 51 |     // Wait until the condition is met
 52 |     yield return new WaitUntil(() => SomeConditionIsTrue());
 53 | 
 54 |     Debug.Log("Condition met, resuming coroutine");
 55 | }
 56 | 
 57 | bool SomeConditionIsTrue() {
 58 |     // Replace with your actual condition
 59 |     return Time.time > 5;
 60 | }
 61 | 
 62 | // Start the coroutine
 63 | StartCoroutine(WaitForConditionCoroutine());
 64 | ```
 65 | 
 66 | #### Using Coroutines with Unity Events
 67 | Coroutines can be used to handle events over time, such as fading out a UI element.
 68 | 
 69 | ```csharp
 70 | IEnumerator FadeOutCoroutine(CanvasGroup canvasGroup, float duration) {
 71 |     float startAlpha = canvasGroup.alpha;
 72 |     float rate = 1.0f / duration;
 73 |     float progress = 0.0f;
 74 | 
 75 |     while (progress < 1.0f) {
 76 |         canvasGroup.alpha = Mathf.Lerp(startAlpha, 0, progress);
 77 |         progress += rate * Time.deltaTime;
 78 | 
 79 |         yield return null; // Wait for the next frame
 80 |     }
 81 | 
 82 |     canvasGroup.alpha = 0;
 83 | }
 84 | 
 85 | // Usage
 86 | CanvasGroup myCanvasGroup = GetComponent<CanvasGroup>();
 87 | StartCoroutine(FadeOutCoroutine(myCanvasGroup, 2.0f));
 88 | ```
 89 | 
 90 | #### Stopping Coroutines
 91 | You can stop a coroutine using `StopCoroutine()` or `StopAllCoroutines()`.
 92 | 
 93 | ```csharp
 94 | Coroutine myCoroutine;
 95 | 
 96 | void Start() {
 97 |     myCoroutine = StartCoroutine(ExampleCoroutine());
 98 | }
 99 | 
100 | void StopMyCoroutine() {
101 |     if (myCoroutine != null) {
102 |         StopCoroutine(myCoroutine);
103 |     }
104 | }
105 | 
106 | void StopAllMyCoroutines() {
107 |     StopAllCoroutines();
108 | }
109 | ```
110 | 
111 | #### Important Notes
112 | - Coroutines are not threads. They run on the main thread and are subject to the same performance constraints.
113 | - Use `yield return null;` to wait for the next frame.
114 | - Use `yield return new WaitForSeconds(seconds);` to wait for a specific amount of time.
115 | - Use `yield return new WaitUntil(() => condition);` to wait until a condition is true.
116 | - Coroutines can be nested, and you can yield return other coroutines.
117 | 
118 | 


--------------------------------------------------------------------------------
/docs/scripting/custom-editor-scripts.md:
--------------------------------------------------------------------------------
 1 | # Custom Editor Scripts
 2 | 
 3 | ```csharp
 4 | // Custom Editor scripts allow you to create custom inspectors and windows in the Unity Editor.
 5 | using UnityEditor;
 6 | using UnityEngine;
 7 | 
 8 | [CustomEditor(typeof(MyComponent))]
 9 | public class MyComponentEditor : Editor {
10 |     public override void OnInspectorGUI() {
11 |         DrawDefaultInspector();
12 | 
13 |         MyComponent myComponent = (MyComponent)target;
14 |         if (GUILayout.Button("Do Something")) {
15 |             myComponent.DoSomething();
16 |         }
17 |     }
18 | }
19 | ```
20 | 
21 | 


--------------------------------------------------------------------------------
/docs/scripting/event-systems.md:
--------------------------------------------------------------------------------
 1 | # Event Systems
 2 | 
 3 | Unity provides several ways to handle events in your games. Here are the main approaches:
 4 | 
 5 | #### UnityEvents
 6 | UnityEvents are serializable events that can be configured in the Inspector and used in scripts.
 7 | 
 8 | ```csharp
 9 | using UnityEngine;
10 | using UnityEngine.Events;
11 | 
12 | // Basic UnityEvent
13 | public class BasicEventExample : MonoBehaviour {
14 |     // This will show up in the inspector
15 |     public UnityEvent onGameStart;
16 |     
17 |     void Start() {
18 |         // Invoke the event
19 |         onGameStart?.Invoke();
20 |     }
21 | }
22 | 
23 | // UnityEvent with parameters
24 | [System.Serializable]
25 | public class ScoreEvent : UnityEvent<int> { }
26 | 
27 | public class ParameterizedEventExample : MonoBehaviour {
28 |     public ScoreEvent onScoreChanged;
29 |     private int score = 0;
30 | 
31 |     public void AddScore(int points) {
32 |         score += points;
33 |         onScoreChanged?.Invoke(score);
34 |     }
35 | }
36 | ```
37 | 
38 | #### C# Events and Delegates
39 | Traditional C# events provide a more code-based approach to event handling.
40 | 
41 | 
42 | Delegates are type-safe function pointers, and events are a way to broadcast messages to multiple listeners.
43 | 
44 | ```csharp
45 | public class GameEvents : MonoBehaviour {
46 |     // Delegate definition
47 |     public delegate void GameStateHandler();
48 |     public delegate void ScoreHandler(int newScore);
49 | 
50 |     // Event declaration
51 |     public static event GameStateHandler OnGameStart;
52 |     public static event GameStateHandler OnGameOver;
53 |     public static event ScoreHandler OnScoreChanged;
54 | 
55 |     // Methods to trigger events
56 |     public static void TriggerGameStart() {
57 |         OnGameStart?.Invoke();
58 |     }
59 | 
60 |     public static void TriggerGameOver() {
61 |         OnGameOver?.Invoke();
62 |     }
63 | 
64 |     public static void TriggerScoreChanged(int newScore) {
65 |         OnScoreChanged?.Invoke(newScore);
66 |     }
67 | }
68 | 
69 | // Example usage in another class
70 | public class Player : MonoBehaviour {
71 |     void OnEnable() {
72 |         // Subscribe to events
73 |         GameEvents.OnGameStart += HandleGameStart;
74 |         GameEvents.OnGameOver += HandleGameOver;
75 |     }
76 | 
77 |     void OnDisable() {
78 |         // Unsubscribe from events
79 |         GameEvents.OnGameStart -= HandleGameStart;
80 |         GameEvents.OnGameOver -= HandleGameOver;
81 |     }
82 | 
83 |     private void HandleGameStart() {
84 |         Debug.Log("Game Started!");
85 |     }
86 | 
87 |     private void HandleGameOver() {
88 |         Debug.Log("Game Over!");
89 |     }
90 | }
91 | ```
92 | 
93 | 


--------------------------------------------------------------------------------
/docs/scripting/scriptable-objects.md:
--------------------------------------------------------------------------------
 1 | # Scriptable Objects
 2 | 
 3 | ```csharp
 4 | // ScriptableObjects are data containers that you can use to save large amounts of data, independent of class instances.
 5 | [CreateAssetMenu(fileName = "NewData", menuName = "ScriptableObjects/Data")]
 6 | public class Data : ScriptableObject {
 7 |     public string dataName;
 8 |     public int dataValue;
 9 | }
10 | 
11 | // Usage
12 | Data myData = ScriptableObject.CreateInstance<Data>();
13 | ```
14 | 
15 | 


--------------------------------------------------------------------------------
/docs/scripts/generate-docs.ts:
--------------------------------------------------------------------------------
  1 | import * as fs from 'fs';
  2 | import * as path from 'path';
  3 | 
  4 | interface Section {
  5 |     title: string;
  6 |     content: string;
  7 |     slug: string;
  8 |     subsections: Section[];
  9 |     link?: string;
 10 | }
 11 | 
 12 | const GITHUB_REPO_URL = 'https://github.com/ozankasikci/unity-cheat-sheet/tree/master';
 13 | 
 14 | function slugify(text: string): string {
 15 |     // Handle URLs in the text
 16 |     if (text.includes('http')) {
 17 |         return text
 18 |             .toLowerCase()
 19 |             .replace(/[^a-z0-9-]+/g, '-')
 20 |             .replace(/(^-|-$)/g, '');
 21 |     }
 22 | 
 23 |     // Handle normal text - preserve hyphens and spaces for header IDs
 24 |     return text
 25 |         .toLowerCase()
 26 |         .replace(/[^a-z0-9\s-]+/g, '') // Remove special chars except spaces and hyphens
 27 |         .replace(/\s+/g, '-') // Replace spaces with hyphens
 28 |         .replace(/-+/g, '-') // Replace multiple hyphens with single hyphen
 29 |         .replace(/(^-|-$)/g, ''); // Remove leading/trailing hyphens
 30 | }
 31 | 
 32 | function extractSectionContent(content: string, section: Section): void {
 33 |     const lines = content.split('\n');
 34 |     let inSection = false;
 35 |     let sectionContent: string[] = [];
 36 |     let inCodeBlock = false;
 37 | 
 38 |     for (let i = 0; i < lines.length; i++) {
 39 |         const line = lines[i];
 40 |         
 41 |         // Handle code blocks
 42 |         if (line.startsWith('```')) {
 43 |             inCodeBlock = !inCodeBlock;
 44 |             if (inSection) {
 45 |                 sectionContent.push(line);
 46 |             }
 47 |             continue;
 48 |         }
 49 | 
 50 |         if (!inCodeBlock) {
 51 |             // Check for section headers
 52 |             const headerMatch = line.match(/^(#{2,4})\s+(.+)$/);
 53 |             if (headerMatch) {
 54 |                 const level = headerMatch[1].length;
 55 |                 const title = headerMatch[2].replace(/\[(.*?)\]\(.*?\)/, '$1').trim();
 56 | 
 57 |                 if (title === section.title) {
 58 |                     inSection = true;
 59 |                     continue;
 60 |                 } else if (inSection && level <= 3) {
 61 |                     // Stop when we hit another section of same or higher level
 62 |                     break;
 63 |                 }
 64 |             }
 65 |         }
 66 | 
 67 |         if (inSection) {
 68 |             sectionContent.push(line);
 69 |         }
 70 |     }
 71 | 
 72 |     section.content = sectionContent.join('\n').trim();
 73 | }
 74 | 
 75 | function parseMarkdownTree(content: string): Section[] {
 76 |     const lines = content.split('\n');
 77 |     const sections: Section[] = [];
 78 |     let currentSection: Section | null = null;
 79 |     let currentSubsection: Section | null = null;
 80 |     let inTableOfContents = false;
 81 | 
 82 |     // First pass: Parse table of contents for structure
 83 |     for (const line of lines) {
 84 |         if (line.trim() === '## Table of Contents') {
 85 |             inTableOfContents = true;
 86 |             continue;
 87 |         }
 88 | 
 89 |         if (inTableOfContents) {
 90 |             if (line.startsWith('##')) {
 91 |                 inTableOfContents = false;
 92 |                 continue;
 93 |             }
 94 | 
 95 |             if (line.trim().startsWith('-')) {
 96 |                 const indentLevel = line.search(/[^ ]/) / 2;
 97 |                 const match = line.match(/- \[(.*?)\]\((.*?)\)/) || line.match(/- (.*)/);
 98 |                 
 99 |                 if (match) {
100 |                     const title = match[1];
101 |                     const link = match[2];
102 |                     
103 |                     const section: Section = {
104 |                         title,
105 |                         content: '',
106 |                         slug: slugify(title),
107 |                         subsections: [],
108 |                         link
109 |                     };
110 | 
111 |                     if (indentLevel === 0) {
112 |                         sections.push(section);
113 |                         currentSection = section;
114 |                         currentSubsection = null;
115 |                     } else if (indentLevel === 1 && currentSection) {
116 |                         currentSection.subsections.push(section);
117 |                         currentSubsection = section;
118 |                     }
119 |                 }
120 |             }
121 |         }
122 |     }
123 | 
124 |     // Second pass: Extract content for each section
125 |     sections.forEach(section => {
126 |         extractSectionContent(content, section);
127 |         section.subsections.forEach(subsection => {
128 |             extractSectionContent(content, subsection);
129 |         });
130 |     });
131 | 
132 |     return sections;
133 | }
134 | 
135 | function escapeRegExp(string: string): string {
136 |     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
137 | }
138 | 
139 | function findContentForSection(section: Section, fullContent: string): void {
140 |     // Try different heading levels
141 |     let sectionStart = -1;
142 |     let headingLevel = '';
143 |     
144 |     // Try different heading levels (###, ##, ####) until we find the section
145 |     for (const level of ['###', '##', '####']) {
146 |         sectionStart = fullContent.indexOf(`${level} ${section.title}`);
147 |         if (sectionStart !== -1) {
148 |             headingLevel = level;
149 |             break;
150 |         }
151 |     }
152 |     
153 |     if (sectionStart === -1) return;
154 | 
155 |     // Find the next heading of same or higher level
156 |     let sectionEnd = fullContent.length;
157 |     const possibleEndings = fullContent.substring(sectionStart + 1).match(/^#{1,4} /gm);
158 |     
159 |     if (possibleEndings) {
160 |         const nextHeadingIndex = fullContent.indexOf(possibleEndings[0], sectionStart + 1);
161 |         if (nextHeadingIndex !== -1) {
162 |             sectionEnd = nextHeadingIndex;
163 |         }
164 |     }
165 | 
166 |     const sectionContent = fullContent.substring(sectionStart, sectionEnd).trim();
167 |     
168 |     // Extract content after the heading
169 |     const contentAfterHeading = sectionContent.substring(headingLevel.length + section.title.length + 1).trim();
170 |     
171 |     // If there's content, set it and adjust pattern links
172 |     if (contentAfterHeading) {
173 |         section.content = adjustPatternLinks(contentAfterHeading);
174 |     }
175 | 
176 |     // Recursively process subsections
177 |     section.subsections.forEach(subsection => {
178 |         findContentForSection(subsection, fullContent);
179 |         // Adjust pattern links in subsection content
180 |         if (subsection.content) {
181 |             subsection.content = adjustPatternLinks(subsection.content);
182 |         }
183 |     });
184 | }
185 | 
186 | function adjustPatternLinks(content: string): string {
187 |     // Replace pattern implementation links to point to GitHub repo
188 |     return content.replace(
189 |         /\[([^\]]+)\]\(Patterns\/([^)]+)\)/g,
190 |         (match, text, path) => {
191 |             return `[${text}](${GITHUB_REPO_URL}/Patterns/${path})`;
192 |         }
193 |     );
194 | }
195 | 
196 | function contentHasChanged(existingContent: string, newContent: string): boolean {
197 |     // Normalize line endings and whitespace to ensure consistent comparison
198 |     const normalizeContent = (content: string) => 
199 |         content.replace(/\r\n/g, '\n').trim();
200 |     
201 |     return normalizeContent(existingContent) !== normalizeContent(newContent);
202 | }
203 | 
204 | function writeFileIfChanged(filePath: string, newContent: string): void {
205 |     try {
206 |         // Check if file exists and read its content
207 |         let shouldWrite = true;
208 |         if (fs.existsSync(filePath)) {
209 |             const existingContent = fs.readFileSync(filePath, 'utf8');
210 |             shouldWrite = contentHasChanged(existingContent, newContent);
211 |         }
212 | 
213 |         // Only write if content has changed or file doesn't exist
214 |         if (shouldWrite) {
215 |             fs.writeFileSync(filePath, newContent);
216 |         }
217 |     } catch (error) {
218 |         console.error(`Error handling file ${filePath}:`, error);
219 |     }
220 | }
221 | 
222 | function generateDocsifyFiles(sections: Section[]): void {
223 |     // Create the base docs directory
224 |     const baseDir = path.join(__dirname, '..');
225 |     
226 |     // Generate section files
227 |     sections.forEach(section => {
228 |         const sectionDir = path.join(baseDir, section.slug);
229 |         if (!fs.existsSync(sectionDir)) {
230 |             fs.mkdirSync(sectionDir, { recursive: true });
231 |         }
232 | 
233 |         section.subsections.forEach(subsection => {
234 |             // Generate content for the subsection
235 |             let content = `# ${subsection.title}\n\n`;
236 |             
237 |             if (subsection.content) {
238 |                 // Adjust pattern links to point to GitHub
239 |                 content += `${adjustPatternLinks(subsection.content)}\n\n`;
240 |             }
241 | 
242 |             const fileName = `${subsection.slug}.md`;
243 |             writeFileIfChanged(path.join(sectionDir, fileName), content);
244 |         });
245 |     });
246 | 
247 |     // Generate _sidebar.md in the base directory
248 |     const sidebarContent = generateSidebar(sections);
249 |     writeFileIfChanged(path.join(baseDir, '_sidebar.md'), sidebarContent);
250 | 
251 |     // Generate main README.md in the base directory
252 |     const mainReadme = generateMainReadme(sections);
253 |     writeFileIfChanged(path.join(baseDir, 'README.md'), mainReadme);
254 | }
255 | 
256 | function generateSectionContent(section: Section): string {
257 |     let content = `# ${section.title}\n\n`;
258 |     
259 |     if (section.content) {
260 |         content += `${section.content}\n\n`;
261 |     }
262 | 
263 |     // For each subsection, add its content and then its own subsections
264 |     section.subsections.forEach(subsection => {
265 |         // For level 4 headings (like Transform.LookAt()), we want them as subsections
266 |         content += `## ${subsection.title}\n\n`;
267 |         if (subsection.content) {
268 |             content += `${subsection.content}\n\n`;
269 |         }
270 |     });
271 | 
272 |     return content;
273 | }
274 | 
275 | function generateSidebar(sections: Section[]): string {
276 |     let content = '<!-- docs/_sidebar.md -->\n\n';
277 |     content += '* [Home](README.md)\n\n';
278 | 
279 |     sections.forEach(section => {
280 |         content += `* ${section.title}\n`;
281 |         section.subsections.forEach(subsection => {
282 |             content += `  * [${subsection.title}](${section.slug}/${subsection.slug}.md)\n`;
283 |             
284 |             // Extract level 4 headings from the content
285 |             const headings = subsection.content.match(/^####\s+(.+)$/gm);
286 |             if (headings) {
287 |                 headings.forEach(heading => {
288 |                     const title = heading.replace('#### ', '');
289 |                     // Create anchor that matches the actual header ID
290 |                     const anchor = slugify(title);
291 |                     content += `    * [${title}](${section.slug}/${subsection.slug}.md#${anchor})\n`;
292 |                 });
293 |             }
294 |         });
295 |     });
296 | 
297 |     return content;
298 | }
299 | 
300 | function generateMainReadme(sections: Section[]): string {
301 |     let content = '# Unity Cheat Sheet\n\n';
302 |     content += 'A comprehensive guide to Unity development patterns and practices.\n\n';
303 |     content += '## Table of Contents\n\n';
304 | 
305 |     sections.forEach(section => {
306 |         content += `### ${section.title}\n\n`;
307 |         section.subsections.forEach(subsection => {
308 |             content += `- [${subsection.title}](${section.slug}/${subsection.slug}.md)\n`;
309 |         });
310 |         content += '\n';
311 |     });
312 | 
313 |     return content;
314 | }
315 | 
316 | // Main execution
317 | const readmePath = path.join(__dirname, '..', '..', 'README.md');
318 | const content = fs.readFileSync(readmePath, 'utf-8');
319 | const sections = parseMarkdownTree(content);
320 | 
321 | // Find content for each section from the full README
322 | sections.forEach(section => {
323 |     findContentForSection(section, content);
324 | });
325 | 
326 | // Generate Docsify files
327 | generateDocsifyFiles(sections); 


--------------------------------------------------------------------------------
/docs/shortcuts/hierarchy-management.md:
--------------------------------------------------------------------------------
 1 | # Hierarchy Management
 2 | 
 3 | ```
 4 | CTRL/CMD + SHIFT + N - Create empty GameObject
 5 | ALT + SHIFT + N - Create empty child GameObject
 6 | CTRL/CMD + D - Duplicate selected
 7 | CTRL/CMD + ALT + F - Frame selected object
 8 | F2 - Rename selected
 9 | Delete - Delete selected
10 | ```
11 | 
12 | 


--------------------------------------------------------------------------------
/docs/shortcuts/layout.md:
--------------------------------------------------------------------------------
1 | # Layout
2 | 
3 | ```
4 | CTRL/CMD + 1-5 - Switch between layouts
5 | SHIFT + Space - Toggle maximize current window
6 | ```
7 | 
8 | 


--------------------------------------------------------------------------------
/docs/shortcuts/scene-view-editing.md:
--------------------------------------------------------------------------------
 1 | # Scene View Editing
 2 | 
 3 | ```
 4 | Q - Pan tool
 5 | W - Move tool
 6 | E - Rotate tool
 7 | R - Scale tool
 8 | T - Rect tool
 9 | Y - Transform tool
10 | 
11 | CTRL/CMD + Z - Undo
12 | CTRL/CMD + Y - Redo
13 | CTRL/CMD + S - Save
14 | CTRL/CMD + P - Play/Stop
15 | CTRL/CMD + SHIFT + P - Pause
16 | ```
17 | 
18 | 


--------------------------------------------------------------------------------
/docs/shortcuts/scene-view-navigation.md:
--------------------------------------------------------------------------------
 1 | # Scene View Navigation
 2 | 
 3 | ```
 4 | Alt + Left Click - Orbit around scene view pivot
 5 | Alt + Right Click - Zoom in/out
 6 | Middle Mouse - Orbit
 7 | Middle Mouse + Alt - Zoom
 8 | F - Focus on selected object
 9 | CTRL/CMD + ALT + F - Frame selected
10 | Hold Right Click - Free look (FPS style)
11 | ```
12 | 
13 | 


--------------------------------------------------------------------------------
/docs/tbd-to-be-documented/input.md:
--------------------------------------------------------------------------------
1 | # Input
2 | 
3 | 


--------------------------------------------------------------------------------
/docs/tbd-to-be-documented/scripting.md:
--------------------------------------------------------------------------------
1 | # Scripting
2 | 
3 | 


--------------------------------------------------------------------------------
/docs/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "ES2020",
 4 |     "module": "commonjs",
 5 |     "strict": true,
 6 |     "esModuleInterop": true,
 7 |     "skipLibCheck": true,
 8 |     "forceConsistentCasingInFileNames": true,
 9 |     "outDir": "./dist",
10 |     "rootDir": "."
11 |   },
12 |   "include": ["scripts/**/*"],
13 |   "exclude": ["node_modules", "docs"]
14 | } 


--------------------------------------------------------------------------------
/docs/ui/button.md:
--------------------------------------------------------------------------------
 1 | # Button
 2 | 
 3 | ```csharp
 4 | // Button is used to handle user clicks and interactions.
 5 | // Attach this script to a Button component to respond to button clicks.
 6 | 
 7 | using UnityEngine.UI;
 8 | 
 9 | Button myButton = GetComponent<Button>();
10 | myButton.onClick.AddListener(MyButtonClickHandler);
11 | 
12 | void MyButtonClickHandler() {
13 |     Debug.Log("Button Clicked!");
14 | }
15 | ```
16 | 
17 | 


--------------------------------------------------------------------------------
/docs/ui/slider.md:
--------------------------------------------------------------------------------
 1 | # Slider
 2 | 
 3 | ```csharp
 4 | // Slider is used for selecting a value within a range.
 5 | // Attach this script to a Slider component to respond to value changes.
 6 | 
 7 | using UnityEngine.UI;
 8 | 
 9 | Slider mySlider = GetComponent<Slider>();
10 | mySlider.onValueChanged.AddListener(MySliderValueChangedHandler);
11 | 
12 | void MySliderValueChangedHandler(float value) {
13 |     Debug.Log("Slider Value: " + value);
14 | }
15 | ```
16 | 
17 | 


--------------------------------------------------------------------------------