游戏登录背景的白云生成脚本

最近看了泰斗破坏神的视频，自己写了个生成云的脚本。我把云这个sprite做成了预制。

上面有个Cloud脚本，Cloud脚本主要控制云的透明度变化，移动方向,尺寸和速度，

云在漂浮的时候会随机发生透明度变化。当云运动到了某一位置或者到了规

定的生存时间就会透明度逐渐减小，看不见的时候自动消失。

然后在UIRoot上面放了个CreateCloud脚本，用来控制云的数量和生成速度。

看下CreateCloud参数：

一二项是最大最小速度，每朵云中间取随机值，

三四项是云的预制，

五六项是制作云的最大和最小间隔，每次制作完

取其中的随机时间等待然后再次制作，

七八项是每次云的alpha值变化的时间，

九十项是消失的最长和最短时间，每朵云取中间的

随机值作为消失时间，

十一项为画面中最多的云的数量，

十二十三项是云存在的最长和最短时间，每朵云的生存时间

取其中的随机值，

十四十五项是云的最大和最小Y值，每朵云的Y值取其中的随机值，

十六十七项是云的最大和最小X值，每朵云的最大和最小X值在其中取，

每朵云在所取的X值中运动，当到达边界X值时，云自动消失，

十八十九项是每次云的alpha值变化完成后到下一次变化

的时间。

CreateCloud脚本：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;


public class CreateCloud : MonoBehaviour {

    static CreateCloud _instance;

    public static CreateCloud Instance
    {
        get { return _instance; }
    }


    public float minCloudSpd;
    public float maxCloudSpd;

    public GameObject cloud1;
    public GameObject cloud2;
    
    public float maxCreateInterval;
    public float minCreateInterval;

    public float minAlphaInterval;
    public float maxAlphaInterval;

    public float minDestroyDur;
    public float maxDestroyDur;

    public int maxCloudCount;

    public float minCloudExistTime;
    public float maxCloudExistTime;

    public float maxCloudFlyingY;
    public float minCloudFlyingY;

    public float maxCloudFlyingX;
    public float minCloudFlyingX;

    /// <summary>
    /// 云层渐变之间休息的最大时间
    /// </summary>
    public float maxCloudRestTime;
    public float minCloudRestTime;

    public List<Cloud> clouds=new List<Cloud>();



    void Awake()
    {
        _instance = this;
    }

	// Use this for initialization
	void Start () {

        StartCoroutine(SpawnCloud());
	}

    IEnumerator SpawnCloud()
    {
        while (true)
        {
            if (clouds.Count<maxCloudCount)
            {
                RandomCloudCreate();
            }
            yield return new WaitForSeconds(Random.Range(minCreateInterval, maxCreateInterval));
        }
    }

    void RandomCloudCreate()
    {
        GameObject go;
        Cloud cloud;
        int category = Random.Range(0, 2);

        if (category == 0)
        {
            go=NGUITools.AddChild(gameObject,cloud1);
            cloud = go.GetComponent<Cloud>();
        }
        else
        {
          go = NGUITools.AddChild(gameObject,cloud2);
            cloud = go.GetComponent<Cloud>();
        }
        SetCloudProperty(cloud);
        clouds.Add(cloud);
    }

    void SetCloudProperty(Cloud cloud)
    {
        cloud.cloudExistTime = Random.Range(minCloudExistTime, maxCloudExistTime);
        cloud.destoyDur = Random.Range(minDestroyDur, maxDestroyDur);
        cloud.minAlphaInterval = Random.Range(minAlphaInterval, maxAlphaInterval);
        cloud.maxAlphaInterval = Random.Range(cloud.minAlphaInterval, maxAlphaInterval);
        cloud.minPosX = Random.Range(minCloudFlyingX, maxCloudFlyingX);
        cloud.maxPosX = Random.Range(cloud.minPosX, maxCloudFlyingX);
        cloud.PosY = Random.Range(minCloudFlyingY, maxCloudFlyingY);
        cloud.moveSpeed = Random.Range(minCloudSpd, maxCloudSpd);
        cloud.minCloudRestTime = Random.Range(minCloudRestTime, maxCloudRestTime);
        cloud.maxCloudRestTime = Random.Range(cloud.minCloudRestTime, maxCloudRestTime);
    }
	
	// Update is called once per frame
	void Update () {
	
	}
}

Cloud脚本：

using UnityEngine;
using System.Collections;

public class Cloud : MonoBehaviour
{

    UISprite myCloudSprite;

    public float cloudExistTime;

    public float destoyDur;

    float remainAlpha;

    int myFlyingDir;



    /// <summary>
    /// 转变状态的最短时间
    /// </summary>
    public float minAlphaInterval;

    /// <summary>
    /// 转变状态的最长时间
    /// </summary>
    public float maxAlphaInterval;

    public float maxCloudRestTime;
    public float minCloudRestTime;

    public float maxPosX;
    public float minPosX;
    public float PosY;

    public float moveSpeed;

    // Use this for initialization
    void Start()
    {
        float x = Random.Range(0.8f, 2f);
        float y = Random.Range(0.8f, 2f);
        transform.localScale = new Vector3(x,y,1);
        transform.localPosition = new Vector3(Random.Range(minPosX,maxPosX),PosY);
        myCloudSprite = GetComponent<UISprite>();
        myCloudSprite.alpha = 0;
        int i = Random.Range(0, 2);
        if (i==0)
        {
            myFlyingDir = -1;
        }
        else
        {
            myFlyingDir = 1;
        }
        StartCoroutine(AlphaGradientStart());
        
        InvokeRepeating("DetectPos", 0.2f, 0.2f);

    }

    void DetectPos()
    {
        if (transform.localPosition.x > maxPosX)
        {
            Destroy();
        }
        if (transform.localPosition.x < minPosX)
        {
            Destroy();
        }
    }


    IEnumerator AlphaGradientStart()
    {
        float alphaGradientDur = Random.Range(minAlphaInterval, maxAlphaInterval);
        float alpha=Random.Range(0f,1f);
        
        if (myCloudSprite.alpha >= alpha)
        {
            while (myCloudSprite.alpha >= alpha)
            {
                myCloudSprite.alpha -=  Time.deltaTime / alphaGradientDur;
                yield return null;
            }
        }else if (myCloudSprite.alpha <= alpha)
        {
            while (myCloudSprite.alpha <= 1)
            {
                myCloudSprite.alpha +=  Time.deltaTime / alphaGradientDur;
                yield return null;
            }
        }
        Invoke("Destroy", cloudExistTime);
        StartCoroutine(AlphaGradientRest());
    }

    IEnumerator AlphaGradientRest()
    {
        float timeToRest = Random.Range(minCloudRestTime, maxCloudRestTime);
        yield return new WaitForSeconds(timeToRest);
        StartCoroutine(AlphaGradientStart());
    }

    void Destroy()
    {
        StopAllCoroutines();
        StartCoroutine(Miss());
    }

    IEnumerator Miss()
    {
        remainAlpha = myCloudSprite.alpha;
        while (myCloudSprite.alpha >=0.03f)
        {
            myCloudSprite.alpha -= remainAlpha*Time.deltaTime / destoyDur;
            yield return 0;
        }
        Destroy(gameObject);
    }


    // Update is called once per frame
    void Update()
    {
        transform.Translate(new Vector3(myFlyingDir * Time.deltaTime * moveSpeed, 0, 0));
    }

    void OnDestroy()
    {
        CreateCloud.Instance.clouds.Remove(this);
    }
}