xianyudefanji/assets/Scripts/Manager/DiaoLuoManager1.ts

import User from "../../FrameWork/User/User";
import Common5 from "../../Platform/th/Common5";
import BagManager from "./BagManager";
import InterfaceManager from "./InterfaceManager";
import LevelUpManager from "./LevelUpManager";
import ShipuManager from "./ShipuManager";
import TanWeiManager from "./TanWeiManager";
enum PINGZHI {
    lock,
    gray,
    green,
    blue,
    purple,
    orange,
    color
}
type WUPINGGAILV = {
    level: number,
    tanwei: number,
    miandian: number,
    zhuzi: number,
    qian: number,
    dengji: number,
}
type PINGZHIGAILV = {
    level: number,
    green: number,
    blue: number,
    purple: number,
    orange: number,
    color: number,
}
let wuPingGaiLv: WUPINGGAILV[] = [
    { level: 100, tanwei: 30, miandian: 45, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 200, tanwei: 30, miandian: 45, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 300, tanwei: 30, miandian: 45, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 600, tanwei: 30, miandian: 45, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 900, tanwei: 30, miandian: 45, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 1200, tanwei: 25, miandian: 50, zhuzi: 5, qian: 10, dengji: 10 },
    { level: 1500, tanwei: 20, miandian: 55, zhuzi: 5, qian: 10, dengji: 10 },
]

let pingZhiGaiLv: PINGZHIGAILV[] = [
    { level: 100, green: 75, blue: 20, purple: 3, orange: 1, color: 1 },
    { level: 200, green: 70, blue: 20, purple: 8, orange: 1, color: 1 },
    { level: 300, green: 60, blue: 25, purple: 12, orange: 2, color: 1 },
    { level: 600, green: 50, blue: 30, purple: 15, orange: 3, color: 2 },
    { level: 900, green: 40, blue: 20, purple: 20, orange: 15, color: 5 },
    { level: 1200, green: 45, blue: 15, purple: 15, orange: 15, color: 10 },
]

let zhuzis = [3730, 3731, 3732, 3733, 3734, 3735, 3736]

let otherWuPing = [3738, 3739]

export default class DiaoLuoManager1 {

    public static getDiaoLuo() {
        //掉落(根据等级选择概率，先根据物品掉落概率随机物品，再根据品质概率随机物品的品质，检查自身当前品质，随机的物品品质必须必自身当前品质高，如果自身当前等级对应的物品品质都到顶了，就不再掉落)
        // let shiPuArray = User.getShiPuArray()
        // let tanWeiArray = User.getTanweiArray()
        // let otherArray = [3730, 3731, 3732, 3733, 3734, 3735, 3736] //珠子

        let level = User.getMyLevel()


        //随机物品
        if (level >= wuPingGaiLv[0].level) {
            let wuping = this.getWuPingByGaiLv()
            let pingzhi = this.getPingZhiByGaiLv(wuping)
            return { wuping: wuping, pingzhi: pingzhi }
        }
    }

