【cocos creator】抽卡游戏随机数生成，权重随机

先按星级权重随机，再按该星级内卡片权重随机

//Search.ts
import Util from "./Util";

const { ccclass, property } = cc._decorator;


@ccclass
export default class NewClass extends cc.Component {

    @property(cc.Node)
    label: cc.Node = null;

    @property
    text: string = 'hello';
    private table: any = null;
    private Indexes: Array<any> = [];//索引数组，记录每个等级开始数组下标

    // LIFE-CYCLE CALLBACKS:

    onLoad() {
        //table.json放在resources文件夹下
        Util.lodeJson("table", (table) => {
            cc.log("加载json文件成功", table)
            this.table = table;
            Util.sortArr(this.table.things);
            var arr = this.table.things;
            for (var i = 0; i < arr.length; i++) {
                if (arr[i].id % 1000 == 1) {
                    var temp: any = {};
                    temp.id = arr[i].id;
                    temp.index = i;
                    this.Indexes.push(temp);
                }
            }
        })
    }

    findByIndex(id) {
        if (!this.table) return;
        if (id < 1000) return false;
        var index1 = Util.fix(id / 1000) * 1000;
        var arr = this.table.things;

        var index = this.Indexes.findIndex(value => { return value.id > index1 })
        var StartIndex = this.Indexes[index].index;
        return arr[StartIndex + id % 1000 - 1];
    }

    getLevelArr(indexesArr: Array<any>, arr: Array<any>, level) {
        var indexStart = indexesArr.findIndex(value => { return value.id > level * 1000 });
        var indexEnd = indexesArr.findIndex(value => { return value.id > (level + 1) * 1000 });
        if (indexEnd == -1) {
            indexEnd = undefined;
            var levelArr = arr.slice(indexesArr[indexStart].index);
            return levelArr;
        }
        var levelArr = arr.slice(indexesArr[indexStart].index, indexesArr[indexEnd].index);
        return levelArr;
    }

    /**获取权重随机对象 */
    getRandByWeight() {
        if (!this.table) return;
        var level = Util.getRandomByWeight(this.table.level_weight).level;
        var levelArr = this.getLevelArr(this.Indexes, this.table.things, level);
        return Util.getRandomByWeight(levelArr);
    }

    start() {

    }

    onBtnClick() {
        if (!this.table) return;
        var arr = {};
        for (var i = 0; i < 100; i++) {
            var id = this.getRandByWeight().id;
            if (!arr[id]) {
                arr[id] = 1;
            }
            else {
                arr[id] += 1;
            }
        }
        var str = "";
        for (var value in arr) {
            if (parseInt(value) % 1000 == 1) str += "\n\n⭐ " + Util.fix(parseInt(value) / 1000) + "   ";
            str += value + ":" + arr[value] + "   ";
        }
        Util.setLabelString(this.label, str);
        cc.log(arr);
    }

    // update (dt) {}
}

//util.ts
const { ccclass, property } = cc._decorator;

@ccclass
export default class Util {

    public static isValidNode(node) {
        return node && node.isValid;
    }
    /**
     * 随机一个范围 min~max 的整数 
     * @param {*} min min为一个整数或者为一个2元素的数组
     * @param {*} max max为整数或者没有
     */
    public static randomInt(min, max) {
        if (max === undefined) {
            max = min[1];
            min = min[0];
        }
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }

    public static lodeJson(name: string, callBsck: any) {
        cc.loader.loadRes("json/" + name, cc.Asset, (err, asset) => {
            if (err) {
                cc.log("加载json文件出错", err);
            }
            if (callBsck) callBsck(asset.json);
        })
    }

    public static setLabelString(node: cc.Node, str: string) {
        if (!this.isValidNode(node)) return;
        var label = node.getComponent(cc.Label);
        if (!label) return;
        label.string = str;
    }
    //data为属性，list为数组名
    public static sortData(a, b, desc?,) {
        if (desc == false) {
            // 降序排列
            return b["id"] - a["id"]
        } else {
            // 升序排列
            return a["id"] - b["id"]
        }
    }
    /**数组排序 */
    public static sortArr(list: []) {
        list.sort(this.sortData);
    }
    /**
     * 保留指定位数的小数（不强制）0会自动省去
     * @param {*} num 数字
     * @param {*} fixTo 要保留的小数位数
     * @param {*} isRounding 四舍五入/向下取整(默认为向下取整)
     */
    public static fix(num, fixTo?, isRounding?) {
        if (typeof (String)) num = parseInt(num);
        num *= 1;
        var exp = Math.pow(10, fixTo || 0);
        if (isRounding) {
            num = Math.floor(num.toFixed(fixTo) * exp) / exp;
        } else {
            num = Math.floor(num * exp) / exp;
        }
        return num;
    }
    /**按权重随产生机值,返回随机到的对象
     * weights_arr{
     * weight:10,
     * }
    */
    public static getRandomByWeight(weights_arr) {
        var total_weight = weights_arr.reduce((total, w) => { return total + w.weight }, 0);
        var rand = Math.random() * total_weight;
        for (var i = 0; i < weights_arr.length; i++) {
            rand = rand - Number(weights_arr[i].weight);
            if (rand <= 0) {
                return weights_arr[i];
            }
        }
    }
}

//table.json

{
    "vsion": 1,
    "level_weight": [
        {
            "level": 1,
            "weight": 80
        },
        {
            "level": 2,
            "weight": 19
        },
        {
            "level": 3,
            "weight": 1
        }
    ],
    "things": [
        {
            "id": 1001,
            "weight": 20
        },
        {
            "id": 1002,
            "weight": 20
        },
        {
            "id": 1003,
            "weight": 20
        },
        {
            "id": 1004,
            "weight": 20
        },
        {
            "id": 1005,
            "weight": 20
        },
        {
            "id": 2001,
            "weight": 20
        },
        {
            "id": 2002,
            "weight": 20
        },
        {
            "id": 2003,
            "weight": 20
        },
        {
            "id": 3001,
            "weight": 20
        },
        {
            "id": 3002,
            "weight": 20
        }
    ]
}