PRD算法完整实现指南

真随机: 🗡️🗡️🗡️🗡️🗡️🗡️🗡️🗡️🗡️🗡️🗡️ (连续10次不暴击)
玩家感受: "这游戏有bug吧？说好的20%暴击呢？"

PRD: 🗡️💥🗡️🗡️💥🗡️💥🗡️🗡️🗡️💥 (更均匀分布)
玩家感受: "暴击率很稳定，游戏体验流畅"

P(N) = C × N
其中：
- P(N): 第N次尝试的触发概率
- C: PRD常数（根据目标概率计算）
- N: 连续未触发的次数

1 - (1-C)(1-2C)...(1-NC) = P

C ≈ P / (1 + 0.5 × P)

using UnityEngine;

public class PRDSystem
{
    private float prdConstant;
    private int currentCount;
    private float targetProbability;

    public PRDSystem(float probability)
    {
        targetProbability = probability;
        prdConstant = CalculateC(probability);
        currentCount = 0;
    }

    /// <summary>
    /// 计算PRD常数C，使用近似公式保证99.9%精度
    /// </summary>
    private float CalculateC(float p)
    {
        return p / (1f + 0.5f * p);
    }

    /// <summary>
    /// 尝试触发概率事件
    /// </summary>
    public bool TryTrigger()
    {
        currentCount++;
        float currentProbability = prdConstant * currentCount;

        if (UnityEngine.Random.value < currentProbability)
        {
            currentCount = 0; // 重置计数器
            return true;
        }

        return false;
    }

    /// <summary>
    /// 强制重置（用于特定游戏机制）
    /// </summary>
    public void Reset()
    {
        currentCount = 0;
    }
}

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;

[BurstCompile]
public struct PRDJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<float> targetProbabilities;
    [ReadOnly] public NativeArray<float> prdConstants;
    public NativeArray<int> currentCounts;
    public NativeArray<bool> results;
    public NativeArray<Unity.Mathematics.Random> randomGenerators;

    public void Execute(int index)
    {
        var rand = randomGenerators[index];
        currentCounts[index]++;

        float currentProbability = prdConstants[index] * currentCounts[index];
        bool triggered = rand.NextFloat() < currentProbability;

        if (triggered)
        {
            currentCounts[index] = 0;
        }

        results[index] = triggered;
        randomGenerators[index] = rand;
    }
}

public class HighPerformancePRD
{
    private NativeArray<float> prdConstants;
    private NativeArray<int> currentCounts;
    private NativeArray<Unity.Mathematics.Random> randomGenerators;

    public void Initialize(int maxUnits, float[] probabilities)
    {
        prdConstants = new NativeArray<float>(maxUnits, Allocator.Persistent);
        currentCounts = new NativeArray<int>(maxUnits, Allocator.Persistent);
        randomGenerators = new NativeArray<Unity.Mathematics.Random>(maxUnits, Allocator.Persistent);

        for (int i = 0; i < maxUnits; i++)
        {
            prdConstants[i] = probabilities[i] / (1f + 0.5f * probabilities[i]);
            currentCounts[i] = 0;
            randomGenerators[i] = new Unity.Mathematics.Random((uint)(i + 1));
        }
    }

    public NativeArray<bool> ProcessProbabilities(float[] targetProbabilities)
    {
        int count = targetProbabilities.Length;
        var results = new NativeArray<bool>(count, Allocator.TempJob);
        var targetProbs = new NativeArray<float>(count, Allocator.TempJob);

        for (int i = 0; i < count; i++)
        {
            targetProbs[i] = targetProbabilities[i];
        }

        var job = new PRDJob
        {
            targetProbabilities = targetProbs,
            prdConstants = prdConstants,
            currentCounts = currentCounts,
            results = results,
            randomGenerators = randomGenerators
        };

        JobHandle jobHandle = job.Schedule(count, 64);
        jobHandle.Complete();

        targetProbs.Dispose();
        return results;
    }

    public void Dispose()
    {
        if (prdConstants.IsCreated) prdConstants.Dispose();
        if (currentCounts.IsCreated) currentCounts.Dispose();
        if (randomGenerators.IsCreated) randomGenerators.Dispose();
    }
}

public class CritSystem : MonoBehaviour
{
    [SerializeField] private float baseCritChance = 0.2f; // 20%基础暴击率
    [SerializeField] private float critDamageMultiplier = 2.0f;

    private PRDSystem critPRD;
    private CharacterStats stats;

    private void Awake()
    {
        // 初始化PRD系统
        float totalCritChance = baseCritChance; // + 装备加成 + 技能加成
        critPRD = new PRDSystem(totalCritChance);
    }

    public float CalculateDamage(float baseDamage)
    {
        if (critPRD.TryTrigger())
        {
            // 触发暴击！
            float critDamage = baseDamage * critDamageMultiplier;
            ShowCritEffect(); // 显示暴击特效
            return critDamage;
        }

        return baseDamage;
    }