    public static getDiaoLuoArray(num) {
        //掉落(根据等级选择概率，先根据物品掉落概率随机物品，再根据品质概率随机物品的品质，检查自身当前品质，随机的物品品质必须必自身当前品质高，如果自身当前等级对应的物品品质都到顶了，就不再掉落)
        // let shiPuArray = User.getShiPuArray()
        // let tanWeiArray = User.getTanweiArray()
        // let otherArray = [3730, 3731, 3732, 3733, 3734, 3735, 3736] //珠子

        let level = User.getMyLevel()


        //随机多个物品
        let arr = []
        let curRandom = 0
        let maxRandom = 20
        if (level >= wuPingGaiLv[0].level) {
            while (arr.length < num) {
                let diaoluo = this.getDiaoLuo()
                if (!diaoluo) {
                    continue
                }
                if (arr.length == 0) {
                    arr.push(diaoluo)
                } else {
                    let isHave = false
                    let isHaveZhuZi = false //珠子只允许出一个
                    for (let i = 0; i < arr.length; i++) {
                        if (arr[i].wuping.isZhuZi) {
                            isHaveZhuZi = true
                            break
                        }
                    }

                    if (User.getMyLevel() < 1200) {
                        let zhuziNum = 0
                        for (let i = 0; i < zhuzis.length; i++) {
                            if (BagManager.getBagGoodNums(zhuzis[i])) {
                                zhuziNum++
                            }
                        }
                        if (zhuziNum >= 5) {//留2个1200级后才出
                            isHaveZhuZi = true
                        }
                    } else {
                        if (BagManager.isHaveAllGood(zhuzis)) {
                            isHaveZhuZi = true
                        }
                    }

                    for (let j = 0; j < arr.length; j++) {
                        if (isHaveZhuZi && zhuzis.includes(diaoluo.wuping.id)) {
                            isHave = true
                            break
                        }
                        if (arr[j].wuping.isShiPu && diaoluo.wuping.isShiPu && arr[j].wuping.id == diaoluo.wuping.id) {
                            isHave = true
                            break
                        }
                        if (arr[j].wuping.isTanWei && diaoluo.wuping.isTanWei && arr[j].wuping.id == diaoluo.wuping.id) {
                            isHave = true
                            break
                        }
                    }
                    if (!isHave) {
                        arr.push(diaoluo)
                    } else {
                        curRandom++
                        if (curRandom >= maxRandom) {
                            for (let i = arr.length - 1; i < 3; i++) {
                                arr.push(this.getRandomInt(0, 1) == 0 ? { id: 0, isQian: true, isAD: false } : { id: 0, isDengJi: true, isAD: false })
                            }
                            break
                        }
                    }
                }
            }
        }

        //第一次掉落，必定出一个橙色和珠子
        // User.setShouCiDiaoLuo(1)
        if (User.getShouCiDiaoLuo() == 1) {
            User.setShouCiDiaoLuo(-1)
            let maxLevel = 6
            let shiPuArray = User.getShiPuArray()
            let orangeIndex = 0
            for (let i = 0; i < arr.length; i++) {
                if (arr[i].wuping.isShiPu && arr[i].pingzhi < 5) {
                    arr[i].pingzhi = PINGZHI.orange
                    orangeIndex = i
                    break
                }
                if (arr[i].wuping.isTanWei && arr[i].pingzhi < 5) {
                    arr[i].pingzhi = PINGZHI.orange
                    orangeIndex = i
                    break
                }
                if (arr[i].isQian && arr[i].pingzhi < 5) {
                    arr[i].pingzhi = PINGZHI.orange
                    orangeIndex = i
                    break
                }
                if (arr[i].isDengJi && arr[i].pingzhi < 5) {
                    arr[i].pingzhi = PINGZHI.orange
                    orangeIndex = i
                    break
                }
            }

            let isHaveZhuZi = false //珠子只允许出一个
            for (let i = 0; i < arr.length; i++) {
                if (arr[i].wuping.isZhuZi) {
                    isHaveZhuZi = true
                    break
                }
            }
            //没珠子就替换一个变成珠子
            if (!isHaveZhuZi) {
                for (let i = 0; i < arr.length; i++) {
                    if (i != orangeIndex) {
                        arr[i].wuping = { id: zhuzis[0], isZhuZi: true, isAD: false }
                        break
                    }
                }
            }
        }

        //必须保证有一个摊位或者面点
        let isHaveShiPu = false
        let isHaveTanWei = false
        for (let i = 0; i < arr.length; i++) {
            if (arr[i].wuping.isShiPu) {
                isHaveShiPu = true
                break
            }
            if (arr[i].wuping.isTanWei) {
                isHaveTanWei = true
                break
            }
        }
        if (!isHaveShiPu && !isHaveTanWei) {
            //已经解锁的面点并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
            let shiPuUnlocks = this.getShiPuUnlocks()
            //已经解锁的摊位并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
            let tanWeiUnlocks = this.getTanWeiUnlocks()
            if (shiPuUnlocks.length > 0) {
                for (let i = 0; i < arr.length; i++) {
                    if (!zhuzis.includes(arr[i].wuping.id)) { //不替换珠子
                        arr[i].wuping = { id: shiPuUnlocks[i].id, isShiPu: true, isAD: false }
                        arr[i].pingzhi = ShipuManager.getShipuUserDate(shiPuUnlocks[i].id).level + 1
                        break
                    }
                }
            } else if (tanWeiUnlocks.length > 0) {
                for (let i = 0; i < arr.length; i++) {
                    if (!zhuzis.includes(arr[i].wuping.id)) { //不替换珠子
                        arr[i].wuping = { id: tanWeiUnlocks[i].id, isTanWei: true, isAD: false }
                        arr[i].pingzhi = TanWeiManager.getShipuUserDate(tanWeiUnlocks[i].id).level + 1
                        break
                    }
                }
            }
        }

        //是否看广告
        // 随机出来的物品需不需要看广告需要与最新解锁的同类物品的蓝色等级的倍数的1/5进行比较，小于最新解锁物品的蓝色倍数就不需要看广告
        for (let i = 0; i < arr.length; i++) {
            if (arr[i].wuping.isShiPu) {
                let curNewId = ShipuManager.getUnLockNum() - 1
                if (ShipuManager.getShipuInComeByIdAndLevel(arr[i].wuping.id, arr[i].pingzhi) >= ShipuManager.getShipuInComeByIdAndLevel(curNewId, 3) / 5  && arr[i].pingzhi>=3) {
                    arr[i].wuping.isAD = true
                }
            }

            if (arr[i].wuping.isTanWei) {
                let curNewId = TanWeiManager.getUnLockNum() - 1
                if (TanWeiManager.getShipuInComeByIdAndLevel(arr[i].wuping.id, arr[i].pingzhi) >= TanWeiManager.getShipuInComeByIdAndLevel(curNewId, 3) / 5  && arr[i].pingzhi>=3) {
                    arr[i].wuping.isAD = true
                }
            }

            if (arr[i].wuping.isQian && arr[i].pingzhi > 2) {
                arr[i].wuping.isAD = true
            }

            if (arr[i].wuping.isDengJi && arr[i].pingzhi > 2) {
                arr[i].wuping.isAD = true
            }
        }

        return arr
    }

