jzhj2024server/Gameserver/App/process/FightProc.php

<?php

namespace loyalsoft;

/**
 * 战斗模块
 * @author c'y'zhao
 */
class FightProc {

    public const TowerGateId = 940011999;

    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    public static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::fight_settle:                                         # 6801 主线战斗结算
                return FightProc::Settle();
            case CmdCode::fight_PassGateTsPrizeReceive:                         # 6802 章节宝箱的领取
                return FightProc::PassGateTsPrizeReceive();
            case CmdCode::fight_selectGate:                                     # 6803 主线剧情关卡选择
                return FightProc::SelectGate();
            case CmdCode::fight_gateChallengeRewards:                           # 6804 挑战关卡: 领取奖励
                return FightProc::GateChallengeRewards();
            case CmdCode::fihgt_reliveCost:                                     # 6805 战斗: 复活花费
                return FightProc::ReliveCost();
            case CmdCode::fight_plotSav:                                        # 6806 主线剧情(已播放)回存
                return FightProc::PlotSav();
            case CmdCode::fight_sweep:                                          # 6807 主线扫荡
                return FightProc::FightSweep();
            case CmdCode::fight_startFight:                                     # 6808 主线剧情关卡开始挑战
                return self::StartFight();
            case CmdCode::fight_tower_RefreshSkills:                            # 6809 挑战关卡: 刷新初始技能
                return self::TowerRefreshSkills();
            case CmdCode::fight_tower_updatelocklist:                           # 6810 挑战关卡: 更新技能锁定列表
                return self::TowerUpdateLockskillList();
            case CmdCode::fight_rankInfo:                                       # 6811 获取主线关卡排行榜信息
                return self::GetRankInfo();
            case CmdCode::fight_rank_uidEquipInfo:                              # 6812 获取主线关卡榜内玩家的装备信息
                return self::GetUidEquipInfo_Rank();
            case CmdCode::fight_rank_GetMainGateRankRewardInfo:                 # 6813 获取通关荣誉榜信息
                return self::GetmainGate_RankRewardInfo();
            case CmdCode::fight_rank_GetFightPowerRankRewardInfo:               # 6814 获取战力荣誉榜信息
                return self::GetFightPower_RankRewardInfo();
            case CmdCode::fight_rank_ReceiveRankReward_MainGate:                # 6815 领取通关荣誉榜奖励
                return self::ReceiveRankReward_MainGate();
            case CmdCode::fight_rank_ReceiveRankReward_FightPower:              # 6816 领取战力荣誉榜奖励
                return self::ReceiveRankReward_FightPower();
            case CmdCode::fight_rank_IsExistRankReward:                         # 6817 是否存在未领取的荣誉榜奖励
                return self::IsExistRankReward();
            case CmdCode::fight_evolveUnlock:                                   # 6818 启灵解锁
                return self::EvolveUnlock();
            case CmdCode::fight_MainTZPass:                                     # 6819 主线挑战--通关
                return self::MainTZPass();
            case CmdCode::fight_MainTZGetReward:                                # 6820 主线挑战--领取奖励
                return self::MainTZGetReward();
            case CmdCode::fight_ResetChallange_RedMask:                         # 6821 每天重置挑战红点
                return self::ResetChallange_RedMask();
            case CmdCode::fight_lockSkill:                                      # 6822 封印/解封技能
                return self::LockSkill();
            case CmdCode::fight_buyLockSkillCount:                              # 6823 购买更多封印数量
                return self::BuySkillLockCount();
            case CmdCode::fight_rank_ReceiveRankReward:                         # 6824 排行奖励一键领取
                return self::ReceiveRankReward();
            default:
                Err(ErrCode::cmd_err);
        }
    }

    /**
     * 6823 购买更多技能封印数量
     */
    static function BuySkillLockCount() {
        list($n) = req()->paras;                                                # 解锁数量
        my_Assert($n > ctx()->privateData()->skillLockerNumber, ErrCode::paras_err); # 参数异常
        $amt = 0;
        foreach (explode(",", glc()->Skill_LockBtn_BuyCount_Cost) as $str) {
            list($cnt, $cost) = explode(':', $str);
            if ($cnt == $n) {
                $amt = $cost;
                break;
            }
        }
        my_Assert($amt > 0, "消耗元宝数量配置出错!");
        my_Assert(ctx()->base()->Consume_Cash($amt), ErrCode::notenough_cash_msg);
        ctx()->privateData()->skillLockerNumber = $cnt;
        UserProc::updateUserInfo();
        return Resp::ok();
    }

    /**
     * 6822 封印/解封技能
     */
    static function LockSkill() {
        list($skillTypeId) = req()->paras;                                      # 技能类型ID
        $pri = ctx()->privateData();
//        my_Assert(in_array($skillTypeId, $pri->skillUnlockRecord), "技能尚未解锁!");
        if (in_array($skillTypeId, $pri->skillReLocked)) {                      # 解封
            StlUtil::arrayRemove($pri->skillReLocked, $skillTypeId);
        } else {                                                                # 封印
            my_Assert(count($pri->skillReLocked) < $pri->skillLockerNumber, "超出封印上限!");
            $pri->skillReLocked[] = $skillTypeId;
            TaskProc::OnCloseSkill();
        }
        return Resp::ok(array("task" => ctx()->task,));
    }

    /**
     * 6821 每天重置挑战红点
     */
    static function ResetChallange_RedMask() {

        ctx()->privateState->challange_RedMask = 1;
        UserProc::updateUserInfo();
        return Resp::ok();
    }

    /**
     * 6819 主线挑战 -- 通关
     */
    static function MainTZPass() {
        list($gateId, $index, $killMonsterNum, $killBossNum) = req()->paras;                                   # 关卡id, 通关难度索引(1/2/3)
        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
//        isEditor() && $gateInfo = new Ins_GateInfo();
        $gateInfo = ctx()->gates->GateList->$gateId;
        my_Assert($gateInfo->pass, ErrCode::gate_GateNoUnlock);                 # 通关后解锁难度1
        my_Assert($gateInfo->tz_state + 1 >= $index, ErrCode::gate_GateNoUnlock); # 通关上一难度解锁当前难度

        FightProc::funUnlock_mainChallengeGate_State(true, $gateId, $index);
        $gateInfo->tz_state = $index;

        TaskProc::OnPassMainChallengeGate_X_Num($gateId, $index);
        TaskProc::OnKillCommonNumMonster($killMonsterNum);
        TaskProc::OnKillleaderNumMonster($killBossNum);
        
        TaskProc::Day7TaskReset();
        UserProc::updateUserInfo();
        return Resp::ok(array("task" => ctx()->task,
                    'funUnlockRecord' => ctx()->privateState->funUnlockRecord,
                    'funUnlockRecord_2' => ctx()->privateState->funUnlockRecord_2,
        ));
    }

    /**
     * 6820 主线挑战 -- 领取奖励
     */
    static function MainTZGetReward() {
        list($gateId, $index) = req()->paras;                                   # 关卡id, 通关难度索引(1/2/3)
        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
//        isEditor() && $gateInfo = new Ins_GateInfo();
        $gateInfo = ctx()->gates->GateList->$gateId;
        my_Assert($gateInfo->pass, ErrCode::gate_GateNoUnlock);                 # 通关后解锁难度1
        my_Assert($gateInfo->tz_state >= $index, ErrCode::gate_GateNoUnlock);   # 已解锁当前难度
        my_Assert(Bits::GetBitValue($gateInfo->tz_rewards, $index - 1) == false, ErrCode::gate_GatePriceHasReceive);
        $gateInfo->tz_rewards = Bits::SetBitValue($gateInfo->tz_rewards, $index - 1, true); # 更新领取记录

        $prize = "tz_reward" . $index;
        $mo = GameConfig::gate_getItem($gateId);
        StoreProc::AddMultiItemInStore($mo->$prize);
        UserProc::updateUserInfo();
        return Resp::ok(array(
                    'gold'=> ctx()->baseInfo->gold,
                    'cash'=> ctx()->baseInfo->cash,
                    'store'=> ctx()->store,
                    'reward' => StoreProc::$reward,
                    'reward_Gem' => StoreProc::$reward_Gem,
        ));
    }

    /**
     * 6818 启灵解锁
     * @return type
     */
    public static function EvolveUnlock() {
        list($type, $id) = req()->paras; //$id废弃 因为玩家可能不安顺序点

        if ($type == 1) {
            $nextId = ctx()->gates->evolveMaxId_left + 1;
            my_Assert($id == $nextId, ErrCode::err_const_no);

            $mo = GameConfig::evolve_getItem($nextId);
            my_Assert($mo != null, ErrCode::err_const_no);
            my_Assert(ctx()->baseInfo->level >= $mo->level, ErrCode::evolve_canotUnlock_levelLimit);
            my_Assert(ctx()->baseInfo->gold >= $mo->needGold_unlock, ErrCode::notenough_gold_msg);

            ctx()->baseInfo->Consume_Gold($mo->needGold_unlock);
            ctx()->gates->evolveMaxId_left = $nextId;

            TaskProc::OnCompleteNumQiLing();
        } else {
            $nextId = ctx()->gates->evolveMaxId_right + 1;
            my_Assert($id == $nextId, ErrCode::err_const_no);

            $dic = GameConfig::evolve();
            foreach ($dic as $key => $value) {
                if ($value->specificEvolveId == $nextId) {
                    $mo = $value;
                }
            }

            my_Assert(ctx()->baseInfo->level >= $mo->level, ErrCode::evolve_canotUnlock_levelLimit);
            my_Assert($mo != null, ErrCode::err_const_no);
            if ($mo->specificEvolveCost != null) {
                $cost = explode(',', $mo->specificEvolveCost);
                $costId = $cost[0];
                $costNum = $cost[1];
                my_Assert(StlUtil::dictHasProperty(ctx()->store->items, $costId) && ctx()->store->items->$costId >= $costNum, ErrCode::notenough_item);
                ctx()->store->removeItem($costId, $costNum);
            }
            ctx()->gates->evolveMaxId_right = $id;
            TaskProc::OnCompleteNumSpecialQiLing();
        }

        UserProc::updateUserInfo();
        $ret = array(
            'task' => ctx()->task,
            'gold' => ctx()->baseInfo->gold,
            'items' => ctx()->store->items,
            'evolveMaxId_right' => ctx()->gates->evolveMaxId_right,
            'evolveMaxId_left' => ctx()->gates->evolveMaxId_left,
        );
        return Resp::ok($ret);
    }

    /**
     * 6807 扫荡
     * @return type
     */
    public static function FightSweep() {
        //list($gateId) = req()->paras;

        $passGateId = ctx()->gates->maxPassGateId();
        my_Assert($passGateId != 0, ErrCode::gate_NoSweep);
        $mo = GameConfig::gate_getItem($passGateId);
        $gateName = $mo->gateName;
        $costTili = glc()->sweep_cost_tili;
        $curTili = ctx()->baseInfo->CurTili();
        my_Assert($curTili >= $costTili, ErrCode::notenough_tili);

        if (ctx()->privateState->honourCardShop_ts == 0) {
            $max = glc()->sweepMaxNum;
            my_Assert(ctx()->gates->fightSweepNum < $max, ErrCode::gate_SweepMaxNum_limit);
        }

        ctx()->gates->fightSweepNum += 1;
        ctx()->baseInfo->Consume_tili($costTili);

        $wavesArr = GameConfig::waves_getItemArray($passGateId);
        $count = count($wavesArr);
        $wavesMo = $wavesArr[$count - 1];

        $gold = $wavesMo->rewardGold;
        StoreProc::AddMultiItemInStore("1," . $gold);

        $oldLevel = ctx()->baseInfo->level;
        $exp = $wavesMo->rewardExp;
        StoreProc::AddMultiItemInStore("4," . $exp);
        $newLevel = ctx()->baseInfo->level;
        if ($wavesMo->rewardTuZhi != null) {
            $tuzhi = explode('-', $wavesMo->rewardTuZhi);
            $n = rand($tuzhi[0], $tuzhi[1]);
            $tuzhiArr = array();
            $item = GameConfig::item();
            foreach ($item as $id => $mo) {
                if ($mo->itemType == 100) {
                    $tuzhiArr[] = $id;
                }
            }
            for ($i = 0; $i < $n; $i++) {
                $index = rand(0, count($tuzhiArr) - 1);
                $goodsStr = $tuzhiArr[$index] . ',' . 1;
                $prizeArr[] = $goodsStr;
                StoreProc::AddMultiItemInStore($goodsStr);
            }
        }

        if ($wavesMo->rewardGem != null) {
            $goodsStr = self::sweepRandReward($wavesMo->rewardGem);
            $str = explode(';', $goodsStr);
            $dic = GameConfig::gem();
            foreach ($str as $value) {
                $list = explode(',', $value);
                $posId = rand(1, 6);
                $qual = $list[0];
                foreach ($dic as $key => $gemMo) {
                    if ($gemMo->qual == $qual && $gemMo->position == $posId && $gemMo->isfixed_predicateId == 0) {
                        $gemStr = $gemMo->typeId . ',' . $list[1];

                        SystemProc::GetGem_GreaterOrangeQual_SweepMainGateIndex(req()->zoneid, ctx()->baseInfo->name, Ins_GateInfo::gateNum($passGateId), $gateName, $gemMo->typeId);
                        //StoreProc::PutGemInStore($gemMo->typeId, $list[1]);
                        StoreProc::AddMultiItemInStore($gemStr);
                        break;
                    }
                }
            }
        }

        TaskProc::OnFightSweepGate();
        UserProc::updateUserInfo();
        $ret = array(
            'gold' => ctx()->baseInfo->gold,
            'cash' => ctx()->baseInfo->cash,
            'tili' => ctx()->baseInfo->tili,
            'tili_ts' => ctx()->baseInfo->tili_ts,
            'xp' => ctx()->baseInfo->xp,
            'maxXp' => ctx()->baseInfo->maxXp,
            'level' => ctx()->baseInfo->level,
            'fightSweepNum' => ctx()->gates->fightSweepNum,
            //'prizeArr' => $prizeArr,
            'store' => ctx()->store,
            'task' => ctx()->task,
            'reward' => StoreProc::$reward,
            'reward_Gem' => StoreProc::$reward_Gem,
            'oldLevel' => $oldLevel,
            'newLevel' => $newLevel,
        );
        return Resp::ok($ret);
    }

    static function sweepRandReward($rewardStr) {
        $ctxArr = explode(';', $rewardStr);
        $numArr = explode('-', $ctxArr[0]);
        $num = rand($numArr[0], $numArr[1]);

        $rand = 0;
        $itemArr = explode(',', $ctxArr[1]);
        foreach ($itemArr as $value) {
            $arr = explode(':', $value);
            $itemId = $arr[0];
            $per = $arr[1];

            $rand += $per;
        }

        $res = "";
        for ($i = 0; $i < $num; $i++) {
            $start = 0;
            $end = 0;
            $randNum = rand(1, $rand);
            $id = 0;
            foreach ($itemArr as $str) {
                $arr = explode(':', $str);
                $itemId = $arr[0];
                $per = $arr[1];

                $end += $per;
                if ($randNum > $start && $randNum <= $end) {
                    $id = $itemId;
                    break;
                }
                $start = $end;
            }

            if ($id != 0) {
                $str = $id . ',1';
                if ($res == "") {
                    $res = $str;
                } else {
                    $res = $res . ';' . $str;
                }
            }
        }

        return $res;
    }

    /**
     * 6808 开始挑战 (主线关卡:扣除体力, 挑战关卡: 增加次数)
     */
    private static function StartFight() {
        list($gateId, $layerNum) = req()->paras;
        my_Assert($gateId > 0, ErrCode::paras_err);
        $mo = GameConfig::gate_getItem($gateId);
        my_Assert(null != $mo, ErrCode::err_const_no);

        if (Ints::Slice($gateId, 0, 1) == 9) {                                  # 爬塔模式
//            list($layerNum) = req()->paras;
            if ($layerNum != ctx()->gates()->TowerGateInfo()->CurLayer) {       # 起始层数校验
                Err(ErrCode::tower_layerNum);
            }
            if (ctx()->gates()->TowerGateInfo()->TodayChanNum < 1) {           # 剩余次数校验
                Err(ErrCode::tower_timeNo);
            }
            ctx()->gates()->TowerGateInfo()->TodayChanNum--;                    # 增加次数
        } else {                                                                # 主线剧情
            my_Assert(ctx()->base()->Consume_tili($mo->cost_tili), ErrCode::notenough_tili);
        }
        UserProc::updateUserInfo();
        return Resp::ok(array("tili" => ctx()->baseInfo->tili, "tili_ts" => ctx()->baseInfo->tili_ts));
    }

    public static function FightDailyClear() {
        //ctx()->gates->xunluo_quick_buyRecord = 0;
        ctx()->gates->fightSweepNum = 0;
        ctx()->gates()->TowerGateInfo()->RefreshSkillTimes = 0;
        ctx()->gates()->TowerGateInfo()->TodayChanNum = glc()->tower_daily_chanceNum;

        ctx()->privateState->challange_RedMask = 0;
    }

    /**
     * 6806 剧情回存
     * @return type
     */
    public static function PlotSav() {
        list($gateId) = req()->paras;

        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::err_const_no);
        ctx()->gates->GateList->$gateId->plotStart = 1;

        UserProc::updateUserInfo();
        $ret = array(
            'ok' => 1,
        );
        return Resp::ok($ret);
    }