    private void ShowCritEffect()
    {
        // 实例化暴击特效
        // 播放暴击音效
        // 显示暴击数字
    }
}

[System.Serializable]
public class DropData
{
    public GameObject itemPrefab;
    public float dropChance;     // 基础掉落概率
    public int minQuantity = 1;
    public int maxQuantity = 1;
}

public class DropSystem : MonoBehaviour
{
    [SerializeField] private DropData[] dropTable;
    private PRDSystem[] dropPRDSystems;

    private void Awake()
    {
        // 为每种掉落物初始化PRD系统
        dropPRDSystems = new PRDSystem[dropTable.Length];
        for (int i = 0; i < dropTable.Length; i++)
        {
            dropPRDSystems[i] = new PRDSystem(dropTable[i].dropChance);
        }
    }

    public void ProcessDrops(Vector3 dropPosition)
    {
        for (int i = 0; i < dropTable.Length; i++)
        {
            if (dropPRDSystems[i].TryTrigger())
            {
                // 计算掉落数量
                int quantity = UnityEngine.Random.Range(
                    dropTable[i].minQuantity,
                    dropTable[i].maxQuantity + 1
                );

                // 生成掉落物
                for (int j = 0; j < quantity; j++)
                {
                    Vector3 randomOffset = new Vector3(
                        UnityEngine.Random.Range(-1f, 1f),
                        0,
                        UnityEngine.Random.Range(-1f, 1f)
                    );

                    Instantiate(
                        dropTable[i].itemPrefab,
                        dropPosition + randomOffset,
                        Quaternion.identity
                    );
                }
            }
        }
    }
}

// SIMD优化 - 一次处理4个PRD计算
public Vector4 ProcessPRDVectorized(Vector4 probabilities, Vector4 counts)
{
    Vector4 constants = probabilities / (Vector4.one + probabilities * 0.5f);
    Vector4 currentProbs = constants * counts;
    Vector4 randomValues = new Vector4(
        UnityEngine.Random.value,
        UnityEngine.Random.value,
        UnityEngine.Random.value,
        UnityEngine.Random.value
    );

    Vector4 results = Vector4.Less(randomValues, currentProbs);
    return results;
}

public class PRDCache
{
    private static Dictionary<float, float> cValueCache = new Dictionary<float, float>();

    public static float GetCachedCValue(float probability)
    {
        if (cValueCache.TryGetValue(probability, out float cachedC))
        {
            return cachedC;
        }

        float newC = probability / (1f + 0.5f * probability);
        cValueCache[probability] = newC;
        return newC;
    }
}

#if UNITY_EDITOR
using UnityEditor;

[CustomEditor(typeof(CritSystem))]
public class CritSystemEditor : Editor
{
    private float[] testResults = new float[1000];

    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();

        CritSystem critSystem = (CritSystem)target;

        if (GUILayout.Button("运行PRD测试 (1000次)"))
        {
            RunPRDTest(critSystem);
        }

        if (testResults[0] != 0)
        {
            float average = 0;
            for (int i = 0; i < testResults.Length; i++)
            {
                average += testResults[i];
            }
            average /= testResults.Length;

            EditorGUILayout.HelpBox(
                $"测试完成!\n" +
                $"理论暴击率: {critSystem.GetBaseCritChance() * 100}%\n" +
                $"实际暴击率: {average * 100:F1}%\n" +
                $"最大连续未暴击: {FindMaxStreak(testResults)}\n" +
                $"分布均匀性: {CalculateDistributionQuality(testResults):F2}",
                MessageType.Info
            );
        }
    }

    private void RunPRDTest(CritSystem critSystem)
    {
        PRDSystem testPRD = new PRDSystem(critSystem.GetBaseCritChance());

        for (int i = 0; i < testResults.Length; i++)
        {
            testResults[i] = testPRD.TryTrigger() ? 1f : 0f;
        }
    }

    private int FindMaxStreak(float[] results)
    {
        int maxStreak = 0;
        int currentStreak = 0;

        for (int i = 0; i < results.Length; i++)
        {
            if (results[i] == 0)
            {
                currentStreak++;
                maxStreak = Mathf.Max(maxStreak, currentStreak);
            }
            else
            {
                currentStreak = 0;
            }
        }

        return maxStreak;
    }

    private float CalculateDistributionQuality(float[] results)
    {
        // 计算实际分布与理想分布的偏差
        // 返回0-1的值，1表示完美分布
        float total = 0;
        for (int i = 0; i < results.Length; i++)
        {
            total += results[i];
        }

        float expected = results.Length * 0.2f; // 假设20%概率
        return 1f - Mathf.Abs(total - expected) / expected;
    }
}
#endif

public class InterventionPRD : PRDSystem
{
    private int maxConsecutiveFailures = 50; // 强制保底机制

    public override bool TryTrigger()
    {
        if (currentCount >= maxConsecutiveFailures)
        {
            currentCount = 0;
            return true; // 强制触发
        }

        return base.TryTrigger();
    }
}