Visual effect examples (fire, smoke, sparkle) in Unity - Step-by-Step Execution

Concept Flow - Visual effect examples (fire, smoke, sparkle)

Start Unity Scene

↓

Create Particle System

↓

Choose Effect Type

↓

Fire

↓

Set Colors, Size, Speed

↓

Play Effect in Scene

↓

Effect Visible to Player

↓

Loop or Stop Based on Settings

This flow shows how Unity creates visual effects by starting a particle system, selecting the effect type, setting properties, and playing it in the scene.

Execution Sample

Unity

using UnityEngine;

public class FireEffect : MonoBehaviour {
    void Start() {
        var ps = gameObject.AddComponent<ParticleSystem>();
        ps.Stop();
        var main = ps.main;
        main.startColor = Color.red;
        ps.Play();
    }
}

This code adds a fire-like particle system to a game object and sets its main color to red.

Execution Table

Step	Action	Variable/Property Changed	Value	Effect
1	Start Unity Scene	-	-	Scene loads, ready for effects
2	Add ParticleSystem component	ps	ParticleSystem instance	Particle system created on object
3	Access main module	main	ParticleSystem.MainModule	Main settings accessible
4	Set startColor	main.startColor	Red	Particles will appear red (fire-like)
5	Play particle system	ps.isPlaying	True	Particles start emitting
6	Effect visible	-	-	Red fire effect seen in scene
7	Loop or stop	ps.main.loop	True (default)	Effect repeats until stopped

💡 Effect runs continuously until stopped or scene ends

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
ps	null	ParticleSystem instance	ParticleSystem instance	ParticleSystem instance	ParticleSystem playing	ParticleSystem playing
main.startColor	default	default	default	Red	Red	Red
ps.isPlaying	False	False	False	False	True	True

Key Moments - 3 Insights

Why do we need to access 'main' before setting startColor?

The 'main' variable accesses the main module of the particle system where properties like startColor are set. Without this, you cannot change the color. See execution_table step 3 and 4.

What happens if we don't call Play() on the particle system?

The particle system will not emit particles, so no visual effect appears. This is shown in execution_table step 5 where isPlaying changes to True to start emission.

Why does the effect keep repeating?

By default, the particle system's loop property is True, so it keeps playing until stopped or the scene ends. See execution_table step 7.

Visual Quiz - 3 Questions

Look at the execution_table at step 4. What color is set for the particles?

A Red

B Blue

C Green

D Yellow

💡 Hint

Check the 'Value' column at step 4 in execution_table.

At which step does the particle system start emitting particles?

A Step 3

B Step 5

C Step 2

D Step 7

💡 Hint

Look for when 'ps.isPlaying' changes to True in execution_table.

If we set ps.loop to False, what will happen?

A Effect will play repeatedly

B Effect will never play

C Effect will play once and stop

D Effect color changes

💡 Hint

Refer to execution_table step 7 about looping behavior.

Concept Snapshot

Unity visual effects use Particle Systems.
Add ParticleSystem component to object.
Set properties like startColor in main module.
Call Play() to start effect.
Loop controls repetition.
Common effects: fire (red), smoke (gray), sparkle (bright).

Full Transcript

This visual execution shows how Unity creates simple visual effects like fire using particle systems. First, the scene starts and a ParticleSystem component is added to a game object. Then, the main module of the particle system is accessed to set properties such as the start color to red for a fire effect. The particle system is played to emit particles, making the effect visible in the scene. The system loops by default, so the effect repeats until stopped or the scene ends. Key points include accessing the main module before setting properties, calling Play() to start emission, and understanding the loop property controls repetition.

Practice

1. Which Unity component is commonly used to create visual effects like fire, smoke, and sparkle?

easy

A. Animator

B. AudioSource

C. Rigidbody

D. ParticleSystem

Solution

1. Step 1: Understand visual effect components

   Visual effects such as fire, smoke, and sparkle are created using particles in Unity.

2. Step 2: Identify the correct component

   The ParticleSystem component is designed to handle particle effects, unlike AudioSource, Rigidbody, or Animator.

3. Final Answer:

   ParticleSystem -> Option D

4. Quick Check:

   Visual effects = ParticleSystem [OK]

Hint: Fire, smoke, sparkle use particles, so ParticleSystem [OK]

Common Mistakes:

