Wie generiert man schockierend gute 2D-Blitz-Effekte in Unity? (JavaScript)

#pragma strict

class LineJS extends MonoBehaviour

{

    //Start

    public var A: Vector2;

    //End

    public var B: Vector2;

    //Thickness of line

    public var Thickness: float;

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

    public var StartCapChild : GameObject;

    public var LineChild : GameObject;

    public var EndCapChild : GameObject;

    //Create a new line

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

    {

        A = a;

        B = b;

        Thickness = thickness;

    }

    //Used to set the color of the line

    public function SetColor(color : Color)

    {

        StartCapChild.GetComponent(SpriteRenderer).color = color;

        LineChild.GetComponent(SpriteRenderer).color = color;

        EndCapChild.GetComponent(SpriteRenderer).color = color;

    }

    //...

}

//Will actually draw the line

public function Draw()

{

    var difference : Vector2 = B - A;

    var rotation : float = 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

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

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

    var endCapChildWorldAdjust : float = 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);

}

#pragma strict

import System.Collections.Generic;

class LightningBoltJS extends MonoBehaviour

{    

    //List of all of our active/inactive lines

    public var ActiveLineObj : List.<GameObject>;

    public var InactiveLineObj : List.<GameObject>;

    //Prefab for a line

    public var LinePrefab : GameObject;

    //Transparency

    public var Alpha : float;

    //The speed at which our bolts will fade out

    public var FadeOutRate : float;

    //The color of our bolts

    public var Tint : Color;

    //The position where our bolt started

    public function Start()

    {

        var first : GameObject = ActiveLineObj[0];

        return first.GetComponent(LineJS).A;

    }

    //The position where our bolt ended

    public function End()

    {

        var last : GameObject = ActiveLineObj[ActiveLineObj.Count-1];

        return last.GetComponent(LineJS).B;

    }

    //True if the bolt has completely faded out

    public function IsComplete()

    { 

	    return Alpha <= 0;

    }

    public function Initialize(maxSegments : int)