// <editor-fold defaultstate="collapsed" desc="挑战模块">

    /**
     * 6810 挑战关卡: 更新锁定技能列表
     */
    public static function TowerUpdateLockskillList() {
        list($li_zd, $li_bd, $li_zds, $li_bds) = req()->paras;                  # 参数解析
        $t = ctx()->gates()->TowerGateInfo();                                   # 记忆技能刷新结果
        $t->skill_zhudong = $li_zd;
        $t->skill_beidong = $li_bd;
        $t->skill_zhudong_lockState = $li_zds;
        $t->skill_beidong_lockState = $li_bds;
        UserProc::updateUserInfo();
        return Resp::ok();
    }

    /**
     * 6809 挑战关卡: 刷新初始技能(扣除免费次数/cost)
     */
    public static function TowerRefreshSkills() {
        list($isFree, $li_zd, $li_bd, $li_zds, $li_bds) = req()->paras;         # 参数解析
        if ($isFree) {
            if (ctx()->gates()->TowerGateInfo()->RefreshSkillTimes > glc()->tower_daily_refreshChanceNum) {
                Err(ErrCode::tower_refreshNo);                                  # 免费次数不足
            }
        } else {
            list($type, $num) = explode(':', glc()->tower_refreshCost);         # 二级货币类型(1:金币,2:元宝):数量
            if ($type == 1) {                                                   # 金币
                my_Assert(ctx()->base()->Consume_Gold($num), ErrCode::notenough_gold_msg);
            } else if ($type == 2) {                                            # 元宝
                my_Assert(ctx()->base()->Consume_Cash($num), ErrCode::notenough_cash_msg);
            } else {
                Err(ErrCode::err_const_no, "检查刷新扣费配置信息!");
            }
        }
        $t = ctx()->gates()->TowerGateInfo();                                   # 记忆技能刷新结果
        $t->RefreshSkillTimes++;
        $t->skill_zhudong = $li_zd;
        $t->skill_beidong = $li_bd;
        $t->skill_zhudong_lockState = $li_zds;
        $t->skill_beidong_lockState = $li_bds;
        UserProc::updateUserInfo();

        $ret = array(
            'task' => ctx()->task,
        );
        return Resp::ok($ret);
    }

    /**
     * 6805 战斗: 复活花费
     * @return type
     * @version 2024年5月17日 重整利用为复活扣除消耗功能
     */
    public static function ReliveCost() {
        // 复活可以扣除复活币(暂无)或者元宝,(客户端看广告复活不需要跟服务器通讯)
        list($reliveNum) = req()->paras;
        $arr = explode(',', glc()->Relive_cost);
        my_Assert($reliveNum >= 0 && $reliveNum <= Count($arr), ErrCode::paras_err); # 参数范围>0
        $amt = $arr[$reliveNum];
        my_Assert(ctx()->base()->Consume_Cash($amt), ErrCode::notenought_yuanbao);
        UserProc::updateUserInfo();
        return Resp::ok();
    }

    /**
     * 6804 挑战关卡: 奖励领取
     * @return type
     */
    public static function GateChallengeRewards() {
        list($finalLayer, $killedMonster, $killedBoss) = req()->paras;          # 战斗结束时的层数

        $lastLayer = ctx()->gates()->TowerGateInfo()->CurLayer;
        $arr = GameConfig::waves_getItemArray(self::TowerGateId);
        TaskProc::OnFightNumChallengeGate();
        TaskProc::OnKillCommonNumMonster($killedMonster);
        TaskProc::OnKillleaderNumMonster($killedBoss);

        if ($finalLayer > $lastLayer) {
            foreach ($arr as $layerId => $layerMo) {
                if ($layerMo->waveId >= $lastLayer && $layerMo->waveId < $finalLayer) {
                    my_Assert($layerMo != null, ErrCode::err_const_no);
                    StoreProc::AddMultiItemInStore($layerMo->rewards);              # 发放奖励
                }
            }

            ctx()->gates()->TowerGateInfo()->CurLayer = $finalLayer;

            TaskProc::OnPassLayer_ChallengeGate($finalLayer - 1);
            UserProc::updateUserInfo();
            $ret = array(
                'store' => ctx()->store,
                'gold' => ctx()->base()->gold,
                'cash' => ctx()->base()->cash,
                'task' => ctx()->task,
            );
            return Resp::ok($ret);
        } else if ($finalLayer == $lastLayer) {
            $ret = array(
                'store' => ctx()->store,
                'gold' => ctx()->base()->gold,
                'cash' => ctx()->base()->cash,
                'task' => ctx()->task,
            );
            return Resp::ok($ret);
        }
        return Resp::err(ErrCode::tower_rewardNo);                              # 没有奖励
    }

