jzhj2024server/Gameserver/App/process/TaskProc.php

<?php

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

namespace loyalsoft;

/**
 * Description of TaskProc
 *
 * @author c'y'zhao
 */
class TaskProc {
    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    public static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::cmd_task_getInfo:                                     # 6201
                return TaskProc::getTaskInfo();
            case CmdCode::cmd_task_getReward:                                   # 6202
                return TaskProc::getReward();    
            case CmdCode::cmd_task_getAchieveReward:                            # 6203 领取成就奖励
                return TaskProc::getAchieveReward();                            
                
            default:
                Err(ErrCode::cmd_err);
        }
    }
    
    /**
     * 6203 领取成就奖励
     * @return type
     */
    public static function getAchieveReward() {
        list($typeId) = req()->paras;
         
        $mo = GameConfig::achieve_getItem($typeId);
        my_Assert($mo != null, ErrCode::err_const_no);
        
        my_Assert(StlUtil::dictHasProperty(ctx()->task->achieveDic, $typeId), ErrCode::err_const_no);
        $achieveDic = ctx()->task->achieveDic->$typeId;
       
        $list = explode(',', $mo->condition);
        $length = count($list);
        my_Assert($achieveDic->val>= $achieveDic->max, ErrCode::task_CanotPriceReviced);
        my_Assert($achieveDic->received < $achieveDic->max, ErrCode::task_PriceRepeatReviced);
                                    
        $index = 0;
        foreach ($list as $k =>$num) {
            if($num == $achieveDic->max){
                $index = $k;
                break;
            }
        }        
        //领取奖励
        $pList = explode(';', $mo->reward);
        StoreProc::AddMultiItemInStore($pList[$index]);
        
        //下一个max    
        if($index +1 < $length){
            $achieveDic->max = $list[$index+1];
        }
        ctx()->task->achieveDic->$typeId = $achieveDic;
        
        UserProc::updateUserInfo();                    
        return Resp::ok(array(
            "achieve"=>ctx()->task->achieveDic,            
            "cash"=> ctx()->baseInfo->cash,
            ));
    }
    
    /**
     * 初始化成就信息
     */
    public static function initAchieveData() {
        $dic = GameConfig::achieve_new();
        if($dic == null){
            return;
        }
        
        $achieveDic = ctx()->task->achieveDic;
        if(count((array)$achieveDic) > 0){
            return;
        }
        
        foreach ($dic as $key => $value) {
            $item = new Ins_Achieve();
            $typeId = $value->typeId;
            $item->typeId = $typeId;
            $item->cmd = $value->cmd;
            //$item->max = explode(',', $value->condition)[0];
            $item->max = $value->num;
            $achieveDic->$typeId = $item;
        }
        ctx()->task->achieveDic = $achieveDic;
    }
    
    //检测成就条件
    public static function CheckAchieveConditions($arg) {        
        $achieveDic = ctx()->task->achieveDic;
        foreach ($achieveDic as $key => $value) {
            $achieve = new Ins_Achieve($value);
            $tag = false;
            if($achieve->cmd == $arg->taskType){
                $mo = $achieve->getAchieveMo();               
                if($mo->paras == $arg->paras[0]){//暂定，若有多个参数，在进行解析
                    $tag = true;
                }
                
            }
            
            if($tag){//找到正确数据
                switch ($arg->ope) {
                    case Enum_PropelType::set:
                        $achieve->val = $arg->val; 
                        break;
                    case Enum_PropelType::add:
                        $achieve->val += $arg->val; 
                        break;
                    default:
                        break;
                }
                
                
            }
            
        }
        
        ctx()->task->achieveDic = $achieveDic;
        UserProc::updateUserInfo();            
        
    }
    
    //-------------------成就条件检测
    //单件装备等级达到X级
    static function accumulateEquiplevel_one($lv) {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_AchieveType::equiplevel_one, Enum_PropelType::set,$lv, array());
        //self::CheckAchieveConditions($taskEventArg);                
    }
    
    
    //累计消耗X钻石
    static function accumulateCostCash($num) {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_AchieveType::accumulateCostCash, Enum_PropelType::add,$num, array());
        //self::CheckAchieveConditions($taskEventArg);                           
    }
    
    
    
    //------------------------------------------------------
    
    public static function getTaskInfo() {
        list($type) = req()->paras;//武器uid
               
        return Resp::ok(array("task"=>ctx()->task,            
            ));
    }
    /**
     * 领取任务奖励
     * @return type
     */
    public static function ReceiveTaskReward() {
        list($type,$uid) = req()->paras;//uid
                
        my_Assert(StlUtil::dictHasProperty(ctx()->task->taskcards, $uid), ErrCode::task_NoExist);
        $task = ctx()->task->taskcards->$uid;
        $mo = GameConfig::taskcard_getItem($task->taskId);
        my_Assert($mo != null, ErrCode::err_const_no);
        
        $taskstepsMo = GameConfig::task_step_getItem($mo->tasksteps);
        my_Assert($taskstepsMo != null, ErrCode::err_const_no);
        
        $taskStep = $task->curSteps;
        my_Assert($taskStep->cur >= $taskstepsMo->num, ErrCode::task_CanotPriceReviced);
        my_Assert($task->state == Enum_TaskCardStateType::finish, ErrCode::task_CanotPriceReviced);
                     
        switch ($type) {
            case Enum_TaskType::DailyTask:
                ctx()->task->dailyTaskAccumulate += $mo->score;
                break;
            case Enum_TaskType::WeekTask:
                ctx()->task->weekTaskAccumulate += $mo->score;
                break;
            default:
                break;
        }
        $task->state = Enum_TaskCardStateType::drawed;
        ctx()->task->taskcards->$uid = $task;
        
        StoreProc::AddMultiItemInStore($mo->reward);
        
        return Resp::ok(array("task"=>ctx()->task,
            "store"=> ctx()->store,                  
            ));
    }
    
    static function ResetTask() {
        self::ResetTask_Daily();
        
        $week = date("w");
        if($week == 1){//每周一 第一次登录的时候刷新
            self::ResetTask_Week();
        }
    }
    
    /**
     * 每日任务重置
     */
    static function ResetTask_Daily() {
        $dic = GameConfig::taskcard();
        
        $retDic = new \stdClass();
        $taskcards = ctx()->task->taskcards;
        
        $dailyCards = array();
        foreach ($dic as $id => $mo) {
            if($mo->type == 1){       
                foreach ($taskcards as $uid => $card) {
                    if($card->typeId == $mo->typeId){                       
                        $dailyCards[] = $uid;
                    }
                }
                                                             
                $retDic->$id = $mo;
            }
        }
        
        foreach ($dailyCards as $uid) {
            unset($taskcards->$uid);
        }
        
        $retDic = (array) $retDic;
        if(count($retDic) <= 0){
            return;
        }
        
        ksort($retDic);
        $index = ctx()->task->taskIndex;
        foreach ($retDic as $id => $mo) {
            $index += 1;
            $task = new Ins_TaskCard($id);
            $taskcards->$index = $task;          
        }
        ctx()->task->taskIndex = $index;
        ctx()->task->taskcards = $taskcards;
        
        UserProc::updateUserInfo();         
    }
    
    /**
     * 每周任务重置
     */
    static function ResetTask_Week() {
        $dic = GameConfig::taskcard();
        
        $retDic = new \stdClass();
        $taskcards = ctx()->task->taskcards;
        
        $dailyCards = array();
        foreach ($dic as $id => $mo) {
            if($mo->type == 2){       
                foreach ($taskcards as $uid => $card) {
                    if($card->typeId == $mo->typeId){                       
                        $dailyCards[] = $uid;
                    }
                }
                                                             
                $retDic->$id = $mo;
            }
        }
        
        foreach ($dailyCards as $uid) {
            unset($taskcards->$uid);
        }
                       
        $retDic = (array) $retDic;
        if(count($retDic) <= 0){
            return;
        }
        
        ksort($retDic);
        $index = ctx()->task->taskIndex;
        foreach ($retDic as $id => $mo) {
            $index += 1;
            $task = new Ins_TaskCard($id);
            $taskcards->$index = $task;          
        }
        ctx()->task->taskIndex = $index;
        ctx()->task->taskcards = $taskcards;
        
        UserProc::updateUserInfo();         
    }

    //---------------------       
    /**
     * 每日登陆
     */
    static function OnUserLogin() {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_TaskCmdType::DailyLogin, Enum_PropelType::set, 1, array());
        self::CheckTaskCardConditions($taskEventArg);                           # 检查日常任务
    }
    
    /**
     * 参与主线关卡X次
     */
    static function OnChallengeZhuXianGate() {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_TaskCmdType::ChallengeZhuXianGate, Enum_PropelType::add, 1, array());
        self::CheckTaskCardConditions($taskEventArg);                           # 检查日常任务
    }
    
    /**
     * 参与日常关卡1次
     */
    static function OnChallengeDailyGate() {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_TaskCmdType::ChallengeDailyGate, Enum_PropelType::add, 1, array());
        self::CheckTaskCardConditions($taskEventArg);                           # 检查日常任务
    }
    
    /**
     * 每日商店购买物品1次
     */
    static function OnDailyShopBuyNum() {  
        $taskEventArg = new Ins_TaskEventArgs(Enum_TaskCmdType::DailyShopBuyNum, Enum_PropelType::add, 1, array());
        self::CheckTaskCardConditions($taskEventArg);                           # 检查日常任务
    }
       
           
    static function CheckTaskCardConditions($taskParam) {
        $bUpdate = false;
        $tasks = ctx()->task->taskcards;
        foreach ($tasks as $tid => &$task) {
            $task = new Ins_TaskCard($task);
            if ($task->state != Enum_TaskCardStateType::ing) {
                continue;
            }
            foreach ($task->curSteps as &$tsp) {                                # 初期里面只有一个任务
                $tsp = new Ins_TaskStep($tsp);
                if ($tsp->check_new($taskParam)) {
                    $bUpdate = true;
                    $tsp->propel($taskParam);
                    NormalEventProc::OnTaskCardStep_Process($task->uid, $tsp->typeId); # 任务进度更新
                    if ($tsp->isFinish()) {
                        NormalEventProc::OnTaskCardStep_Complete($task->uid, $tsp->typeId); # 广播任务步骤完成事件
//                        $tsp->doFinishAct();
                    }
                }
            }
            
            if ($task->IsFinish()) {                                            # 检查后添加后续任务
                $arr = array();
                foreach ($task->curSteps as &$tsp) {                            # 初期里面只有一个任务
                    $tsp = new Ins_TaskStep($tsp);
                    if (strlen($tsp->mo()->next) > 0) {                         # 有后续任务
                        $arr = array_merge($arr, explode(',', $tsp->mo()->next)); # 累加下一个任务步骤
                    }
                }
                foreach ($arr as $stpid) {                                      # 轮询添加后续任务
                    if ($stpid > 0) {
                        $task->AddStep($stpid);                                 # 将后续任务追加到任务列表中
                    }
                }

                if (count($arr) != 0) {
                    self::autoRecoverStateMissions($taskParam);
                }
            }
            if ($task->IsFinish()) {                                            # 检查是否任务卡的所有步骤都已完成
                $task->state = Enum_TaskCardStateType::finish;
                NormalEventProc::OnTaskCard_Finish($task->uid, null);           # 广播卡完成事件
            }
        }
        
        if ($bUpdate) {                                                         # 带回数据到客户端
            ctx()->task->taskcards = $tasks;
            UserProc::updateUserInfo();                                         # 更新玩家数据
        }

        return $bUpdate;
    }
    
    /**
     * 自动修复状态型任务
     */
    static function autoRecoverStateMissions() {
        $tasks = ctx()->task->taskcards;
        foreach ($tasks as $tid => &$task) {
            $task = new Ins_TaskCard($task);

            if ($task->state == Enum_TaskCardStateType::ing //                  # 进行中的或者已完成的
                    || $task->state == Enum_TaskCardStateType::finish) {
                foreach ($task->curSteps as &$tsp) {                            # 初期里面只有一个任务
                    $tsp = new Ins_TaskStep($tsp);
                    $tsp->autoCalcStatusCur();                   
                }
                if ($task->state == Enum_TaskCardStateType::finish) {           # 检查是否任务卡的所有步骤都已完成
                    if (!$task->IsFinish()) {
                        $task->state = Enum_TaskCardStateType::ing;             # 状态回退
                    }
                }
            }
        }
//        Clog::info("更新状态统计类的任务卡!");
        ctx()->task->taskcards = $tasks;
    }
            
}