    {

        //Initialize lists for pooling

        ActiveLineObj = new List.<GameObject>();

        InactiveLineObj = new List.<GameObject>();

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

        {

            //instantiate from our Line Prefab

            var 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 function ActivateBolt(source : Vector2, dest : Vector2, color : Color, thickness : float)

    {

        //for use in loops later

        var i : int;

        //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)

        {

            var adjust : Vector2 = Random.insideUnitCircle;

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

            dest += adjust;

        }

        //difference from source to destination

        var slope : Vector2 = dest - source;

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

        //distance between source and destination

        var distance : float = slope.magnitude;

        var positions : List.<float> = new List.<float>();

        positions.Add(0);

        for (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();

        var Sway : float = 80;

        var Jaggedness : float = 1 / Sway;

        //Affects how wide the bolt is allowed to spread

        var spread : float = 1f;

        //Start at the source

        var prevPoint : Vector2 = source;

        //No previous displacement, so just 0

        var prevDisplacement : float = 0;

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

        {

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

            var inactiveCount : int = InactiveLineObj.Count;

            if(inactiveCount <= 0) break;

            var pos : float = positions[i];

            var prevPos : float = positions[i - 1];

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

            var scale : float = (distance * Jaggedness) * (pos - prevPos);

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

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

            //calculate the displacement

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

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

            displacement *= envelope;

            //Calculate the end point

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

            activateLine(prevPoint, point, thickness);

            prevPoint = point;

            prevDisplacement = displacement;

        }

        activateLine(prevPoint, dest, thickness);

    }

    public function DeactivateSegments()

    {

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

        {

            var line : GameObject = ActiveLineObj[i];

            line.SetActive(false);

            ActiveLineObj.RemoveAt(i);

            InactiveLineObj.Add(line);

        }

    }

    function activateLine(A : Vector2, B : Vector2, thickness : float)

    {

        //get the inactive count

        var inactiveCount : int = InactiveLineObj.Count;

        //only activate if we can pull from inactive

        if(inactiveCount <= 0) return;

        //pull the GameObject

        var lineObj : GameObject = InactiveLineObj[InactiveLineObj.Count - 1];

        //set it active

        lineObj.SetActive(true);

        //get the Line component

        var lineComponent : LineJS = lineObj.GetComponent(LineJS);

        lineComponent.SetColor(Color.white);

        lineComponent.A = A;

        lineComponent.B = B;

        lineComponent.Thickness = thickness;

        ActiveLineObj.Add(lineObj);

        InactiveLineObj.Remove(lineObj);

    }

    public function Draw()

    {

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

        if (Alpha <= 0) return;

        for(var i : int = 0; i < ActiveLineObj.Count; i++)

        {

            var obj : GameObject = ActiveLineObj[i];

            var lineComponent : LineJS = obj.GetComponent(LineJS);

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

            lineComponent.Draw();

        }

    }

    public function Update()

    {

        Alpha -= FadeOutRate;

    }

    //...

}

#pragma strict

import System.Collections.Generic;

class DemoScriptJS extends MonoBehaviour

{

    //Prefabs to be assigned in Editor

    public var BoltPrefab : GameObject;

    //For pooling

    var activeBoltsObj : List.<GameObject>;

    var inactiveBoltsObj : List.<GameObject>;

    var maxBolts : int = 1000;

    //For handling mouse clicks

    var clicks : int = 0;

    var pos1 : Vector2;

    var pos2 : Vector2;

    function Start()

    {

        //Initialize lists

        activeBoltsObj = new List.<GameObject>();

        inactiveBoltsObj = new List.<GameObject>();

        //for use later

        var tempV3 : Vector3;

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

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

        //For however many bolts we've specified

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

        {

            //create from our prefab

            var bolt : GameObject = Instantiate(BoltPrefab);

            //Assign parent

            bolt.transform.parent = p.transform;

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

            bolt.GetComponent(LightningBoltJS).Initialize(25);

            //Set inactive to start

            bolt.SetActive(false);

            //Store in our inactive list

            inactiveBoltsObj.Add(bolt);

        }

    }

    function Update()

    {

        //Declare variables for use later

        var boltObj : GameObject;

        var boltComponent : LightningBoltJS;

        var i : int;

        var tempV3 : Vector3;

        var adjust : Vector2;

        //store off the count for effeciency

        var activeLineCount : int = activeBoltsObj.Count;

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

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

        {

        	//pull GameObject

        	boltObj = activeBoltsObj[i];

        	//get the LightningBolt component

        	boltComponent = boltObj.GetComponent(LightningBoltJS);

        	//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

                tempV3 = Camera.main.ScreenToWorldPoint(Input.mousePosition);

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

            }

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

            {

                //store end position

                tempV3 = Camera.main.ScreenToWorldPoint(Input.mousePosition);

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

                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(i = 0; i < activeBoltsObj.Count; i++)

        {

            boltObj = activeBoltsObj[i];

            boltObj.GetComponent(LightningBoltJS).Update();

            boltObj.GetComponent(LightningBoltJS).Draw();

        }

    }

    function CreatePooledBolt(source : Vector2, dest : Vector2, color : Color, thickness : float)

    {

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

        if(inactiveBoltsObj.Count > 0)

        {

            //pull the GameObject

            var boltObj : GameObject = 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

            var boltComponent : LightningBoltJS =  boltObj.GetComponent(LightningBoltJS);

            //activate the bolt using the given position data

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

        }

    }

}

//Capture the important points of our text for later

function TextCapture()

{

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

    yield WaitForEndOfFrame();

    //get the camera that draws our text

    var cam : Camera = 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

        var image : Texture2D = 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

        var interval : int = 2;

        //loop through pixels

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

        {

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

            {

                //get the color of the pixel

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

                //if the color has an 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

for (var i1 : int = 0; i1 < textPoints.Count; i1++)

{

    var point : Vector2 = textPoints[i1];

    //randomly ignore certain points

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

    //placeholder values

    var nearestParticle : Vector2 = Vector2.zero;

    var nearestDistSquared : float = float.MaxValue;

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

    {

        //select a random point

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

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

        var distSquared : float = 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 function DistanceSquared(a : Vector2, b : Vector2)

{

    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

var movingBolt : List.<GameObject>;

//used for actually moving the moving bolt

var lightningEnd : Vector2 = new Vector2(100, 100);

var lightningVelocity : Vector2 = new Vector2(1, 0);

function Update()

{

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

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

    {

        boltObj = movingBolt[i];

        //get the bolt component

        boltComponent = boltObj.GetComponent(LightningBoltJS);

        //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.Update();

        boltComponent.Draw();

    }

    //if our moving bolt is active

    if(movingBolt.Count > 0)

    {

        boltObj = movingBolt[movingBolt.Count-1];

        //calculate where it currently ends

        lightningEnd = boltObj.GetComponent(LightningBoltJS).End();

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

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

        {

            //instantiate from our bolt prefab

            boltObj = GameObject.Instantiate(BoltPrefab);

            //get the bolt component

            boltComponent = boltObj.GetComponent(LightningBoltJS);

            //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.Update();

            boltComponent.Draw();

        }

    }

}

//get the difference between our two positions (destination - source = vector from source to destination)

var diff : Vector2 = pos2 - pos1;

function Update()

{

    //define how many bolts we want in our circle

    var boltsInBurst : int = 10;

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

    {

        //rotate around the z axis to the appropriate angle

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

        adjust = rot * diff;

        //Calculate the end position for the bolt

        var boltEnd : Vector2 = adjust + pos1;

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

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

    }

}