// </editor-fold>

    /**
     * 6803 关卡选择
     * @return type
     */
    public static function SelectGate() {
        list($gateId) = req()->paras;

        ctx()->gates->CurrentGateId = $gateId;

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
        );
        return Resp::ok($ret);
    }

    /**
     * 6802 章节宝箱的领取
     * @return type
     */
    public static function PassGateTsPrizeReceive() {
        list($gateId, $index) = req()->paras;

        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);

        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
        $gateInfo = ctx()->gates->GateList->$gateId;

        $tag = false;
        $prize = "";
        $mask = 0;
        switch ($index) {
            case 1:
                $ts = $gateMo->first_ts1 * 60;
                if ($gateInfo->MaxSeconds >= $ts) {
                    $tag = true;
                }
                $mask = 1;
                $prize = $gateMo->first_reward1;
                break;
            case 2:
                $ts = $gateMo->first_ts2 * 60;
                if ($gateInfo->MaxSeconds >= $ts) {
                    $tag = true;
                }
                $mask = 2;
                $prize = $gateMo->first_reward2;
                break;
            case 3:
                if ($gateInfo->pass > 0) {
                    $tag = true;
                }
                $mask = 3;
                $prize = $gateMo->first_reward3;
                break;
            default:
                break;
        }

        if ($tag) {
            my_Assert(!in_array($mask, $gateInfo->FirstReward), ErrCode::gate_GatePriceHasReceive);
            $gateInfo->FirstReward[] = $mask;

            $pStr = explode(';', $prize);
            foreach ($pStr as $val) {
                $arr = explode(',', $val);
                if (GameConfig::item_getItem($arr[0]) == 201 || GameConfig::item_getItem($arr[0]) == 701) {
                    FightProc::funUnlock_Gem();
                    break;
                }
            }
            StoreProc::AddMultiItemInStore($prize);
        }
        ctx()->gates->GateList->$gateId = $gateInfo;
        TaskProc::OnReceiveGateBoxReward();

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
            'store' => ctx()->store,
            'task' => ctx()->task,
            'gold' => ctx()->baseInfo->gold,
            'cash' => ctx()->baseInfo->cash,
            'reward' => StoreProc::$reward,
            'reward_Gem' => StoreProc::$reward_Gem,
            'funUnlockRecord' => ctx()->privateState->funUnlockRecord,
            'funUnlockRecord_2' => ctx()->privateState->funUnlockRecord_2,
        );
        return Resp::ok($ret);
    }

    /**
     * [6801]关卡战斗结算
     * @return type
     */
    public static function Settle() {
        list($resultType, $gateId, $gold, $curTs, $pickups,
                $finalLayer, $finalHpPercent, $killMonsterNum, $killBossNum,
                $finalLevel, $reliveNum) = req()->paras;
        # 客户端需要增加参数: killmonserNum,killBosssNum, finalHpPercent(最终血量百分比)
        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);
        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
        $gateInfo = ctx()->gates->GateList->$gateId;
        $ts = $gateInfo->MaxSeconds;
        if ($curTs >= $ts) {
            $gateInfo->MaxSeconds = $curTs;
        }

        self::funUnlock_Gate($resultType, $gateId); //备注：这个接口的位置不能动 里面有关卡第一次胜利解锁的功能提示校验
        self::subFunUnlock($resultType, $gateId);
        if ($resultType) {                                                      # 胜利
            self::skillUnlock_gate($resultType, $gateId); //备注 这个接口位置不能动

            if (ctx()->gates->GateList->$gateId->pass == 0) {
                ctx()->gates->GateList->$gateId->pass = 1;
                                              
                $maxGateId = ctx()->gates->maxPassGateNumId();

                if ($maxGateId > 0) {
                    self::Ranking_MainGateIndex($maxGateId);
                    self::IsAchievedMainGate_PassReward($maxGateId);
                }
            }

            TaskProc::OnPassGate_X($gateId);                                    # 刷新任务进度: 通关第X关
            TaskProc::OnPassGate_X_state($gateId);
            if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainStoryGate) {
                ctx()->gates()->UnlockNextPlotGate($gateId);                    # 解锁下一主线关卡
//                ctx()->gates()->UnlockMainChallengeGate($gateId);              # 挑战关卡解锁逻辑. -gwang 2024年4月15日
            } else {                                                            # 不是主线关卡, 暂时没有其他逻辑
            }