    public static getWuPingByGaiLv() {
        let gailv_wuping = this.getWuPingGaiLvByMyLevel()
        //已经解锁的面点并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
        let shiPuUnlocks = this.getShiPuUnlocks()
        // let maxLevel = 6
        // for (let i = 0; i < shiPuArray.length; i++) {
        //     if (!shiPuArray[i].isLock && shiPuArray[i].level < maxLevel && gailv_pingzhi[pingzhi[shiPuArray[i].level + 1]] > 0) {
        //         shiPuUnlocks.push({ id: shiPuArray[i].id, isShiPu: true, isAD: false })
        //     }
        // }
        //已经解锁的摊位并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
        let tanWeiUnlocks = this.getTanWeiUnlocks()
        // for (let i = 0; i < tanWeiArray.length; i++) {
        //     if (!tanWeiArray[i].isLock && tanWeiArray[i].level < maxLevel && gailv_pingzhi[pingzhi[tanWeiArray[i].level + 1]] > 0) {
        //         tanWeiUnlocks.push({ id: tanWeiArray[i].id, isTanWei: true, isAD: false })
        //     }
        // }

        // 珠子
        let zhuZiUnlocks = []
        for (let i = 0; i < zhuzis.length; i++) {
            if (BagManager.getBagGoodNums(zhuzis[i]) <= 0) {
                zhuZiUnlocks.push({ id: zhuzis[i], isZhuZi: true, isAD: false })
            }
        }

        // 钱袋子
        let qiandaizi = []
        qiandaizi.push({ id: 3738, isQian: true, isAD: false })

        // 等级提升
        let levelup = []
        levelup.push({ id: 3739, isDengJi: true, isAD: false })

        //1-100
        let pingjun = 0
        let pingjunIndex = 0
        let allgailv = [gailv_wuping.tanwei, gailv_wuping.miandian, gailv_wuping.zhuzi, gailv_wuping.qian, gailv_wuping.dengji]
        if (tanWeiUnlocks.length == 0) {
            pingjun = gailv_wuping.tanwei
            pingjunIndex++
            allgailv[0] = 0
        }
        if (shiPuUnlocks.length == 0) {
            pingjun += gailv_wuping.miandian
            pingjunIndex++
            allgailv[1] = 0
        }
        if (zhuZiUnlocks.length == 0) {
            pingjun += gailv_wuping.zhuzi
            pingjunIndex++
            allgailv[2] = 0
        }

        //平均分配
        let pingjunByIndex = Math.floor(pingjun / (5 - pingjunIndex))
        for (let i = 0; i < allgailv.length; i++) {
            if (allgailv[i] != 0) {
                allgailv[i] += pingjunByIndex
            }
        }
        //算平均分配后的位置
        for (let j = 0; j < allgailv.length; j++) {
            if (allgailv[j] != 0 && j != 0) {
                allgailv[j] += allgailv[j - 1]
            }
        }
        allgailv[allgailv.length - 1] = 100//上面向下取整所以这里保证最后一个一定是100
        console.log("allgailv==", allgailv)

        let curRandom = this.getRandomInt(1, 100)
        let wuping
        if (curRandom <= allgailv[0]) {
            //随机到摊位
            wuping = tanWeiUnlocks[this.getRandomInt(0, tanWeiUnlocks.length - 1)]
        } else if (curRandom <= allgailv[1]) {
            //随机到面点
            wuping = shiPuUnlocks[this.getRandomInt(0, shiPuUnlocks.length - 1)]
        } else if (curRandom <= allgailv[2]) {
            //随机到珠子
            wuping = zhuZiUnlocks[this.getRandomInt(0, zhuZiUnlocks.length - 1)]
        } else if (curRandom <= allgailv[3]) {
            //随机到钱袋子
            wuping = qiandaizi[0]
        } else if (curRandom <= allgailv[4]) {
            //随机到等级
            wuping = levelup[0]
        }

        return wuping
    }

