Cara Menghasilkan Efek Petir 2D yang Mengejutkan dan Menyenangkan dalam Unity (C#)

using UnityEngine;

using System.Collections;

public class Line : MonoBehaviour

{

    //Start

    public Vector2 A;

    //End

    public Vector2 B;

    //Thickness of line

    public float Thickness;

    //Children that contain the pieces that make up the line

    public GameObject StartCapChild, LineChild, EndCapChild;

    //Create a new line

    public Line(Vector2 a, Vector2 b, float thickness)

    {

        A = a;

        B = b;

        Thickness = thickness;

    }

    //Used to set the color of the line

    public void SetColor(Color color)

    {

        StartCapChild.GetComponent<SpriteRenderer>().color = color;

        LineChild.GetComponent<SpriteRenderer>().color = color;

        EndCapChild.GetComponent<SpriteRenderer>().color = color;

    }

    //...

}

//Will actually draw the line

public void Draw()

{

    Vector2 difference = B - A;

    float rotation = Mathf.Atan2(difference.y, difference.x) * Mathf.Rad2Deg;

    //Set the scale of the line to reflect length and thickness

    LineChild.transform.localScale = new Vector3(100 * (difference.magnitude / LineChild.GetComponent<SpriteRenderer>().sprite.rect.width), 

                                                 Thickness, 

                                                 LineChild.transform.localScale.z);

    StartCapChild.transform.localScale = new Vector3(StartCapChild.transform.localScale.x, 

                                                     Thickness, 

                                                     StartCapChild.transform.localScale.z);

    EndCapChild.transform.localScale = new Vector3(EndCapChild.transform.localScale.x, 

                                                   Thickness, 

                                                   EndCapChild.transform.localScale.z);

    //Rotate the line so that it is facing the right direction

    LineChild.transform.rotation = Quaternion.Euler(new Vector3(0,0, rotation));

    StartCapChild.transform.rotation = Quaternion.Euler(new Vector3(0,0, rotation));

    EndCapChild.transform.rotation = Quaternion.Euler(new Vector3(0,0, rotation + 180));

    //Move the line to be centered on the starting point

    LineChild.transform.position = new Vector3 (A.x, A.y, LineChild.transform.position.z);

    StartCapChild.transform.position = new Vector3 (A.x, A.y, StartCapChild.transform.position.z);

    EndCapChild.transform.position = new Vector3 (A.x, A.y, EndCapChild.transform.position.z);

    //Need to convert rotation to radians at this point for Cos/Sin

    rotation *= Mathf.Deg2Rad;

    //Store these so we only have to access once

    float lineChildWorldAdjust = LineChild.transform.localScale.x * LineChild.GetComponent<SpriteRenderer>().sprite.rect.width / 2f;

    float startCapChildWorldAdjust = StartCapChild.transform.localScale.x * StartCapChild.GetComponent<SpriteRenderer>().sprite.rect.width / 2f;

    float endCapChildWorldAdjust = EndCapChild.transform.localScale.x * EndCapChild.GetComponent<SpriteRenderer>().sprite.rect.width / 2f;

    //Adjust the middle segment to the appropriate position

    LineChild.transform.position += new Vector3 (.01f * Mathf.Cos(rotation) * lineChildWorldAdjust, 

                                                 .01f * Mathf.Sin(rotation) * lineChildWorldAdjust,

                                                 0);

    //Adjust the start cap to the appropriate position

    StartCapChild.transform.position -= new Vector3 (.01f * Mathf.Cos(rotation) * startCapChildWorldAdjust, 

                                                     .01f * Mathf.Sin(rotation) * startCapChildWorldAdjust,

                                                     0);

    //Adjust the end cap to the appropriate position

    EndCapChild.transform.position += new Vector3 (.01f * Mathf.Cos(rotation) * lineChildWorldAdjust * 2, 

                                                   .01f * Mathf.Sin(rotation) * lineChildWorldAdjust * 2,

                                                   0);

    EndCapChild.transform.position += new Vector3 (.01f * Mathf.Cos(rotation) * endCapChildWorldAdjust, 

                                                   .01f * Mathf.Sin(rotation) * endCapChildWorldAdjust,

                                                   0);

}

using UnityEngine;

using System.Collections.Generic;

class LightningBolt : MonoBehaviour

{

    //List of all of our active/inactive lines

    public List<GameObject> ActiveLineObj;

    public List<GameObject> InactiveLineObj;

    //Prefab for a line

    public GameObject LinePrefab;

    //Transparency

    public float Alpha { get; set; }

    //The speed at which our bolts will fade out

    public float FadeOutRate { get; set; }

    //The color of our bolts

    public Color Tint { get; set; }

    //The position where our bolt started

    public Vector2 Start { get { return ActiveLineObj[0].GetComponent<Line>().A; } }

    //The position where our bolt ended

    public Vector2 End { get { return ActiveLineObj[ActiveLineObj.Count-1].GetComponent<Line>().B; } }

    //True if the bolt has completely faded out

    public bool IsComplete { get { return Alpha <= 0; } }

    public void Initialize(int maxSegments)

    {

        //Initialize lists for pooling

        ActiveLineObj = new List<GameObject>();

        InactiveLineObj = new List<GameObject>();

        for(int i = 0; i < maxSegments; i++)

        {

            //instantiate from our Line Prefab

            GameObject line = (GameObject)GameObject.Instantiate(LinePrefab);

            //parent it to our bolt object

            line.transform.parent = transform;

            //set it inactive

            line.SetActive(false);

            //add it to our list

            InactiveLineObj.Add(line);

        }

    }

    public void ActivateBolt(Vector2 source, Vector2 dest, Color color, float thickness)

    {

        //Store tint

        Tint = color;

        //Store alpha

        Alpha = 1.5f;

        //Store fade out rate

        FadeOutRate = 0.03f;

        //actually create the bolt

        //Prevent from getting a 0 magnitude

        if(Vector2.Distance(dest, source) <= 0)

        {

            Vector2 adjust = Random.insideUnitCircle;

            if(adjust.magnitude <= 0) adjust.x += .1f;

            dest += adjust;

        }

        //difference from source to destination

        Vector2 slope = dest - source;

        Vector2 normal = (new Vector2(slope.y, -slope.x)).normalized;

        //distance between source and destination

        float distance = slope.magnitude;

        List<float> positions = new List<float>();

        positions.Add(0);

        for (int i = 0; i < distance / 4; i++) 

        {

            //Generate random positions between 0 and 1 to break up the bolt

            //positions.Add (Random.Range(0f, 1f));

            positions.Add (Random.Range(.25f, .75f));

        }

        positions.Sort();

        const float Sway = 80;

        const float Jaggedness = 1 / Sway;

        //Affects how wide the bolt is allowed to spread

        float spread = 1f;

        //Start at the source

        Vector2 prevPoint = source;

        //No previous displacement, so just 0

        float prevDisplacement = 0;

        for (int i = 1; i < positions.Count; i++)

        {

            //don't allow more than we have in the pool

            int inactiveCount = InactiveLineObj.Count;

            if(inactiveCount <= 0) break;

            float pos = positions[i];

            //used to prevent sharp angles by ensuring very close positions also have small perpendicular variation.

            float scale = (distance * Jaggedness) * (pos - positions[i - 1]);

            //defines an envelope. Points near the middle of the bolt can be further from the central line.

            float envelope = pos > 0.95f ? 20 * (1 - pos) : spread;

            float displacement = Random.Range(-Sway, Sway);

            displacement -= (displacement - prevDisplacement) * (1 - scale);

            displacement *= envelope;

            //Calculate the end point

            Vector2 point = source + (pos * slope) + (displacement * normal);

            activateLine(prevPoint, point, thickness);

            prevPoint = point;

            prevDisplacement = displacement;

        }

        activateLine(prevPoint, dest, thickness);

    }

    public void DeactivateSegments()

    {

        for(int i = ActiveLineObj.Count - 1; i >= 0; i--)

        {

            GameObject line = ActiveLineObj[i];

            line.SetActive(false);

            ActiveLineObj.RemoveAt(i);

            InactiveLineObj.Add(line);

        }

    }

    void activateLine(Vector2 A, Vector2 B, float thickness)

    {

        //get the inactive count

        int inactiveCount = InactiveLineObj.Count;

        //only activate if we can pull from inactive

        if(inactiveCount <= 0) return;

        //pull the GameObject

        GameObject line = InactiveLineObj[inactiveCount - 1];

        //set it active

        line.SetActive(true);

        //get the Line component

        Line lineComponent = line.GetComponent<Line>();

        lineComponent.SetColor(Color.white);

        lineComponent.A = A;

        lineComponent.B = B;

        lineComponent.Thickness = thickness;

        InactiveLineObj.RemoveAt(inactiveCount - 1);

        ActiveLineObj.Add(line);

    }

    public void Draw()

    {

        //if the bolt has faded out, no need to draw

        if (Alpha <= 0) return;

        foreach (GameObject obj in ActiveLineObj)

        {

            Line lineComponent = obj.GetComponent<Line>();

            lineComponent.SetColor(Tint * (Alpha * 0.6f));

            lineComponent.Draw();

        }

    }

    public void UpdateBolt()

    {

        Alpha -= FadeOutRate;

    }

    //...

}

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class DemoScript : MonoBehaviour 

{

    //Prefabs to be assigned in Editor

    public GameObject BoltPrefab;

    //For pooling

    List<GameObject> activeBoltsObj;

    List<GameObject> inactiveBoltsObj;

    int maxBolts = 1000;

    //For handling mouse clicks

    int clicks = 0;

    Vector2 pos1, pos2;

    void Start()

    {

        //Initialize lists

        activeBoltsObj = new List<GameObject>();

        inactiveBoltsObj = new List<GameObject>();

        //Grab the parent we'll be assigning to our bolt pool

        GameObject p = GameObject.Find("LightningPoolHolder");

        //For however many bolts we've specified

        for(int i = 0; i < maxBolts; i++)

        {

            //create from our prefab

            GameObject bolt = (GameObject)Instantiate(BoltPrefab);

            //Assign parent

            bolt.transform.parent = p.transform;

            //Initialize our lightning with a preset number of max sexments

            bolt.GetComponent<LightningBolt>().Initialize(25);

            //Set inactive to start

            bolt.SetActive(false);

            //Store in our inactive list

            inactiveBoltsObj.Add(bolt);

        }

    }

    void Update()

    {

        //Declare variables for use later

        GameObject boltObj;

        LightningBolt boltComponent;

        //store off the count for effeciency

        int activeLineCount = activeBoltsObj.Count;

        //loop through active lines (backwards because we'll be removing from the list)

        for (int i = activeLineCount - 1; i >= 0; i--)

        {

            //pull GameObject

            boltObj = activeBoltsObj[i];

            //get the LightningBolt component

            boltComponent = boltObj.GetComponent<LightningBolt>();

            //if the bolt has faded out

            if(boltComponent.IsComplete)

            {

                //deactive the segments it contains

                boltComponent.DeactivateSegments();

                //set it inactive

                boltObj.SetActive(false);

                //move it to the inactive list

                activeBoltsObj.RemoveAt(i);

                inactiveBoltsObj.Add(boltObj);

            }

        }

        //If left mouse button pressed

        if(Input.GetMouseButtonDown(0))

        {

          //if first click

        	if(clicks == 0)

        	{

                //store starting position

                Vector3 temp = Camera.main.ScreenToWorldPoint(Input.mousePosition);

                pos1 = new Vector2(temp.x, temp.y);

        	}

        	else if(clicks == 1) //second click

        	{

                //store end position

                Vector3 temp = Camera.main.ScreenToWorldPoint(Input.mousePosition);

                pos2 = new Vector2(temp.x, temp.y);

                //create a (pooled) bolt from pos1 to pos2

                CreatePooledBolt(pos1,pos2, Color.white, 1f);

        	}

        	//increment our tick count

        	clicks++;

        	//restart the count after 2 clicks

        	if(clicks > 1) clicks = 0;

        }

        //update and draw active bolts

        for(int i = 0; i < activeBoltsObj.Count; i++)

        {

            activeBoltsObj[i].GetComponent<LightningBolt>().UpdateBolt();

            activeBoltsObj[i].GetComponent<LightningBolt>().Draw();

        }

    }

        void CreatePooledBolt(Vector2 source, Vector2 dest, Color color, float thickness)

        {

        //if there is an inactive bolt to pull from the pool

        if(inactiveBoltsObj.Count > 0)

        {

        	//pull the GameObject

        	GameObject boltObj = inactiveBoltsObj[inactiveBoltsObj.Count - 1];

        	//set it active

        	boltObj.SetActive(true);

        	//move it to the active list

        	activeBoltsObj.Add(boltObj);

        	inactiveBoltsObj.RemoveAt(inactiveBoltsObj.Count - 1);

        	//get the bolt component

        	LightningBolt boltComponent =  boltObj.GetComponent<LightningBolt>();

        	//activate the bolt using the given position data

        	boltComponent.ActivateBolt(source, dest, color, thickness);

        }

    }

}

using UnityEngine;

using System.Collections.Generic;

class BranchLightning : MonoBehaviour

{

    //For holding all of our bolts in our branch

    List<GameObject> boltsObj = new List<GameObject>();

    //If there are no bolts, then the branch is complete (we're not pooling here, but you could if you wanted)

    public bool IsComplete { get { return boltsObj.Count == 0; } }

    //Start position of branch

    public Vector2 Start { get; private set; }

    //End position of branch

    public Vector2 End { get; private set; }

    static Random rand = new Random();

    public void Initialize(Vector2 start, Vector2 end, GameObject boltPrefab)

    {

        //store start and end positions

        Start = start;

        End = end;

        //create the  main bolt from our bolt prefab

        GameObject mainBoltObj = (GameObject)GameObject.Instantiate(boltPrefab);

        //get the LightningBolt component

        LightningBolt mainBoltComponent = mainBoltObj.GetComponent<LightningBolt>();

        //initialize our bolt with a max of 5 segments

        mainBoltComponent.Initialize(5);

        //activate the bolt with our position data

        mainBoltComponent.ActivateBolt(start, end, Color.white, 1f);

        //add it to our list

        boltsObj.Add(mainBoltObj);

        //randomly determine how many sub branches there will be (3-6)

        int numBranches = Random.Range(3,6);

        //calculate the difference between our start and end points

        Vector2 diff = end - start;

        // pick a bunch of random points between 0 and 1 and sort them

        List<float> branchPoints = new List<float>();

        for(int i = 0; i < numBranches; i++) branchPoints.Add(Random.value);

        branchPoints.Sort();

        //go through those points

        for (int i = 0; i < branchPoints.Count; i++)

        {

            // Bolt.GetPoint() gets the position of the lightning bolt based on the percentage passed in (0 = start of bolt, 1 = end)

            Vector2 boltStart = mainBoltComponent.GetPoint(branchPoints[i]);

            //get rotation of 30 degrees. Alternate between rotating left and right. (i & 1 will be true for all odd numbers...yay bitwise operators!)

            Quaternion rot = Quaternion.AngleAxis(30 * ((i & 1) == 0 ? 1 : -1), new Vector3(0,0,1));

            //calculate how much to adjust for our end position

            Vector2 adjust = rot * (Random.Range(.5f, .75f) * diff * (1 - branchPoints[i]));

            //get the end position

            Vector2 boltEnd = adjust + boltStart;

            //instantiate from our bolt prefab

            GameObject boltObj = (GameObject)GameObject.Instantiate(boltPrefab);

            //get the LightningBolt component

            LightningBolt boltComponent = boltObj.GetComponent<LightningBolt>();

            //initialize our bolt with a max of 5 segments

            boltComponent.Initialize(5);

            //activate the bolt with our position data

            boltComponent.ActivateBolt(boltStart, boltEnd, Color.white, 1f);

            //add it to the list

            boltsObj.Add(boltObj);

        }

    }

    public void UpdateBranch()

    {

    	//go through our active bolts

    	for (int i = boltsObj.Count - 1; i >= 0; i--)

    	{

            //get the GameObject

            GameObject boltObj = boltsObj[i];

            //get the LightningBolt component

            LightningBolt boltComp = boltObj.GetComponent<LightningBolt>();

            //update/fade out the bolt

            boltComp.UpdateBolt();

            //if the bolt has faded

            if(boltComp.IsComplete)

            {

                //remove it from our list

                boltsObj.RemoveAt(i);

                //destroy it (would be better to pool but I'll let you figure out how to do that =P)

                Destroy(boltObj);

            }

    	}

    }

    //Draw our active bolts on screen

    public void Draw()

    {

        foreach (GameObject boltObj in boltsObj)

        {

            boltObj.GetComponent<LightningBolt>().Draw();

        }

    }

}

// Returns the point where the bolt is at a given fraction of the way through the bolt. Passing

// zero will return the start of the bolt, and passing 1 will return the end.

public Vector2 GetPoint(float position)

{

    Vector2 start = Start;

    float length = Vector2.Distance(start, End);

    Vector2 dir = (End - start) / length;

    position *= length;

    //find the appropriate line

    Line line = ActiveLineObj.Find(x => Vector2.Dot(x.GetComponent<Line>().B - start, dir) >= position).GetComponent<Line>();

    float lineStartPos = Vector2.Dot(line.A - start, dir);

    float lineEndPos = Vector2.Dot(line.B - start, dir);

    float linePos = (position - lineStartPos) / (lineEndPos - lineStartPos);

    return Vector2.Lerp(line.A, line.B, linePos);

}

//Capture the important points of our text for later

IEnumerator TextCapture()

{

    //must wait until end of frame so something is actually drawn or else it will error

    yield return new WaitForEndOfFrame();

    //get the camera that draws our text

    Camera cam = GameObject.Find("TextCamera").GetComponent<Camera>();

    //make sure it has an assigned RenderTexture

    if(cam.targetTexture != null) 

    {

        //pull the active RenderTexture

        RenderTexture.active = cam.targetTexture;

        //capture the image into a Texture2D

        Texture2D image = new Texture2D(cam.targetTexture.width, cam.targetTexture.height);

        image.ReadPixels(new Rect(0, 0, cam.targetTexture.width, cam.targetTexture.height), 0, 0);

        image.Apply();

        //calculate how the text will be scaled when it is displayed as lightning on the screen

        scaleText = 1 / (cam.ViewportToWorldPoint(new Vector3(1,0,0)).x - cam.ViewportToWorldPoint(Vector3.zero).x);

        //calculate how the text will be positioned when it is displayed as lightning on the screen (centered)

        positionText.x -= image.width * scaleText * .5f;

        positionText.y -= image.height * scaleText * .5f;

        //basically determines how many pixels we skip/check

        const int interval = 2;

        //loop through pixels

        for(int y = 0; y < image.height; y += interval)

        {

            for(int x = 0; x < image.width; x += interval)

            {

                //get the color of the pixel

                Color color = image.GetPixel(x,y);

                //if the color has any r (red) value

                if(color.r > 0)

                {

                    //add it to our points for drawing

                    textPoints.Add(new Vector2(x,y));

                }

            }

        }

    }

}

//go through the points we capture earlier

foreach (Vector2 point in textPoints)

{

    //randomly ignore certain points

    if(Random.Range(0,75) != 0) continue;

    //placeholder values

    Vector2 nearestParticle = Vector2.zero;

    float nearestDistSquared = float.MaxValue;

    for (int i = 0; i < 50; i++)

    {

        //select a random point

        Vector2 other = textPoints[Random.Range(0, textPoints.Count)];

        //calculate the distance (squared for performance benefits) between the two points

        float distSquared = DistanceSquared(point, other);

        //If this point is the nearest point (but not too near!)

        if (distSquared < nearestDistSquared && distSquared > 3 * 3)

        {

            //store off the data

            nearestDistSquared = distSquared;

            nearestParticle = other;

        }

    }

    //if the point we found isn't too near/far

    if (nearestDistSquared < 25 * 25 && nearestDistSquared > 3 * 3)

    {

        //create a (pooled) bolt at the corresponding screen position

        CreatePooledBolt((point * scaleText) + positionText, (nearestParticle * scaleText) + positionText, new Color(Random.value,Random.value,Random.value,1f), 1f);

    }

}

/* The code above uses the following function 

 * It'll need to be placed appropriately

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

//calculate distance squared (no square root = performance boost)

public float DistanceSquared(Vector2 a, Vector2 b)

{

    return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

}

---------------------------------------------*/

//Will contain all of the pieces for the moving bolt

List<GameObject> movingBolt = new List<GameObject>();

//used for actually moving the moving bolt

Vector2 lightningEnd = new Vector2(100, 100);

Vector2 lightningVelocity = new Vector2(1, 0);

void Update()

{

    //loop through all of our bolts that make up the moving bolt

    for(int i = movingBolt.Count - 1; i >= 0; i--)

    {

        //get the bolt component

        boltComponent = movingBolt[i].GetComponent<LightningBolt>();

        //if the bolt has faded out

        if(boltComponent.IsComplete)

        {

            //destroy it

            Destroy(movingBolt[i]);

            //remove it from our list

            movingBolt.RemoveAt(i);

            //on to the next one, on on to the next one

            continue;

        }

        //update and draw bolt

        boltComponent.UpdateBolt();

        boltComponent.Draw();

    }

    //if our moving bolt is active

    if(movingBolt.Count > 0)

    {

        //calculate where it currently ends

        lightningEnd = movingBolt[movingBolt.Count-1].GetComponent<LightningBolt>().End;

        //if the end of the bolt is within 25 units of the camera

        if(Vector2.Distance(lightningEnd,(Vector2)Camera.main.transform.position) < 25)

        {

            //instantiate from our bolt prefab

            boltObj = (GameObject)GameObject.Instantiate(BoltPrefab);

            //get the bolt component

            boltComponent = boltObj.GetComponent<LightningBolt>();

            //initialize it with a maximum of 5 segments

            boltComponent.Initialize(5);

            //activate the bolt using our position data (from the current end of our moving bolt to the current end + velocity) 

            boltComponent.ActivateBolt(lightningEnd,lightningEnd + lightningVelocity, Color.white, 1f);

            //add it to our list

            movingBolt.Add(boltObj);

            //update and draw our new bolt

            boltComponent.UpdateBolt();

            boltComponent.Draw();

        }

    }

}

Vector2 diff = pos2 - pos1;

void Update()

{

    //define how many bolts we want in our circle

    int boltsInBurst = 10;

    for(int i = 0; i < boltsInBurst; i++)

    {

        //rotate around the z axis to the appropriate angle

        Quaternion rot = Quaternion.AngleAxis((360f/boltsInBurst) * i, new Vector3(0,0,1));

        //Calculate the end position for the bolt

        Vector2 boltEnd = (Vector2)(rot * diff) + pos1;

        //create a (pooled) bolt from pos1 to boltEnd

        CreatePooledBolt(pos1, boltEnd, Color.white, 1f);

    }

}

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class DemoScript : MonoBehaviour 

{

    //Prefabs to be assigned in Editor

    public GameObject BoltPrefab;

    public GameObject BranchPrefab;

    //For pooling

    List<GameObject> activeBoltsObj;

    List<GameObject> inactiveBoltsObj;

    int maxBolts = 1000;

    float scaleText;

    Vector2 positionText;

    //Different modes for the demo

    enum Mode : byte

    {

        bolt,

        branch,

        moving,

        text,

        nodes,

        burst

    }

    //The current mode the demo is in

    Mode currentMode = Mode.bolt;

    //Will contain all of the pieces for the moving bolt

    List<GameObject> movingBolt = new List<GameObject>();

    //used for actually moving the moving bolt

    Vector2 lightningEnd = new Vector2(100, 100);

    Vector2 lightningVelocity = new Vector2(1, 0);

    //Will contain all of the pieces for the branches

    List<GameObject> branchesObj;

    //For handling mouse clicks

    int clicks = 0;

    Vector2 pos1, pos2;

    //For storing all of the pixels that need to be drawn by the bolts 

    List<Vector2> textPoints = new List<Vector2>();

    //true in text mode

    bool shouldText = false;

    void Start()

    {

        //Initialize lists

        activeBoltsObj = new List<GameObject>();

        inactiveBoltsObj = new List<GameObject>();

        branchesObj = new List<GameObject>();

        //Grab the parent we'll be assigning to our bolt pool

        GameObject p = GameObject.Find("LightningPoolHolder");

        //For however many bolts we've specified

        for(int i = 0; i < maxBolts; i++)

        {

            //create from our prefab

            GameObject bolt = (GameObject)Instantiate(BoltPrefab);

            //Assign parent

            bolt.transform.parent = p.transform;

            //Initialize our lightning with a preset number of max sexments

            bolt.GetComponent<LightningBolt>().Initialize(25);

            //Set inactive to start

            bolt.SetActive(false);

            //Store in our inactive list

            inactiveBoltsObj.Add(bolt);

        }

        //Start up a coroutine to capture the pixels we'll be drawing from our text (need the coroutine or error)

        StartCoroutine(TextCapture());

    }

    void Update()

    {

        //Declare variables for use later

        GameObject boltObj;

        LightningBolt boltComponent;

        //store off the count for effeciency

        int activeLineCount = activeBoltsObj.Count;

        //loop through active lines (backwards because we'll be removing from the list)

        for (int i = activeLineCount - 1; i >= 0; i--)

        {

            //pull GameObject

            boltObj = activeBoltsObj[i];

            //get the LightningBolt component

            boltComponent = boltObj.GetComponent<LightningBolt>();

            //if the bolt has faded out

            if(boltComponent.IsComplete)

            {

                //deactive the segments it contains

                boltComponent.DeactivateSegments();

                //set it inactive

                boltObj.SetActive(false);