//            StoreProc::AddMultiItemInStore($gateMo->reward_win);                # 发放胜利奖励(2024.5.30 过期)
        } else {
            ctx()->gates->GateList->$gateId->fightNum_fail += 1;
            self::skillUnlock_fightNum($resultType); //这个接口位置不能动
        }
//        else {                                                                # 失败
////            StoreProc::AddMultiItemInStore($gateMo->reward_fail);               # 发放失败奖励(2024.5.30 过期)
//        }

        StoreProc::AddMultiItemInStore($pickups);                               # 战场拾取道具直接入背包
        //ctx()->base()->Add_Gold($gold);                                         # 战场拾取的金币直接入背包
        //ctx()->base()->Add_Exp($exp);
        $waveMo = GameConfig::waveItem_getItem($gateId, $finalLayer);
        my_Assert(null != $waveMo, ErrCode::err_const_no);
        $oldLevel = ctx()->baseInfo->level;
        StoreProc::AddMultiItemInStore('4,' . $waveMo->rewardExp);
        //ctx()->base()->Add_Exp($waveMo->rewardExp);                             # 指挥官经验
        $newLevel = ctx()->baseInfo->level;
        if ($oldLevel != $newLevel) {
            ctx()->privateState->oldLevel = $oldLevel;
            ctx()->privateState->upLevel = $newLevel;
        }

        //ctx()->base()->Add_Gold($waveMo->rewardGold);                           # 金币奖励
        //$pickups .= ";1," . $gold + $waveMo->rewardGold;

        $str = "1," . $gold + $waveMo->rewardGold;
        StoreProc::AddMultiItemInStore($str);

        # 图纸奖励: 数量min-max, 部位随机
        if (strlen($waveMo->rewardTuZhi) > 0 && str_contains($waveMo->rewardTuZhi, '-')) {
            list($tz_min, $tz_max) = explode('-', $waveMo->rewardTuZhi);        # 图纸数量
            $tz_n = rand($tz_min, $tz_max);
            # 图纸部位数据源 1001, 1002, 1003, 1004, 1005, 1006
            for ($i = 0; $i < $tz_n; $i++) {
                $id = 1000 + rand(1, 6);
                StoreProc::AddMultiItemInStore("$id,1");                        # 获得图纸
                //$pickups .= ";$id,1";
            }
        }
        # 宝石奖励: 数量min-max;品质:权重,品质:权重...
        if (strlen($waveMo->rewardGem) > 0) {
            self::funUnlock_Gem();

            list($gs_num, $gs_props) = explode(';', $waveMo->rewardGem);
            list($gem_min, $gem_max) = explode('-', $gs_num);                   # 宝石数量
            $gem_n = rand($gem_min, $gem_max);
            $arr = explode(",", $gs_props);
            $pool = array();
            $n = 0;
            foreach ($arr as $str) {
                list($qual, $props) = explode(':', $str);
                $pool[] = array('q' => $qual, 'p' => $props);
                $n += $props;
            }
            for ($i = 0; $i < $gem_n; $i++) {                                   # 随机n块宝石
                $r = rand(1, $n);                                                  # 投色子
                $l = 0;
                foreach ($pool as $item) {
                    if ($r <= ($l + $item['p'])) {
                        $gemId = $item['q'] * 100000 + rand(1, 6) * 1000;
                        SystemProc::GetGem_GreaterOrangeQual_MainGate(req()->zoneid, ctx()->baseInfo->name, Ins_GateInfo::gateNum($gateId), $gateMo->gateName, $gemId); //广播
                        //StoreProc::PutGemInStore($gemId);                       # 发放宝石并退出本次投色子
                        //$pickups .= ";$gemId,1";
                        StoreProc::AddMultiItemInStore("$gemId,1");

                        break;
                    }
                    $l += $item['p'];                                             # 累计到下一段
                }
            }
        }

        ctx()->gates->GateList->$gateId->fightNum += 1;
        TaskProc::Day7TaskReset();
        TaskProc::OnFightNumMainGate();
        TaskProc::OnKillCommonNumMonster($killMonsterNum);
        TaskProc::OnKillleaderNumMonster($killBossNum);
        TaskProc::OnFightGate_X($gateId);

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
            'store' => ctx()->store,
            'task' => ctx()->task,
            'baseInfo' => ctx()->base(),
            'gold' => $gold + $waveMo->rewardGold,
            'exp' => $waveMo->rewardExp,
            //'rewardStr' => $pickups
            'reward' => StoreProc::$reward,
            'reward_Gem' => StoreProc::$reward_Gem,
            'oldLevel' => $oldLevel,
            'newLevel' => $newLevel,
            'funUnlockRecord' => ctx()->privateState->funUnlockRecord,
            'funUnlockRecord_2' => ctx()->privateState->funUnlockRecord_2,
            'skillUnlockRecord' => ctx()->privateState->skillUnlockRecord,
            'heros' => ctx()->heros,
            'subFunStartTs' => ctx()->privateState->subFunStartTs,
        );
        return Resp::ok($ret);
    }