    public static getPingZhiByGaiLv(wuping) {
        let num = this.getRandomInt(1, 100)
        let gailv = this.getPingZhiGaiLvByMyLevel()
        if (zhuzis.includes(wuping.id)) {
            return this.getRandomInt(1, 7)
        } else if (otherWuPing.includes(wuping.id)) {
            // { level: 100, green: 80, blue: 20, purple: 0, orange: 0, color: 0 },
            let maxLevel = 6
            let _gailv = [gailv.green, gailv.blue, gailv.purple, gailv.orange, gailv.color]
            for (let i = 0; i < _gailv.length; i++) {
                if (_gailv[i] == 0) {
                    maxLevel--
                }
            }
            return this.getRandomInt(1, maxLevel)
        } else {
            let level
            if (wuping.isShiPu) {
                level = ShipuManager.getShipuUserDate(wuping.id).level
            } else if (wuping.isTanWei) {
                level = TanWeiManager.getShipuUserDate(wuping.id).level
            }
            let _green = gailv.green
            if (gailv.green != 0) {
                if (level >= PINGZHI.green) {
                    gailv.green = 0
                }
            }
            let _blue = gailv.blue
            if (gailv.blue != 0) {
                if (level >= PINGZHI.blue) {
                    gailv.blue = 0
                } else {
                    gailv.blue = _green + gailv.blue
                }
            }
            let _purple = gailv.purple
            if (gailv.purple != 0) {
                if (level >= PINGZHI.purple) {
                    gailv.purple = 0
                } else {
                    gailv.purple = _green + _blue + gailv.purple
                }
            }
            let _orange = gailv.orange
            if (gailv.orange != 0) {
                if (level >= PINGZHI.orange) {
                    gailv.orange = 0
                } else {
                    gailv.orange = _green + _blue + _purple + gailv.orange
                }
            }
            let _color = gailv.color
            if (gailv.color != 0) {
                if (level >= PINGZHI.color) {
                    gailv.color = 0
                } else {
                    gailv.color = _green + _blue + _purple + _orange + gailv.color
                }
            }

            let pingzhi
            if (num > 0 && num <= gailv.green) {
                pingzhi = PINGZHI.green
            } else if (num > gailv.green && num <= gailv.blue) {
                pingzhi = PINGZHI.blue
            } else if (num > gailv.blue && num <= gailv.purple) {
                pingzhi = PINGZHI.purple
            } else if (num > gailv.purple && num <= gailv.orange) {
                pingzhi = PINGZHI.orange
            } else if (num > gailv.orange && num <= gailv.color) {
                pingzhi = PINGZHI.color
            }
            return pingzhi
        }


    }