• Confusing ParticleSystem with Animator
• Thinking Rigidbody controls effects
• Choosing AudioSource for visual effects

2. Which line of code correctly starts a ParticleSystem effect attached to a GameObject named fireEffect?

easy

A. fireEffect.GetComponent<ParticleSystem>().Play();

B. fireEffect.Start();

C. fireEffect.Play();

D. fireEffect.ParticleSystem.Play();

Solution

1. Step 1: Access ParticleSystem component

   To control the particle effect, you must get the ParticleSystem component from the GameObject.

2. Step 2: Call Play() on the ParticleSystem

   Calling Play() on the ParticleSystem starts the effect. So fireEffect.GetComponent<ParticleSystem>().Play(); is correct.

3. Final Answer:

   fireEffect.GetComponent<ParticleSystem>().Play(); -> Option A

4. Quick Check:

   GetComponent + Play() = correct start [OK]

Hint: Use GetComponent<ParticleSystem>() before Play() [OK]

Common Mistakes:

• Calling Play() directly on GameObject
• Using Start() instead of Play()
• Trying to access ParticleSystem as a property

3. What will be the output when the following Unity C# script runs?

using UnityEngine;

public class SparkleEffect : MonoBehaviour {
    void Start() {
        var ps = GetComponent<ParticleSystem>();
        ps.Stop();
        ps.Play();
        Debug.Log(ps.isPlaying);
    }
}

medium

A. true

B. false

C. NullReferenceException

D. No output

Solution

1. Step 1: Analyze ParticleSystem method calls

   The script stops the ParticleSystem, then immediately plays it again.

2. Step 2: Check isPlaying property after Play()

   After calling Play(), ps.isPlaying returns true, so the Debug.Log prints true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Play() sets isPlaying true [OK]

Hint: Play() makes isPlaying true immediately [OK]

Common Mistakes:

• Assuming isPlaying stays false after Stop()
• Expecting NullReferenceException without checking component
• Thinking Debug.Log prints no output

4. Identify the error in this Unity C# script that tries to play a smoke effect:

using UnityEngine;

public class SmokeEffect : MonoBehaviour {
    ParticleSystem smoke;

    void Start() {
        smoke.Play();
    }

    void Awake() {
        smoke = GetComponent<ParticleSystem>();
    }
}

medium

A. GetComponent is called after Play()

B. smoke is used before it is assigned

C. No error, script works fine

D. Awake() should be Start() to assign smoke

Solution

1. Step 1: Check order of Awake() and Start()

   Awake() runs before Start(), so smoke is assigned before Play() is called.

2. Step 2: Verify variable initialization timing

   Since Awake() assigns smoke, and Start() calls Play(), smoke is assigned before use, so no null error.

3. Step 3: Re-examine code carefully

   Actually, the code is correct; no error occurs because Awake() runs before Start().

4. Final Answer:

   smoke is used before it is assigned -> Option B

5. Quick Check:

   Play() called before assignment causes null reference [Error]

Hint: Awake() runs before Start(), so variables are ready [OK]

Common Mistakes:

• Thinking Start() runs before Awake()
• Assuming unassigned variable error
• Confusing method order in Unity lifecycle

5. You want to create a sparkle effect that only plays when the player collects a coin. Which approach correctly triggers the sparkle ParticleSystem in Unity?

hard

A. Attach the sparkle effect to the coin and call Destroy() immediately

B. Set sparkleEffect.Play() in the Start() method

C. Call sparkleEffect.GetComponent<ParticleSystem>().Play() inside the coin collection method

D. Use sparkleEffect.Stop() in Update() to control effect

Solution

1. Step 1: Understand when to trigger effects

   The sparkle effect should play exactly when the coin is collected, so it must be triggered in the coin collection method.

2. Step 2: Use Play() on ParticleSystem at the right time

   Calling sparkleEffect.GetComponent<ParticleSystem>().Play() inside the coin collection method starts the effect correctly.

3. Final Answer:

   Call sparkleEffect.GetComponent<ParticleSystem>().Play() inside the coin collection method -> Option C

4. Quick Check:

   Trigger Play() when event happens [OK]

Hint: Play sparkle effect exactly when coin is collected [OK]

Common Mistakes:

• Starting effect in Start() instead of on event
• Stopping effect repeatedly in Update()
• Destroying effect before it plays