游戲中的隨機算法

1.從一個數組中隨機取出一個元素

var element = myArray[Random.Range(0, myArray.Length)];

2.PRD偽隨機算法, 通常用來計算暴擊率

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
using System.Text;
using System.Threading;

public class PRDCalcC : EditorWindow
{
    private static readonly string obj = "lock";
    private static Dictionary<int, int> prdDic = new Dictionary<int, int>();
    private string infoStr = "";
    private string dataStr = "數據運算中....";

    [MenuItem("Tools/PRD_C")]
    static void ShowWindow()
    {
        GetWindow<PRDCalcC>();
    }

    private void OnGUI()
    {
        EditorGUILayout.BeginVertical();
        if (GUILayout.Button("運算數據"))
        {
            // 計算 1% - 100% 暴擊率范圍所有的 PRD C值
            for (int i = 0; i <= 100; ++i)
            {
                int j = i;
                // 創建線程負責具體計算 C 值
                Thread thread = new Thread(() =>
                {
                    double p = i * 1d / 100d; // 顯示給玩家的暴擊率
                    double c = CFromP(p); // PRD算法 暴擊增量
                    int ic = (int)Math.Round(c * 100, 0); // 將百分數小數轉換為整數
                    lock (obj)
                    {
                        prdDic[j] = ic; // 計算結果存放在字典中
                    }
                });
                thread.Start();
            }
        }
        GUILayout.Label(dataStr);
        if (prdDic.Count == 101)
        {
            dataStr = "數據運算完畢";
            if (GUILayout.Button("點擊生成配置文件"))
            {
                try
                {
                    CreateXml();
                    infoStr = "配置文件生成成功！";
                }
                catch (Exception e)
                {
                    infoStr = "配置文件生成失敗！錯誤為：" + e;
                }
            }
        }

        GUILayout.Label(infoStr);

        EditorGUILayout.EndVertical();
    }

    // 生成 XML 文件
    private void CreateXml()
    {
        string path = EditorUtility.OpenFolderPanel("選擇目標文件夾", "", "") + @"/prd.xml";
        StringBuilder sb = new StringBuilder();
        sb.Append(@"<?xml version=""1.0"" encoding=""UTF - 8"" standalone=""yes""?>");
        sb.Append('\n');
        sb.Append(@"<root xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">");
        sb.Append('\n');

        string xml = null;
        lock (obj)
        {
            // 在主線程中 從字典中拿出多線程放入的數據，進行解析
            foreach(var pair in prdDic)
            {
                sb.Append("<item>\n");
                sb.Append("    <p>" + pair.Key + "</p>\n");
                sb.Append("    <c>" + pair.Value + "</c>\n");
                sb.Append("</item>\n");
            }
            xml = sb.ToString();
            sb.Clear();
            xml.Remove(xml.Length - 1);
        }
        using(FileStream fs = Directory.Exists(path) ? File.OpenWrite(path) : File.Create(path))
        {
            byte[] bytes = Encoding.UTF8.GetBytes(xml);
            fs.Write(bytes, 0, bytes.Length);
            fs.Flush();
            fs.Close();
        }
        lock (obj)
        {
            prdDic.Clear();
        }
    }

    // 根據 傳入 C 值，計算該C值下，最小暴擊范圍的平均暴擊率
    private static double PFromC(double c)
    {
        double dCurP = 0d;
        double dPreSuccessP = 0d;
        double dPE = 0;
        int nMaxFail = (int)Math.Ceiling(1d / c);
        for (int i = 1; i <= nMaxFail; ++i)
        {
            dCurP = Math.Min(1d, i * c) * (1 - dPreSuccessP);
            dPreSuccessP += dCurP;
            dPE += i * dCurP;
        }
        return 1d / dPE;
    }

    // 根據傳入的暴擊率，計算 PRD 算法中的系數 C
    private static double CFromP(double p)
    {
        double dUp = p;
        double dLow = 0d;
        double dMid = p;
        double dPLast = 1d;
        while (true)
        {
            dMid = (dUp + dLow) / 2d;
            double dPtested = PFromC(dMid);

            if (Math.Abs(dPtested - dPLast) <= 0.00005d) break;

            if (dPtested > p) dUp = dMid;
            else dLow = dMid;

            dPLast = dPtested;
        }

        return dMid;
    }
}

3.洗牌算法

/// <summary>
/// Knuth-Durstenfeld Shuffle算法，效率最高，會打亂原數組，時間復雜度O(n) 空間復雜度O(1)
/// </summary>
/// <typeparam name="T">數組類型</typeparam>
/// <param name="_array">目標數組</param>
public void KnuthDurstenfeldShuffle<T>(T[] _array)
{
    int rand;
    T tempValue;
    for (int i = 0; i < _array.Length; i++)
    {
        rand = Random.Range(0, _array.Length - i);
        tempValue = _array[rand];
        _array[rand] = _array[_array.Length - 1 - i];
        _array[_array.Length - 1 - i] = tempValue;
    }
}

4.權重概率算法

//probs為權重數組, 且權重由大到小排序
float Choose (float[] probs) {
    float total = 0;
    foreach (float elem in probs) {
        total += elem;
    }
    float randomPoint = Random.value * total;
    for (int i= 0; i < probs.Length; i++) {
        if (randomPoint < probs[i]) {
            return i;
        }
        else {
            randomPoint -= probs[i];
        }
    }
    return probs.Length - 1;
}

5.在一個空心圓范圍內隨機生成物體

using UnityEngine;
using System.Collections;

public class RandomRadius : MonoBehaviour {
    public GameObject prefabs;
    // Use this for initialization
    void Start () {
        for (int i = 0; i < 1000; i++) {
            Vector2 p = Random.insideUnitCircle*3;
            Vector2 pos = p.normalized*(2+p.magnitude);
            Vector3 pos2 = new Vector3(pos.x,0,pos.y);
            Instantiate(prefabs,pos2,Quaternion.identity);
        }
    }
}

 6.從一個數組中隨機選擇指定個數且不重復的元素

int[] spawnPoints = {1, 5, 6, 8, 9, 20, 15, 10, 13};

int[] ChooseSet (int numRequired) {
    int[] result = new Transform[numRequired];
    int numToChoose = numRequired;
    for (int numLeft = spawnPoints.Length; numLeft > 0; numLeft--) {
        float prob = (float)numToChoose/(float)numLeft;
        if (Random.value <= prob) {
            numToChoose--;
            result[numToChoose] = spawnPoints[numLeft - 1];
            if (numToChoose == 0) {
                break;
            }
        }
    }
    return result;
}

7.在一個球體內生成隨機點

var randWithinRadius = Random.insideUnitSphere * radius;

 8.遵循高斯分布的隨機算法(lua實現)

function randomNormalDistribution()
    local u, v, w, c = 0, 0, 0, 0
    while(w == 0 or w >= 1)
    do
        --//獲得兩個（-1,1）的獨立隨機變量
        u = math.random() * 2 - 1
        v = math.random() * 2 - 1
        w = u * u + v * v
    end
    --//這里就是 Box-Muller轉換
    c = math.sqrt((-2 * math.log(w)) / w)
    --//返回2個標准正態分布的隨機數，封裝進一個數組返回
    --//當然，因為這個函數運行較快，也可以扔掉一個
    --//return [u*c,v*c];
    return u * c
end

function getNumberInNormalDistribution(mean, std_dev)
    return mean + (randomNormalDistribution() * std_dev)
end
--//參數1表示期望值, 參數二表示差值范圍
getNumberInNormalDistribution(180, 10)