    public static getWuPingGaiLvByMyLevel() {
        let level = User.getMyLevel()
        let gailv
        for (let i = 0; i < wuPingGaiLv.length; i++) {
            if (level >= wuPingGaiLv[i].level) {
                gailv = Common5.deepClone(wuPingGaiLv[i])
            } else {
                break
            }
        }
        return gailv
    }

    public static getPingZhiGaiLvByMyLevel() {
        let level = User.getMyLevel()
        let gailv
        for (let i = 0; i < pingZhiGaiLv.length; i++) {
            if (level >= pingZhiGaiLv[i].level) {
                gailv = Common5.deepClone(pingZhiGaiLv[i])
            } else {
                break
            }
        }
        return gailv
    }

    public static getShiPuUnlocks() {
        let shiPuArray = User.getShiPuArray()
        let gailv_pingzhi = this.getPingZhiGaiLvByMyLevel()
        let pingzhi = ["", "", "green", "blue", "purple", "orange", "color"]
        //已经解锁的面点并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
        let shiPuUnlocks = []
        let maxLevel = 6
        for (let i = 0; i < shiPuArray.length; i++) {
            if (!shiPuArray[i].isLock && shiPuArray[i].level < maxLevel && gailv_pingzhi[pingzhi[shiPuArray[i].level + 1]] > 0) {
                shiPuUnlocks.push({ id: shiPuArray[i].id, isShiPu: true, isAD: false })
            }
        }
        return shiPuUnlocks
    }

    public static getTanWeiUnlocks() {
        let tanWeiArray = User.getTanweiArray()
        let gailv_pingzhi = this.getPingZhiGaiLvByMyLevel()
        let pingzhi = ["", "", "green", "blue", "purple", "orange", "color"]
        //已经解锁的摊位并且在当前等级对应的品质里面，超出等级段对应的品质不参与掉落
        let tanWeiUnlocks = []
        let maxLevel = 6
        for (let i = 0; i < tanWeiArray.length; i++) {
            if (!tanWeiArray[i].isLock && tanWeiArray[i].level < maxLevel && gailv_pingzhi[pingzhi[tanWeiArray[i].level + 1]] > 0) {
                tanWeiUnlocks.push({ id: tanWeiArray[i].id, isTanWei: true, isAD: false })
            }
        }
        return tanWeiUnlocks
    }

    /**
     * 随机数
     * @param min 最小数
     * @param max 最大数
     * @returns 
     */
    public static getRandomInt(min: number, max: number): number {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
}