// <editor-fold defaultstate="collapsed" desc="功能解锁">   

    /**
     * 检测功能解锁的
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function funUnlock($resultType, $gateId) {
        $dic = GameConfig::fun_unlock();
        foreach ($dic as $id => $mo) {
            if ($mo->unlockTip == 1 && $mo->unlockParas1 == $gateId) {
                $tag = false;
                //1:参与战斗结束即可  2战斗胜利  3某场战斗参加N次数才行
                switch ($mo->unlockType1) {
                    case 1:
                        if (ctx()->gates->GateList->$gateId->fightNum == 0) {
                            $tag = true;
                        }
                        break;
                    case 2:
                        if ($resultType == true && ctx()->gates->GateList->$gateId->pass == 0) {
                            $tag = true;
                        }

                        break;
                    default:
                        break;
                }

                if ($tag) {
                    ctx()->privateState->funUnlockRecord[] = $id;
                }
            }
        }
    }

    /**
     * 检测功能解锁的 关卡
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function funUnlock_Gate($resultType, $gateId) {
        $dic = GameConfig::fun_unlock();
        foreach ($dic as $id => $mo) {
            if ($mo->unlockTip == 1) {//$mo->unlockGateId == $gateId              
                $tag = false;
                if ($mo->unlockType1 != null) {
                    //1:参与战斗结束即可  2战斗胜利  3某场战斗参加N次数才行
                    switch ($mo->unlockType1) {
                        case Enum_FunUnlockType::battle_Gate:
                            if ($mo->unlockParas1 == $gateId && ctx()->gates->GateList->$gateId->fightNum == 0) {
                                $tag = true;
                            }
                            break;
                        case Enum_FunUnlockType::passBattle_Gate:
                            if ($resultType == true && $mo->unlockParas1 == $gateId && ctx()->gates->GateList->$gateId->pass == 0) {
                                $tag = true;
                            }

                            break;
                        default:
                            break;
                    }
                }

                if ($mo->unlockType2 != null) {
                    //1:参与战斗结束即可  2战斗胜利  3某场战斗参加N次数才行
                    switch ($mo->unlockType2) {
                        case Enum_FunUnlockType::battle_Gate:
                            if ($mo->unlockParas2 == $gateId && ctx()->gates->GateList->$gateId->fightNum == 0) {
                                $tag = true;
                            }
                            break;
                        case Enum_FunUnlockType::passBattle_Gate:
                            if ($resultType == true && $mo->unlockParas2 == $gateId && ctx()->gates->GateList->$gateId->pass == 0) {
                                $tag = true;
                            }

                            break;
                        default:
                            break;
                    }
                }

                if ($tag && !in_array($id, ctx()->privateState->funUnlockRecord_2)) {
                    ctx()->privateState->funUnlockRecord[] = $id;
                    ctx()->privateState->funUnlockRecord_2[] = $id;
                }
            }
        }
    }

    /**
     *  初次得到宝石 功能解锁
     */
    static function funUnlock_Gem() {
        $dic = GameConfig::fun_unlock();
        foreach ($dic as $id => $mo) {
            $tag = false;
            if ($mo->unlockTip == 1) {//$mo->unlockGateId == $gateId               
                if ($mo->unlockType1 != null && $mo->unlockType1 == Enum_FunUnlockType::getGem && ctx()->store->gemStore == null) {
                    $tag = true;
                }

                if ($mo->unlockType2 != null && $mo->unlockType2 == Enum_FunUnlockType::getGem && ctx()->store->gemStore == null) {
                    $tag = true;
                }
            }

            if ($tag && !in_array($id, ctx()->privateState->funUnlockRecord_2)) {
                ctx()->privateState->funUnlockRecord[] = $id;
                ctx()->privateState->funUnlockRecord_2[] = $id;
            }
        }
    }

    /**
     *  玩家等级要求 功能解锁
     */
    static function funUnlock_userLv($level) {
        $dic = GameConfig::fun_unlock();
        foreach ($dic as $id => $mo) {
            $tag = false;
            if ($mo->unlockTip == 1) {//$mo->unlockGateId == $gateId               
                if ($mo->unlockType1 != null && $mo->unlockType1 == Enum_FunUnlockType::userLv && $mo->unlockParas1 == $level) {
                    $tag = true;
                }

                if ($mo->unlockType2 != null && $mo->unlockType2 == Enum_FunUnlockType::userLv && $mo->unlockParas2 == $level) {
                    $tag = true;
                }
            }
            if ($tag && !in_array($id, ctx()->privateState->funUnlockRecord_2)) {
                ctx()->privateState->funUnlockRecord[] = $id;
                ctx()->privateState->funUnlockRecord_2[] = $id;
            }
        }
    }

    /**
     *  主线挑战 功能解锁
     */
    static function funUnlock_mainChallengeGate_State($result, $gateId, $state) {
        $dic = GameConfig::fun_unlock();
        foreach ($dic as $id => $mo) {
            $tag = false;
            if ($mo->unlockTip == 1) {//$mo->unlockGateId == $gateId              
                if ($mo->unlockType1 != null && $result = true && $mo->unlockType1 == Enum_FunUnlockType::mainChallengeGate_State) {
                    $str = explode(',', $mo->unlockParas1);
                    $uGateId = $str[0];
                    $gateState = $str[1];

                    if ($uGateId == $gateId && StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId) && ctx()->gates->GateList->$gateId->tz_state == $gateState - 1) {
                        $tag = true;
                    }
                }

                if ($mo->unlockType2 != null && $result = true && $mo->unlockType2 == Enum_FunUnlockType::mainChallengeGate_State) {
                    $str = explode(',', $mo->unlockParas2);
                    $uGateId = $str[0];
                    $gateState = $str[1];
                    if ($uGateId == $gateId && StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId) && ctx()->gates->GateList->$gateId->tz_state == $gateState - 1) {
                        $tag = true;
                    }
                }
            }

            if ($tag && !in_array($id, ctx()->privateState->funUnlockRecord_2)) {
                ctx()->privateState->funUnlockRecord[] = $id;
                ctx()->privateState->funUnlockRecord_2[] = $id;
            }
        }
    }

    /**
     * 查看某功能是否解锁
     * @param type $id
     */
    static function isFunUnlock($id) {
        $funMo = GameConfig::fun_unlock_getItem($id);
        if ($funMo->unlockType1 != null && self::unlockCondition($funMo->unlockType1, $funMo->unlockParas1)) {
            return true;
        }

        if ($funMo->unlockType2 != null && self::unlockCondition($funMo->unlockType2, $funMo->unlockParas2)) {
            return true;
        }
        return false;
    }

    /**
     * 解锁条件id
     * @param type $conditionId
     */
    static function unlockCondition($conditionId, $paras) {
        $funUnlock = false;
        switch ($conditionId) {
            case Enum_FunUnlockType::battle_Gate:
                $gateId = $paras;
                if (ctx()->gates->GateList->$gateId->fightNum > 0) {
                    $funUnlock = true;
                }
                break;
            case Enum_FunUnlockType::passBattle_Gate:
                $gateId = $paras;
                if (ctx()->gates->GateList->$gateId->pass >= 1) {
                    $funUnlock = true;
                }

                break;
            case Enum_FunUnlockType::getGem:
                if (ctx()->store->gemStore != null) {
                    $funUnlock = true;
                }

                break;
            case Enum_FunUnlockType::userLv:
                if (ctx()->baseInfo->level >= $paras) {
                    $funUnlock = true;
                }

                break;
            case Enum_FunUnlockType::mainChallengeGate_State:
                $str = explode(',', $paras);
                $uGateId = $str[0];
                $gateState = $str[1];

                if (StlUtil::dictHasProperty(ctx()->gates->GateList, $uGateId) && ctx()->gates->GateList->$uGateId->tz_state >= $gateState) {
                    $funUnlock = true;
                }

                break;
            default:
                break;
        }
        return $funUnlock;
    }

    /**
     * 检测次级功能解锁的
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function subFunUnlock($resultType, $gateId) {
        $dic = GameConfig::subfun_unlock();
        foreach ($dic as $id => $mo) {
            if ($mo->type != 1) {
                continue;
            }

            if ($mo->unlockGateId == $gateId) {
                $tag = false;
                //1:参与战斗结束即可  2战斗胜利  3某场战斗参加N次数才行
                switch ($mo->unlockType) {
                    case 1:
                        if (ctx()->gates->GateList->$gateId->fightNum == 0) {
                            $tag = true;
                        }
                        break;
                    case 2:
                        if ($resultType == true && ctx()->gates->GateList->$gateId->pass == 0) {
                            $tag = true;
                        }

                        break;
                    default:
                        break;
                }

                if ($tag) {
                    if (!StlUtil::dictHasProperty(ctx()->privateState->subFunStartTs, $id)) {
                        ctx()->privateState->subFunStartTs->$id = now();
                    }
                }
            }
        }
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="技能解锁">

    /**
     * 检测技能解锁的 1 关卡解锁，游玩到一定关卡解锁技能
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function skillUnlock_gate($resultType, $gateId) {
        $dic = GameConfig::skills();

        $gateIndex = Ins_GateInfo::gateNum($gateId);
        foreach ($dic as $id => $mo) {
            if ($mo->unlock_acc_id_new == null) {
                continue;
            }
            $strList = explode(':', $mo->unlock_acc_id_new);
            $unlockType = $strList[0];
            $unlockId = $strList[1];

            if ($unlockType == 1 && $unlockId == $gateIndex && $resultType == true && ctx()->gates->GateList->$gateId->pass == 0 && !in_array($mo->typeId, ctx()->privateState->skillUnlockRecord)) {
                ctx()->privateState->skillUnlockRecord[] = $mo->typeId;
            }
        }
    }

    /**
     * 检测技能解锁的 2://皮肤解锁，获取到人物解锁后对应皮肤技能
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function skillUnlock_heroUnlock($heroId) {
        $dic = GameConfig::skills();
        foreach ($dic as $id => $mo) {
            if ($mo->unlock_acc_id_new == null) {
                continue;
            }

            $strList = explode(':', $mo->unlock_acc_id_new);
            $unlockType = $strList[0];
            $unlockId = $strList[1];

            if ($unlockType != 2) {
                continue;
            }

            $heroMo = GameConfig::hero_getItem($heroId);
            $heroTypeId = $heroMo->typeID;
            $isUnlock = ctx()->heros->Dic->$heroId->isUnlock;

            if ($unlockId == $heroTypeId && $isUnlock == 0 && !in_array($mo->typeId, ctx()->privateState->skillUnlockRecord)) {
                ctx()->privateState->skillUnlockRecord[] = $mo->typeId;
            }
        }
    }

    /**
     * 检测技能解锁的  3://玩家失败X次后解锁
     * @param type $resultType
     * @param type $gateId
     * @return type
     */
    static function skillUnlock_fightNum($resultType) {

        if ($resultType) {
            return;
        }

        $GateList = ctx()->gates->GateList;
        $num = 0;
        foreach ($GateList as $gateId => $Ins_GateInfo) {
            $num += $Ins_GateInfo->fightNum_fail;
        }

        $dic = GameConfig::skills();
        foreach ($dic as $id => $mo) {
            if ($mo->unlock_acc_id_new == null) {
                continue;
            }

            $strList = explode(':', $mo->unlock_acc_id_new);
            $unlockType = $strList[0];
            $unlockId = $strList[1];

            if ($unlockType != 3) {
                continue;
            }

            if ($num == $unlockId && !in_array($mo->typeId, ctx()->privateState->skillUnlockRecord)) {
                ctx()->privateState->skillUnlockRecord[] = $mo->typeId;
            }
        }
    }

    /**
     * 玩家等级解锁技能
     * @param type $curLevel
     */
    static function skillUnlock_userLevel($curLevel) {
        $dic = GameConfig::skills();
        foreach ($dic as $id => $mo) {
            if ($mo->unlock_acc_id_new == null) {
                continue;
            }

            $strList = explode(':', $mo->unlock_acc_id_new);
            $unlockType = $strList[0];
            $unlockId = $strList[1];

            if ($unlockType != 5) {                                             // 玩家等级
                continue;
            }
            if ($unlockId == $curLevel && !in_array($mo->typeId, ctx()->privateState->skillUnlockRecord)) {
                ctx()->privateState->skillUnlockRecord[] = $mo->typeId;
            }
        }
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="排行榜">

    /**
     * 参与主线关卡排行榜
     * @param type $gateIndex
     */
    public static function Ranking_MainGateIndex($maxGateIndex) {
        $memKey = MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid);
        $mem = gMem();

        $uid = req()->uid;
        $score = self::GetRankScoreUid($uid, 1);
        if ($maxGateIndex > $score) {
            $arr = array();
            $arr["$uid"] = self::createScore($maxGateIndex);
            $mem->zadd($memKey, $arr);
        }

        $length = $mem->zlen($memKey);
        if ($length > glc()->Rank_MainGateIndex_OnListRank) {
            $num = $length - glc()->Rank_MainGateIndex_OnListRank;
            $mem->zremrangebyrank($memKey, 0, $num - 1);
        }
    }

    public static function createScore($score) {
        if ($score > 0) {
            $newScore = $score . '.' . (9999999999 - now());
            return $newScore;
        }
        return 0;
    }

    /**
     * 战力榜
     * @param type $gateIndex
     */
    public static function Ranking_FightPower() {
        $memKey = MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid);
        $mem = gMem();

        $uid = req()->uid;

        $score = self::GetRankScoreUid($uid, 2);
        $power = self::countUserFightPower();
        if ($power > $score) {
            $arr = array();
            $arr["$uid"] = self::createScore($power);
            $mem->zadd($memKey, $arr);
            self::IsAchievedFightPower_PassReward($power);
        }

        $length = $mem->zlen($memKey);
        if ($length > glc()->Rank_FightPower_OnListRank) {
            $num = $length - glc()->Rank_FightPower_OnListRank;
            $mem->zremrangebyrank($memKey, 0, $num - 1);
        }
    }

    public static function GetRankScoreUid($uid_rank, $type) {
        if ($type == 1) {
            $score = gMem()->zscore(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), $uid_rank);
        } else {
            $score = gMem()->zscore(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), $uid_rank);
        }

        if ($score == null) {
            $score = 0;
        }

        return intval($score);
    }

    /**
     * 6811 获取主线关卡排行榜信息
     * @return type
     */
    public static function GetRankInfo() {
        list($type) = req()->paras;

        $selfIsHasRank = 0; //本人是否上榜 0未上榜没有排名 1上榜则selfRank就是排名
        $selfExtraInfo = 0;
        $isExistFinishReward = 0;
        $isExistFinishReward_other = 0;
        if ($type == 1) {
            $list = gMem()->zrevrange(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), 0, glc()->Rank_MainGateIndex_OnListRank, true);
            $selfExtraInfo = ctx()->gates->maxPassGateNumId();

            $isExistFinishReward = self::isExistNoDrawed_MainGate();
            $isExistFinishReward_other = self::isExistNoDrawed_FightPower();
        } else {
            $list = gMem()->zrevrange(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), 0, glc()->Rank_FightPower_OnListRank, true);
            $selfExtraInfo = self::countUserFightPower();

            $isExistFinishReward = self::isExistNoDrawed_FightPower();
            $isExistFinishReward_other = self::isExistNoDrawed_MainGate();
        }

        if ($isExistFinishReward == 1) {
            $isExistFinishReward = true;
        } else {
            $isExistFinishReward = false;
        }

        if ($isExistFinishReward_other == 1) {
            $isExistFinishReward_other = true;
        } else {
            $isExistFinishReward_other = false;
        }

        $selfRank = null;
        $retArr = array();
        if (count($list) > 0) {
            foreach ($list as $uid => $score) {
                $rankInfo = self::initOtherUidRankInfo($uid, $score, $type);
                if ($rankInfo->uid == req()->uid) {
                    $selfIsHasRank = 1;
                    $selfRank = $rankInfo;
                }

                $retArr[] = $rankInfo;
            }
        }

        if ($selfRank == null) {
            $selfRank = self::initOtherUidRankInfo(req()->uid, $selfExtraInfo, $type);
        }

        UserProc::updateUserInfo();
        $ret = array(
            'rankInfo' => $retArr,
            'selfRank' => $selfRank,
            'selfIsHasRank' => $selfIsHasRank,
            'isExistFinishReward' => $isExistFinishReward,
            'isExistFinishReward_other' => $isExistFinishReward_other,
        );
        return Resp::ok($ret);
    }

    /**
     * 初始化玩家rank
     * @param type $uid
     * @param type $score
     * @return \loyalsoft\Ins_rank
     */
    static function initOtherUidRankInfo($uid, $score, $type = null) {
        $ins_rank = new Ins_rank();

        if ($type == 1) {
            $lv = gMem()->zrevrank(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), $uid);
        } else {
            $lv = gMem()->zrevrank(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), $uid);
        }

        if ($lv == null) {
            $lv = 0;
        }

        $ins_rank->rank = $lv + 1;
        $ins_rank->uid = $uid;
        $userInfo = UserProc::getUserGame(req()->zoneid, $uid);
        $ins_rank->name = $userInfo->baseInfo->name;
        $ins_rank->headImg = $userInfo->baseInfo->headImg;
        //$ret = intval($score);
