游戏中的随机算法

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('
');
        sb.Append(@"<root xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">");
        sb.Append('
');

        string xml = null;
        lock (obj)
        {
            // 在主线程中 从字典中拿出多线程放入的数据，进行解析
            foreach(var pair in prdDic)
            {
                sb.Append("<item>
");
                sb.Append("    <p>" + pair.Key + "</p>
");
                sb.Append("    <c>" + pair.Value + "</c>
");
                sb.Append("</item>
");
            }
            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)