//        if(!$isToRank){
//            $ret = $score;
//        }
        $ins_rank->score = intval($score);
        return $ins_rank;
    }

    /**
     * 6812 获取排行榜内玩家的装备信息
     * @return type
     */
    public static function GetUidEquipInfo_Rank() {
        list($uid) = req()->paras;
        $userInfo = UserProc::getUserGame(req()->zoneid, $uid);

        $store = $userInfo->store;
        $heros = $userInfo->heros;
        $gates = $userInfo->gates;

        UserProc::updateUserInfo();
        $ret = array(
            'store' => $store,
            'heros' => $heros,
            'gates' => $gates,
        );
        return Resp::ok($ret);
    }

    /**
     * 通关奖励是否达成
     * @param type $maxGateIndex
     */
    public static function IsAchievedMainGate_PassReward($maxGateIndex) {
        $rewards = GameConfig::rank_passgatereward();

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        foreach ($rewards as $passGateId => $mo) {
            if ($passGateId == $maxGateIndex && !gMem()->hexists($memKey, $maxGateIndex)) {
                $ins_rank = new Ins_rank();
                $ins_rank->uid = req()->uid;
                $ins_rank->name = ctx()->baseInfo->name;
                $ins_rank->headImg = ctx()->baseInfo->headImg;
                $ins_rank->score = $passGateId;
                gMem()->hset($memKey, $maxGateIndex, $ins_rank);
                break;
            }
        }
    }

    /*
     * 战力奖励是否达成
     */

    public static function IsAchievedFightPower_PassReward($power) {
        $rewards = GameConfig::rank_fightpowerreward();

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        foreach ($rewards as $fightPower => $mo) {
            if ($power >= $fightPower && !gMem()->hexists($memKey, $fightPower)) {
                $ins_rank = new Ins_rank();
                $ins_rank->uid = req()->uid;
                $ins_rank->name = ctx()->baseInfo->name;
                $ins_rank->headImg = ctx()->baseInfo->headImg;
                $ins_rank->score = $fightPower;
                gMem()->hset($memKey, $fightPower, $ins_rank);
            }
        }
    }

    public static function isExistNoDrawed_MainGate() {
        $isExistFinishReward = 0;
        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);
        foreach ($dic as $gateId => $ins_rank) {
            if (!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate)) {
                $isExistFinishReward = 1;
                break;
            }
        }

        ctx()->privateState->redTip_RewardMainGateRank = $isExistFinishReward;
        return $isExistFinishReward;
    }

    public static function isExistNoDrawed_FightPower() {
        $isExistFinishReward = 0;
        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);
        foreach ($dic as $fightPower => $ins_rank) {
            if (!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower)) {
                $isExistFinishReward = 1;
                break;
            }
        }

        ctx()->privateState->redTip_RewardFightPowerRank = $isExistFinishReward;
        return $isExistFinishReward;
    }

    /**
     * 6813
     * @return type
     */
    public static function GetmainGate_RankRewardInfo() {
        //list($type) = req()->paras;

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);

        if ($dic == null) {
            $dic = new \stdClass();
        }

        UserProc::updateUserInfo();
        $ret = array(
            'rankReward' => $dic,
        );
        return Resp::ok($ret);
    }

    /**
     * 6814
     * @return type
     */
    public static function GetFightPower_RankRewardInfo() {
        //list($type) = req()->paras;

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);

        if ($dic == null) {
            $dic = new \stdClass();
        }

        UserProc::updateUserInfo();
        $ret = array(
            'rankReward' => $dic,
        );
        return Resp::ok($ret);
    }

    /**
     * 6815 领取通关荣誉榜奖励
     * @return type
     */
    public static function ReceiveRankReward_MainGate() {
        list($gateId) = req()->paras;

        my_Assert(!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate), ErrCode::rankReward_HasReceive);

        $mo = GameConfig::rank_passgatereward_getItem($gateId);
        my_Assert($mo != null, ErrCode::err_const_no);

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        if (gMem()->hexists($memKey, $gateId)) {
            StoreProc::AddMultiItemInStore($mo->reward);
            ctx()->privateState->rankReward_drawed_MainGate[] = $gateId;

            TaskProc::OnRankPrize_Num();
        }

        $tag = self::isExistNoDrawed_MainGate();
        UserProc::updateUserInfo();
        $ret = array('redTip' => $tag, 'task' => ctx()->task, 'store' => ctx()->store, 'cash' => ctx()->baseInfo->cash, 'reward' => StoreProc::$reward);
        return Resp::ok($ret);
    }

    /**
     * 6816 领取战力荣誉榜奖励
     * @return type
     */
    public static function ReceiveRankReward_FightPower() {
        list($fightPower) = req()->paras;

        my_Assert(!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower), ErrCode::rankReward_HasReceive);

        $mo = GameConfig::rank_fightpowerreward_getItem($fightPower);
        my_Assert($mo != null, ErrCode::err_const_no);

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        if (gMem()->hexists($memKey, $fightPower)) {
            StoreProc::AddMultiItemInStore($mo->reward);
            ctx()->privateState->rankReward_drawed_fightPower[] = $fightPower;
            TaskProc::OnFightRankPrize_Num();
        }

        $tag = self::isExistNoDrawed_FightPower();

        UserProc::updateUserInfo();
        $ret = array('redTip' => $tag, 'task' => ctx()->task, 'store' => ctx()->store, 'cash' => ctx()->baseInfo->cash, 'reward' => StoreProc::$reward);
        return Resp::ok($ret);
    }

    /**
     * 6824 排行奖励一键领取
     */
    static function ReceiveRankReward() {
        list($type) = req()->paras;                                                # 解锁数量
        if ($type == 1) {
            $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
            $dic = gMem()->hgetall($memKey);
            foreach ($dic as $gateId => $ins_rank) {
                if (!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate)) {
                    $mo = GameConfig::rank_passgatereward_getItem($gateId);
                    StoreProc::AddMultiItemInStore($mo->reward);
                    ctx()->privateState->rankReward_drawed_MainGate[] = $gateId;
                    TaskProc::OnRankPrize_Num();
                }
            }
        } else {
            $memKey2 = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
            $dic2 = gMem()->hgetall($memKey2);
            foreach ($dic2 as $fightPower => $ins_rank) {
                if (!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower)) {
                    $mo = GameConfig::rank_fightpowerreward_getItem($fightPower);
                    StoreProc::AddMultiItemInStore($mo->reward);
                    ctx()->privateState->rankReward_drawed_fightPower[] = $fightPower;
                    TaskProc::OnFightRankPrize_Num();
                }
            }
        }

        UserProc::updateUserInfo();
        $ret = array('redTip' => 0,
            'task' => ctx()->task,
            'store' => ctx()->store,
            'cash' => ctx()->baseInfo->cash,
            'reward' => StoreProc::$reward,
            'rankReward_drawed_fightPower' => ctx()->privateState->rankReward_drawed_fightPower,
            'rankReward_drawed_MainGate' => ctx()->privateState->rankReward_drawed_MainGate,
        );
        return Resp::ok($ret);
    }

    /**
     * 6817
     */
    public static function IsExistRankReward() {
        //list($type) = req()->paras;

        $type = 0;
        $isExistFinishReward = false;
        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);
        foreach ($dic as $gateId => $ins_rank) {
            if (!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate)) {
                $isExistFinishReward = true;
                $type = 1;
                break;
            }
        }

        $memKey2 = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic2 = gMem()->hgetall($memKey2);
        foreach ($dic2 as $fightPower => $ins_rank) {
            if (!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower)) {
                $isExistFinishReward = true;
                $type = 2;
                break;
            }
        }

        UserProc::updateUserInfo();
        $ret = array(
            'isExistFinishReward' => $isExistFinishReward,
            'type' => $type,
        );
        return Resp::ok($ret);
    }

    /*
     * 删除排行榜内注销账号的玩家
     */

    public static function DeleteRankInvalidUser($uid2) {
        $dic1 = gMem()->zrevrange(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), 0, glc()->Rank_MainGateIndex_OnListRank, true);
        foreach ($dic1 as $uid => $score) {
            if ($uid == $uid2) {
                gMem()->zrem(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), $uid);
                break;
            }
        }

        $dic2 = gMem()->zrevrange(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), 0, glc()->Rank_FightPower_OnListRank, true);
        foreach ($dic2 as $uid => $score) {
            if ($uid == $uid2) {
                gMem()->zrem(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), $uid);
                break;
            }
        }
    }

    /*
     * 排行玩家修改昵称
     */

    public static function UpdateRankUserName($uid, $newName) {
        $memKey1 = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey1);
        foreach ($dic as $gateId => $ins_rank) {
            if ($ins_rank->uid == $uid) {
                $ins_rank->name = $newName;
                gMem()->hset($memKey1, $gateId, $ins_rank);
            }
        }

        $memKey2 = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic2 = gMem()->hgetall($memKey2);
        foreach ($dic2 as $fightPower => $ins_rank) {
            if ($ins_rank->uid == $uid) {
                $ins_rank->name = $newName;
                gMem()->hset($memKey2, $fightPower, $ins_rank);
            }
        }
    }

    /*
     * 排行玩家头像变动
     */

    public static function UpdateRankUserHeadImg($uid, $headImg) {
        $memKey1 = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey1);
        foreach ($dic as $gateId => $ins_rank) {
            if ($ins_rank->uid == $uid) {
                $ins_rank->headImg = $headImg;
                gMem()->hset($memKey1, $gateId, $ins_rank);
            }
        }

        $memKey2 = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic2 = gMem()->hgetall($memKey2);
        foreach ($dic2 as $fightPower => $ins_rank) {
            if ($ins_rank->uid == $uid) {
                $ins_rank->headImg = $headImg;
                gMem()->hset($memKey2, $fightPower, $ins_rank);
            }
        }
    }

    /*
     * 统计战力 战斗力=攻击x（生命-伤害减免值）x（1+暴击率/100x（暴击伤害倍率-1））改为 //战斗力=攻击x（生命-伤害减免值）x（1+暴击率 x（暴击伤害倍率-1））2024-8-30
     */

    public static function countUserFightPower() {
        $CurrentHeroId = ctx()->heros->CurrentHeroId;
        //$hero = ctx()->heros->Dic->$CurrentHeroId;

        list($addHp, $addAtk, $addDecDamage, $addEatFood) = ctx()->gates()->GetEnvovleBuffs(); // 启灵加成

        $mo = GameConfig::hero_getItem($CurrentHeroId);
        my_Assert($mo != null, ErrCode::err_const_no);

        $heroBashAttack = $mo->attack;
        $heroBashHp = $mo->hp;

        $equipDic = ctx()->store->equip;
        $attck = 0;
        $hp = 0;
        foreach ($equipDic as $index => $ins_equip) {
            $Ins_Equip = new Ins_Equip($ins_equip);
            if ($Ins_Equip->mo()->upgradeType == 1) {//攻击力
                $attck += GameConfig::equip_levelupgrade_getItem($ins_equip->level)->attckNum;
            } elseif ($Ins_Equip->mo()->upgradeType == 2) {
                $hp += GameConfig::equip_levelupgrade_getItem($ins_equip->level)->hpNum;
            } else {
                $attck += GameConfig::equip_levelupgrade_getItem($ins_equip->level)->attckNum;
                $hp += GameConfig::equip_levelupgrade_getItem($ins_equip->level)->hpNum;
            }
        }

        $heroAttck = $heroBashAttack + $attck + $addAtk;                        # 英雄基础攻击力+装备宝石词条攻击力+启灵攻击力
        $heroHp = $heroBashHp + $hp + $addHp;                                   # 英雄基础hp + 装备宝石词条hp + 启灵hp

        $pag = ctx()->store->equipPag;
        $gemDic = ctx()->store->gemEquip->$pag; //Dictionary<E_EquipPosition, Dictionary<int, Ins_Gem>>
        $per = 0;
        $parasVal = 0;

        $per_hp = 0;
        $parasVal_hp = 0;
        foreach ($equipDic as $index => $ins_equip) {
            if (StlUtil::dictHasProperty($gemDic, $index)) {
                $dic = $gemDic->$index;
                foreach ($dic as $k => $gem) {
                    $ins_Gem = new Ins_Gem($gem);
                    if ($ins_Gem->predicateMo()->actionType == "mulDamage") {
                        $per += $ins_Gem->predicateMo()->actionParam1;
                    } elseif ($ins_Gem->predicateMo()->actionType == "addDamage") {
                        $parasVal += $ins_Gem->predicateMo()->actionParam1;
                    } elseif ($ins_Gem->predicateMo()->actionType == "mulHp") {
                        $per_hp += $ins_Gem->predicateMo()->actionParam1;
                    } elseif ($ins_Gem->predicateMo()->actionType == "addHp") {
                        $parasVal_hp += $ins_Gem->predicateMo()->actionParam1;
                    }
                }
            }
        }

        if ($per != 0) {
            $heroAttck = round($heroAttck + $heroAttck * $per);
        }
        if ($parasVal != 0) {
            $heroAttck += $parasVal;
        }

        if ($per_hp != 0) {
            $heroHp = round($heroHp + $heroHp * $per_hp);
        }
        if ($parasVal_hp != 0) {
            $heroHp += $parasVal_hp;
        }

        $dec_demage = $mo->dec_demage + $addDecDamage;                          # 英雄基础减伤 + 启灵减伤
        $bigHit_Val = $mo->bigHit_Val;
        $bigHit_rate = $mo->bigHit_rate;

        $val = $heroAttck * ($heroHp - $dec_demage) * (1 + $bigHit_rate * ($bigHit_Val - 1));

        return intval($val);
    }

    // </editor-fold>
}