代码整理.

Gameserver/Amfphp/model/User/Data_UserGame.php

@@ -341,13 +341,12 @@ class Data_UserGame extends HashSaver {
     }
 
     /**
-     * 给玩家增加体力
-     * @param Req $req
+     * 给玩家增加体力 
      * @param int $amt
      * @return type
      */
-    static function Add_tili($req, $amt) {
-        $user = $req->userInfo->game;
+    static function Add_tili($amt) {
+        $user = req()->userInfo->game;
         my_Assert($user, "user为空");
         my_Assert($amt >= 0, "体力amt小于0");
         ActiveProc::ChangeTili($amt);

Gameserver/Amfphp/model/User/Ins_TaskStep.php

@@ -91,7 +91,7 @@ class Ins_TaskStep extends Object_ext {
                         } else if (strtolower($plot->presentItem) == strtolower("rename")) {
                             // 跳过特殊字符串
                         } else {
-                            StoreProc::AddMultiItemInStore(req(), $plot->presentItem);
+                            StoreProc::AddMultiItemInStore($plot->presentItem);
                         }
                     }
                     if (!empty($plot->recycleItem)) {

Gameserver/Amfphp/process/ActiveProc.php

@@ -16,29 +16,28 @@ class ActiveProc {
 
     /**
      * 逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    public static function procMain($req) {
-        switch ($req->cmd) {
+    public static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::active_day7_drawreward:                               # 6502 领取七日签到奖励
-                return self::Day7_DrawReward($req);
+                return self::Day7_DrawReward();
             case CmdCode::active_getzonePublicTs:                               # 6503 查询开服时间戳
-                return ActiveProc::GetZonePublicTS($req);
+                return ActiveProc::GetZonePublicTS();
             case CmdCode::active_getTodayOnlineInfos:                           # 6504 查询当天在线时长
-                return self::getTotayOnlineInfos($req);
+                return self::getTotayOnlineInfos();
             case CmdCode::Task_Tili:                                            # 6508 体力变化
-                return ActiveProc::RecoveryTili($req);
+                return ActiveProc::RecoveryTili();
             case CmdCode::active_token_drawReward:                              # 6512 兑换码礼包
-                return self::drawActivePackageByCode($req);
+                return self::drawActivePackageByCode();
             case CmdCode::active_draw_onlinegift:                               # 6513 领取在线(时长)礼包
-                return self::drawOnlineGift($req);
+                return self::drawOnlineGift();
             case CmdCode::active_draw_reggift:                                  # 6514 领取全服注册礼包
-                return self::drawRegGift($req);
+                return self::drawRegGift();
             case CmdCode::active_presentTili:                                   # 6515 领取在线赠送体力
-                return self::drawTiliGift($req);
+                return self::drawTiliGift();
             case CmdCode::active_get_regnum:                                    # 6516 查询当前全服注册人数
-                return self::getRegNumber($req);
+                return self::getRegNumber();
 
             default:
                 return Resp::err(ErrCode::cmd_err);
@@ -46,43 +45,35 @@ class ActiveProc {
     }
 
     /**
-     * 每天重置
-     * @param type $req
+     * 每天重置 
      */
-    static function DailyReset($req) {
-        self::DailyResetDay7Task($req);
-        self::ClearOnlineGiftTs($req);
-        self::ClearDailyTiliGift($req);
+    static function DailyReset() {
+        self::DailyResetDay7Task();
+        self::ClearOnlineGiftTs();
+        self::ClearDailyTiliGift();
     }
 
 // <editor-fold defaultstate="collapsed" desc="    赠送体力    ">
 
     /**
-     * 领取 赠送体力
-     * @param Req $req
-     * @return type
+     * [6515] 领取 赠送体力  
      */
-    static function drawTiliGift($req) {
-        $user = new Data_UserGame($req->userInfo->game);
+    static function drawTiliGift() {
+        $user = new Data_UserGame(req()->userInfo->game);
         $privateState = new Info_PrivateState($user->privateState);
         $hour = date('G');
-        if (in_array($hour, $privateState->dailyDrawedTiliGift)) {              # 判断是否已领取
-            return Resp::err(ErrCode::active_hasgetted);
-        }
+        my_Assert(!in_array($hour, $privateState->dailyDrawedTiliGift), ErrCode::active_hasgetted); # 判断是否已领取
         $arr = explode(',', glc()->activity_presentTili_times);                 # 判断是否满足领取条件
-        if (!in_array($hour, $arr)) {
-            return Resp::err(ErrCode::active_illegal);              # 不满足条件
-        }
-        Data_UserGame::Add_tili($req, glc()->activity_presentTili_number); # 发放奖励
-
+        my_Assert(in_array($hour, $arr), ErrCode::active_illegal);              # 不满足条件
+        Data_UserGame::Add_tili(glc()->activity_presentTili_number);            # 发放奖励
         $privateState->dailyDrawedTiliGift[] = $hour;
-        $req->userInfo->game->privateState = $privateState;
-        UserProc::updateUserInfo();                                         # 回存
-        return Resp::ok(array(#                                     # 返回值
+        req()->userInfo->game->privateState = $privateState;
+        UserProc::updateUserInfo();                                             # 回存
+        return Resp::ok(array(#                                                 # 返回值
                     'key' => 'ok',
                     'record' => $privateState->dailyDrawedTiliGift,
-                    'tili' => $req->userInfo->game->baseInfo->tili,
-                    'time' => $req->userInfo->game->privateState->TiliTime,
+                    'tili' => $user->baseInfo->tili,
+                    'time' => $user->privateState->TiliTime,
         ));
     }
 
@@ -91,23 +82,21 @@ class ActiveProc {
 // <editor-fold defaultstate="collapsed" desc="    全服注册礼包    ">
 
     /**
-     * 查询当前全服注册人数
-     * @param type $req
+     * [6516] 查询当前全服注册人数 
      */
-    static function getRegNumber($req) {
+    static function getRegNumber() {
         return Resp::ok(array(
-                    'num' => gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid))
+                    'num' => gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int(req()->zoneid))
         ));
     }
 
     /**
-     * 领取全服注册礼包
-     * @param Req $req
+     * [6514] 领取全服注册礼包 
      */
-    static function drawRegGift($req) {
-        $user = new Data_UserGame($req->userInfo->game);
+    static function drawRegGift() {
+        $user = new Data_UserGame(req()->userInfo->game);
         $privateState = new Info_PrivateState($user->privateState);
-        $giftId = $req->paras[0];                                               # 礼包id
+        $giftId = req()->paras[0];                                               # 礼包id
         $giftModel = GameConfig::activity_reggift_getItem($giftId);             # 取礼包常亮数据
         if (null == $giftModel) {
             return Resp::err(ErrCode::err_const_no);
@@ -116,20 +105,20 @@ class ActiveProc {
             return Resp::err(ErrCode::active_hasgetted);
         }
         // 判断是否满足领取条件
-        if (gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid)) < $giftModel->regNumber) {
+        if (gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int(req()->zoneid)) < $giftModel->regNumber) {
             return Resp::err(ErrCode::active_illegal);              # 不满足条件
         }
-        $err = StoreProc::AddMultiItemInStore($req, $giftModel->rewardstr);     # 发放奖励
+        $err = StoreProc::AddMultiItemInStore($giftModel->rewardstr);           # 发放奖励
         if ($err) {
             return Resp::err($err);                                 # 失败
         }
         $privateState->drawedRegGift[] = $giftId;
         $user->privateState = $privateState;
-        $req->userInfo->game = $user;
+        req()->userInfo->game = $user;
         UserProc::updateUserInfo();                                         # 回存
         return Resp::ok(array(#                                     # 返回值
                     'key' => 'ok',
-                    'store' => $req->userInfo->game->store
+                    'store' => $user->store
         ));
     }
 
@@ -137,25 +126,23 @@ class ActiveProc {
 // <editor-fold defaultstate="collapsed" desc="    在线礼包   ">
 
     /**
-     * 【6504】查询当天在线时长信息
-     * @param req $req
+     * 【6504】查询当天在线时长信息 
      */
-    static function getTotayOnlineInfos($req) {
+    static function getTotayOnlineInfos() {
 
         return Resp::ok(array(
-                    "onlineGiftIDs" => $req->userInfo->game->privateState->onlineGiftIDs,
-                    "onlineGiftts" => $req->userInfo->game->privateState->onlineGiftts
+                    "onlineGiftIDs" => req()->userInfo->game->privateState->onlineGiftIDs,
+                    "onlineGiftts" => req()->userInfo->game->privateState->onlineGiftts
         ));
     }
 
     /**
-     * 6513 领取连续在线礼包
-     * @param req $req
+     * [6513] 领取连续在线礼包 
      */
-    static function drawOnlineGift($req) {
-        $user = $req->userInfo->game;
+    static function drawOnlineGift() {
+        $user = req()->userInfo->game;
         $privateState = new Info_PrivateState($user->privateState);
-        $giftid = $req->paras[0];                                               # 提取参数: 礼包的编号
+        $giftid = req()->paras[0];                                               # 提取参数: 礼包的编号
         $giftData = GameConfig::activity_onlinegift_getItem($giftid);           # 在线礼包常量数据
         my_Assert(null != $giftData, ErrCode::onlinegift_constno_err);          # 防御找不到配置数据
         my_Assert($privateState->onlineGiftts >= $giftData->onlineSec, #        # 时间未到，不可以领取
@@ -168,47 +155,45 @@ class ActiveProc {
 //        var_dump($privateState->onlineGiftIDs);
         my_Assert(!in_array($giftid, $privateState->onlineGiftIDs), #            # 判断礼包ID是否已经领取
                 ErrCode::active_hasgetted);
-        $err = StoreProc::AddMultiItemInStore($req, $giftData->rewardstr);      # 发放奖励
+        $err = StoreProc::AddMultiItemInStore($giftData->rewardstr);            # 发放奖励
         if ($err) {
             return Resp::err($err, '发放奖励失败');
         }
         $privateState->onlineGiftIDs[] = $giftid;                               # 记录已领礼包ID
         $user->privateState = $privateState;
-        $req->userInfo->game = $user;
+        req()->userInfo->game = $user;
         UserProc::updateUserInfo();                                             # 回写用户数据
 
         return Resp::ok(array(
                     'onlineGiftts' => $privateState->onlineGiftts,
                     'onlineGiftIDs' => $privateState->onlineGiftIDs,
                     "reward" => $packageInfo->reward,
-                    'gold' => $req->userInfo->game->baseInfo->gold,
-                    'cash' => $req->userInfo->game->baseInfo->cash,
-                    'tili' => $req->userInfo->game->baseInfo->tili,
-                    'store' => $req->userInfo->game->store,
-                    'hero' => $req->userInfo->game->heros
+                    'gold' => $user->baseInfo->gold,
+                    'cash' => $user->baseInfo->cash,
+                    'tili' => $user->baseInfo->tili,
+                    'store' => $user->store,
+                    'hero' => $user->heros
         ));                                                                     # 设置返回值
     }
 
     /**
-     * 清理/重置 在线礼包时间戳
-     * @param Req $req
+     * 清理/重置 在线礼包时间戳 
      */
-    static private function ClearOnlineGiftTs($req) {
-        $req->userInfo->game->privateState->onlineGiftts = 0;
-        $req->userInfo->game->privateState->onlineGiftIDs = array();
+    static private function ClearOnlineGiftTs() {
+        req()->userInfo->game->privateState->onlineGiftts = 0;
+        req()->userInfo->game->privateState->onlineGiftIDs = array();
     }
 
 // </editor-fold>
 // <editor-fold defaultstate="collapsed" desc="    兑换码     ">
 
     /**
-     * [6512]凭兑换码领取礼包
-     * @param Req $req
+     * [6512]凭兑换码领取礼包 
      */
-    static function drawActivePackageByCode($req) {
-        $user = new Data_UserGame($req->userInfo->game);
+    static function drawActivePackageByCode() {
+        $user = new Data_UserGame(req()->userInfo->game);
         $privateState = new Info_PrivateState($user->privateState);             # 快速访问
-        list( $activeId, $codestring) = $req->paras;                            # 取参数 活动id, 兑换码
+        list( $activeId, $codestring) = req()->paras;                            # 取参数 活动id, 兑换码
         $active = GameConfig::activity_getItem($activeId);                      # 活动数据
         my_Assert(null != $active, ErrCode::active_const_no_err);
         my_Assert($active->startts <= now() && $active->endts >= now(), ErrCode::active_time); # 校验开放时间
@@ -216,7 +201,7 @@ class ActiveProc {
         $activeCode = CipheredBase32::Decode($codestring);                      # 解码
         $codePlatStr = GameConstants::GetPlatStringByActivteCode($activeCode);  # platstr
         my_Assert(GameConstants::AllPlatStr == $codePlatStr #                   # 忽略全平台礼包
-                || $req->userInfo->getPlatStr() == $codePlatStr, #              # 平台字符串必须相符
+                || req()->userInfo->getPlatStr() == $codePlatStr, #              # 平台字符串必须相符
                 ErrCode::active_activecode_plat); #                             # 平台错误
 
         my_Assert(is_int($activeCode->number) #                                 # 编号为int值
@@ -230,21 +215,21 @@ class ActiveProc {
                 ErrCode::active_activecode_outtime);                            # 激活码已经失效,或者礼包尚未开启
         my_Assert(!in_array($packageID, $privateState->usedTokens), ErrCode::active_hasgetted); # 已经领取过该礼包了
         my_Assert(!self::checkActiveCodeIsUsed($activeCode), ErrCode::active_activecode_used);  # 检查 该激活码是否已经使用过了
-        $err = StoreProc::AddMultiItemInStore($req, $packageInfo->reward);      # 发放礼包
+        $err = StoreProc::AddMultiItemInStore($packageInfo->reward);            # 发放礼包
         my_Assert(ErrCode::ok == $err, $err);                                   # 防御发放礼包过程出错
-        $req->userInfo->game->privateState->usedTokens[] = $packageID;          # 记录领取记录
-        $ok = self::setActiveCodeUserRecord($activeCode, $req->uid);            # 插入数据库
+        req()->userInfo->game->privateState->usedTokens[] = $packageID;          # 记录领取记录
+        $ok = self::setActiveCodeUserRecord($activeCode, req()->uid);            # 插入数据库
         my_Assert($ok, ErrCode::err_db);                                        # 数据库操作失败- 重试
         UserProc::updateUserInfo();                                             # 回存玩家数据
         $ret = array(#                                                          # 返回值
             "plat" => $codePlatStr,
             "packageId" => $activeCode->package,
             "reward" => $packageInfo->reward,
-            'gold' => $req->userInfo->game->baseInfo->gold,
-            'cash' => $req->userInfo->game->baseInfo->cash,
-            'tili' => $req->userInfo->game->baseInfo->tili,
-            'store' => $req->userInfo->game->store,
-            'hero' => $req->userInfo->game->heros
+            'gold' => $user->baseInfo->gold,
+            'cash' => $user->baseInfo->cash,
+            'tili' => $user->baseInfo->tili,
+            'store' => $user->store,
+            'hero' => $user->heros
         );
         return Resp::ok($ret);                                                  # 返回成功信息
     }
@@ -283,50 +268,44 @@ class ActiveProc {
 // </editor-fold>
 
     /**
-     * 查询当前分区开放时间戳
-     * @param Req $req
+     * [6503] 查询当前分区开放时间戳 
      */
-    private static function GetZonePublicTS($req) {
-        $zoneInfo = GameConfig::zonelist_getItem($req->zoneid);
+    private static function GetZonePublicTS() {
+        $zoneInfo = GameConfig::zonelist_getItem(req()->zoneid);
         return Resp::ok($zoneInfo->publicTs);
     }
 
 // <editor-fold defaultstate="collapsed" desc="  体力  ">
 
     /**
-     * 
-     * @param req $req
-     * @return type
+     * [6508]  
      */
-    public static function RecoveryTili($req) {
-        $useTili = $req->paras[0];
+    public static function RecoveryTili() {
+        $useTili = req()->paras[0];
         ActiveProc::ChangeTili($useTili);
 
         UserProc::updateUserInfo();
         $result = array(
-            'time' => $req->userInfo->game->privateState->TiliTime,
-            'tili' => $req->userInfo->game->baseInfo->tili
+            'time' => req()->userInfo->game->privateState->TiliTime,
+            'tili' => req()->userInfo->game->baseInfo->tili
         );
         $resp = Resp::ok($result);
         return $resp;
     }
 
     /**
-     * 清理每天的赠送体力领取记录
-     * @param Req $req
+     * 清理每天的赠送体力领取记录 
      */
-    private static function ClearDailyTiliGift($req) {
-        $req->userInfo->game->privateState->dailyDrawedTiliGift = ArrayInit();
+    private static function ClearDailyTiliGift() {
+        req()->userInfo->game->privateState->dailyDrawedTiliGift = ArrayInit();
     }
 
     /**
      * 修改玩家体力
-     * @param int $useTili $useTili>0代表增加体力,   $useTili<0代表消耗体力
-     * @return type
+     * @param int $useTili $useTili>0代表增加体力,   $useTili<0代表消耗体力 
      */
     public static function ChangeTili($useTili) {
-        $req = req();
-        $user = $req->userInfo->game;
+        $user = req()->userInfo->game;
         $moreTili = 0;                                                          # 超上限的体力值
 // 如果没有tilitime这个值,说明是以前老用户新登录的,为了纠错在判断里面补值.(正常用户不会进入判断内部)
         if (!CommUtil::isPropertyExists($user->privateState, "TiliTime")) {
@@ -360,49 +339,47 @@ class ActiveProc {
 // <editor-fold defaultstate="collapsed" desc="    7日签到   ">
 
     /**
-     * 重置7日签到相关计数器
-     * @param Req $req
+     *  重置7日签到相关计数器 
      */
-    static function DailyResetDay7Task($req) {
-        $req->userInfo->game->gates->Times = 0;
-
+    static function DailyResetDay7Task() {
+        req()->userInfo->game->gates->Times = 0;
         $typeID = 6;                                                            #  7日活动
         $ac = GameConfig::activity_getItem($typeID);
         my_Assert(null != $ac, ErrCode::err_const_no);
         $startDay = tsDay($ac->startts);
-        $newLoginDays = array_filter($req->userInfo->game->privateState->LoginDays, # 剔除不符合时间的登录记录
-                function($tsday)use($startDay) {
-            return $startDay <= $tsday;
-        }
+        $newLoginDays = array_filter(req()->userInfo->game->privateState->LoginDays, # 剔除不符合时间的登录记录
+                function ($tsday)use ($startDay) {
+                    return $startDay <= $tsday;
+                }
         );
-        $req->userInfo->game->privateState->LoginDays = $newLoginDays;          # 
-        if (count($req->userInfo->game->privateState->LoginDays) < 7) {
-            $req->userInfo->game->privateState->LoginDays[] = tsDay();
+        req()->userInfo->game->privateState->LoginDays = $newLoginDays;          # 
+        if (count(req()->userInfo->game->privateState->LoginDays) < 7) {
+            req()->userInfo->game->privateState->LoginDays[] = tsDay();
         }
     }
 
     /**
-     * [6502] 领取七日签到奖励
-     * @param req $req
+     * [6502] 领取七日签到奖励 
      */
-    static function Day7_DrawReward($req) {
+    static function Day7_DrawReward() {
         // 设计7日数据结构
-        list($day) = $req->paras;                                               # 参数: 领取第x天的奖励
-        $private = new Info_PrivateState($req->userInfo->game->privateState);   # 私有数据
+        list($day) = req()->paras;                                               # 参数: 领取第x天的奖励
+        $user = req()->userInfo->game;
+        $private = new Info_PrivateState($user->privateState);   # 私有数据
         my_Assert(count($private->LoginDays) >= $day, ErrCode::active_day7_totaldays);
         my_Assert(!in_array($day, $private->day7_drawed), ErrCode::active_hasgetted);
         $day_rwd = GameConfig::activity_day7_getItem($day);                     # 查询奖励数据
         my_Assert(null != $day_rwd, ErrCode::err_const_no);                     # 防御找不到配置
-        StoreProc::AddMultiItemInStore($req, $day_rwd->reward);                 # 发放奖励
+        StoreProc::AddMultiItemInStore($day_rwd->reward);                       # 发放奖励
         $private->day7_drawed[] = $day;                                         # 添加领取记录
-        $req->userInfo->game->privateState = $private;                          # 更新数据
+        $user->privateState = $private;                          # 更新数据
         UserProc::updateUserInfo();                                             # 回存
         return Resp::ok(array(
-                    'gold' => $req->userInfo->game->baseInfo->gold,
-                    'cash' => $req->userInfo->game->baseInfo->cash,
-                    'tili' => $req->userInfo->game->baseInfo->tili,
-                    'store' => $req->userInfo->game->store,
-                    'hero' => $req->userInfo->game->heros
+                    'gold' => $user->baseInfo->gold,
+                    'cash' => $user->baseInfo->cash,
+                    'tili' => $user->baseInfo->tili,
+                    'store' => $user->store,
+                    'hero' => $user->heros
         ));                                                                     # 返回值
     }
 

Gameserver/Amfphp/process/CollegeProc.php

@@ -19,17 +19,16 @@ class CollegeProc {
 
     /**
      * 逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    public static function procMain($req) {
-        switch ($req->cmd) {
-            case CmdCode::cmd_college_ActiveTaskCard:
-                return CollegeProc::ActiveTaskCard($req);
-            case CmdCode::cmd_college_ReceiveCollegeReward:
-                return CollegeProc::ReceiveCollegeReward($req);
-            case CmdCode::cmd_college_ReceiveCourseReward:
-                return CollegeProc::ReceiveCourseReward($req);
+    public static function procMain() {
+        switch (req()->cmd) {
+            case CmdCode::cmd_college_ActiveTaskCard:                           # 7301 激活任务卡
+                return CollegeProc::ActiveTaskCard();
+            case CmdCode::cmd_college_ReceiveCollegeReward:                     # 7302 领取年级奖励
+                return CollegeProc::ReceiveCollegeReward();
+            case CmdCode::cmd_college_ReceiveCourseReward:                      # 7303 领取课程奖励
+                return CollegeProc::ReceiveCourseReward();
 
             default:
                 Err(ErrCode::cmd_err);
@@ -37,10 +36,10 @@ class CollegeProc {
     }
 
     /**
-     * 激活
-     * @param Req $req
+     * 7301 激活 
      */
-    public static function ActiveTaskCard($req) {
+    public static function ActiveTaskCard() {
+        $req = req();
         list($taskCardId) = $req->paras;
         $collegeInfo = $req->userInfo->game->college;
         $compMissCardDic = $collegeInfo->compMissCardDic;
@@ -52,12 +51,12 @@ class CollegeProc {
             return Resp::err(ErrCode::college_TaskCardStateError);
         }
 
-        $cid = StoreProc::PutTaskCardInStore($taskCardId, $req); //存入背包
-        NormalEventProc::OnTaskCard_Actived($cid, null);                # 带入事件
+        $cid = StoreProc::PutTaskCardInStore($taskCardId);                      // 存入背包
+        NormalEventProc::OnTaskCard_Actived($cid, null);                        # 带入事件
         $compMissCardDic->$taskCardId->indexId = $cid;
         $compMissCardDic->$taskCardId->type = Enum_TaskCardStateType::ing;
 
-        $taskCard = new Ins_TaskCard($req->userInfo->game->store->taskcards->$cid);          # 任务卡对象
+        $taskCard = new Ins_TaskCard($req->userInfo->game->store->taskcards->$cid); # 任务卡对象
         $taskCard->state = Enum_TaskCardStateType::ing;
 
         TaskProc::OnGetSchoolTask();
@@ -83,10 +82,10 @@ class CollegeProc {
     }
 
     /**
-     * 领取一个年级的奖励
-     * @param Req $req
+     * 7302 领取一个年级的奖励 
      */
-    public static function ReceiveCollegeReward($req) {
+    public static function ReceiveCollegeReward() {
+        $req = req();
         $collegeInfo = $req->userInfo->game->college;
         $dic = GameConfig::college_getItem($collegeInfo->collegeId);
         $tag = true;
@@ -100,7 +99,7 @@ class CollegeProc {
         if (!$tag) {
             return Resp::err(ErrCode::college_courseNumError);
         }
-        StoreProc::AddMultiItemInStore($req, GameConfig::course_getItem($collegeInfo->courseId)->prize);      # 发放奖励
+        StoreProc::AddMultiItemInStore(GameConfig::course_getItem($collegeInfo->courseId)->prize);      # 发放奖励
 
         $college = new Info_College($req->userInfo->game->college);
         $college->updataCourseNew();
@@ -112,10 +111,10 @@ class CollegeProc {
     }
 
     /**
-     * 领取课程奖励
-     * @param Req $req
+     * 7303 领取课程奖励 
      */
-    public static function ReceiveCourseReward($req) {
+    public static function ReceiveCourseReward() {
+        $req = req();
         //list($taskCardId) = $req->paras;
         $collegeInfo = $req->userInfo->game->college;
 
@@ -131,14 +130,12 @@ class CollegeProc {
             return Resp::err(ErrCode::college_taskCardNumError);
         }
 
-        StoreProc::AddMultiItemInStore($req, GameConfig::course_getItem($collegeInfo->courseId)->prize);      # 发放奖励
+        StoreProc::AddMultiItemInStore(GameConfig::course_getItem($collegeInfo->courseId)->prize);      # 发放奖励
         TaskProc::OnFinishAllSchoolTaskOfGrade($collegeInfo->courseId);
-        
+
         $college = new Info_College($req->userInfo->game->college);
         $college->updataCourse();
-        
-        
-        
+
         $req->userInfo->game->college = $college;
         UserProc::updateUserInfo();
 

Gameserver/Amfphp/process/EmailProc.php

@@ -148,7 +148,7 @@ class EmailProc {
         my_Assert($mail->readts > 0, ErrCode::err_innerfault);                  # 未打开的不可能调用领取接口
         my_Assert($mail->isExistReward(), ErrCode::email_no_appendix);          # 先判断邮件，是否存在有效的奖励物品
         my_Assert($mail->drawedts <= 0, ErrCode::email_appendix_drawed);        # 邮件不可重复领取
-        $err = StoreProc::AddMultiItemInStore(req(), $mail->appendix, 4);        # 发放奖励  
+        $err = StoreProc::AddMultiItemInStore($mail->appendix, 4);              # 发放奖励  
 
         my_Assert(ErrCode::ok == $err, $err);                                   # 发奖成功
         $mail->drawedts = now();                                                # 更新领取时间戳
@@ -186,7 +186,7 @@ class EmailProc {
                 if ($m->drawedts > 0) {                                         # 已领取邮件跳过
                     continue;
                 }
-                $err = StoreProc::AddMultiItemInStore(req(), $m->appendix, 4);
+                $err = StoreProc::AddMultiItemInStore($m->appendix, 4);
                 my_Assert(ErrCode::ok == $err, $err);                           # 发奖成功
                 $m->drawedts = now();                                           # 更新下领取时间戳
                 if ($m->readts <= 0) {                                          # 更新下读取时间戳

Gameserver/Amfphp/process/EventProc.php

@@ -11,23 +11,22 @@ namespace loyalsoft;
  */
 class EventProc {
 
-    public static function procMain($req) {
-        switch ($req->cmd) {
+    public static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::cmd_event_GetNotifications:                           # 7201 拉取角标通知列表
-                return self::GetCornerSignNotifications($req);
+                return self::GetCornerSignNotifications();
             default:
                 return Resp::err(ErrCode::cmd_err);
         }
     }
 
     /**
-     * [7201] 拉取角标通知
-     * @param req $req
+     * [7201] 拉取角标通知 
      */
-    static function GetCornerSignNotifications($req) {
+    static function GetCornerSignNotifications() {
         // 这里直接返回, 将来开发对应的触发逻辑, 给数组中添加相应的值
-        $arr = array_values(array_unique($req->userInfo->game->privateState->cornerSignNotifications)); # 返回值去重
-        $req->userInfo->game->privateState->cornerSignNotifications = [];       # 清理记录
+        $arr = array_values(array_unique(req()->userInfo->game->privateState->cornerSignNotifications)); # 返回值去重
+        req()->userInfo->game->privateState->cornerSignNotifications = [];       # 清理记录
         UserProc::updateUserInfo();
         return Resp::ok(array("notifications" => $arr));                        # 返回
     }

Gameserver/Amfphp/process/FightProc.php

@@ -24,7 +24,7 @@ class FightProc {
                 return SweepGatesProc::Arenas_Fight();
             case CmdCode::cmd_fight_arenassweep:                                # [6802] 扫荡
                 Err(ErrCode::function_notopen_msg);                             # 暂未开放扫荡功能. -gwang 2020.4.20
-                return SweepGatesProc::Arenas_NewSweepFight(req());
+                return SweepGatesProc::Arenas_NewSweepFight();
 
             case CmdCode::cmd_fight_GetArenasActiveReward:                      # 6806 领取章节星级奖励
                 return SweepGatesProc::DrawChapterStarsReward();
@@ -71,7 +71,7 @@ class FightProc {
      * 清理每日字段
      */
     static function ClearByDay() {
-        SweepGatesProc::ClearGateTimes(req());                                   # 清理每个难度副本的每日战斗次数 
+        SweepGatesProc::ClearGateTimes();                                        # 清理每个难度副本的每日战斗次数 
         $pvp = new Info_UserPVP(req()->userInfo->game->pvp);
         $pvp->refreshDailyData();
         $pvp->sendRewardEmail(req()->zoneid, req()->uid, PVPProc::GetCurSeasonID());

Gameserver/Amfphp/process/FightProc/PVPProc.php

@@ -183,7 +183,7 @@ class PVPProc {
         my_Assert($pvp->pvpCoins > $citem->price, ErrCode::pvp_coinnotenough);  # pvp币不足 
         $citem->sold += 1;                                                      # 设置已售罄/已购买标志
         $pvp->pvpCoins -= $citem->price;                                        # 扣除竞技币 
-        StoreProc::AddMultiItemInStore(req(), $citem->goods);                    // 发放道具
+        StoreProc::AddMultiItemInStore($citem->goods);                          # 发放道具
         req()->userInfo->game->pvp = $pvp;                                       // 回写数据
         UserProc::updateUserInfo();
         return Resp::ok(array('pvp' => $pvp, 'store' => req()->userInfo->game->store)); # 返回

Gameserver/Amfphp/process/FightProc/SweepGatesProc.php

@@ -31,7 +31,7 @@ class SweepGatesProc {
     public static function Arenas_preFight() {
         list($gateId, $difficulty) = req()->paras;                               # 提取参数 
         my_Assert($gateId > 0, "关卡id非法");
-        $isFirst = self::isFirstChallenge(req(), $gateId, $difficulty);          # 是否首次通关 
+        $isFirst = self::isFirstChallenge($gateId, $difficulty);                # 是否首次通关 
         $smGate = GameConfig::gate_getItem($gateId);                            # 关卡配置数据
         $i = $difficulty + 1;                                                   # 按三个难度取不同的值.
 //        $tili = self::getProperty_n($smGate, "tili", $i);                     # 体力暂时未用上
@@ -112,15 +112,16 @@ class SweepGatesProc {
             $sumOfStars += $sinfo->Stars();
         });
         my_Assert($stars <= $sumOfStars, ErrCode::err_arenas_starreward_starNotEnough); # 星数未达标
-        StoreProc::AddMultiItemInStore(req(), $starCfg->reward);                # 发放奖励
+        StoreProc::AddMultiItemInStore($starCfg->reward);                       # 发放奖励
         $starsArr[] = $stars;                                                   # 领奖记录
         $userGates->chapterStarsRwd->$chapterId->$hard = $starsArr;             # 回写数据
         req()->userInfo->game->gates = $userGates;
 
         UserProc::updateUserInfo();
-        return Resp::ok(array("store" => req()->userInfo->game->store,
-                    'gold' => req()->userInfo->game->baseInfo->gold,
-                    'cash' => req()->userInfo->game->baseInfo->cash
+        $user = req()->userInfo->game;
+        return Resp::ok(array("store" => $user->store,
+                    'gold' => $user->baseInfo->gold,
+                    'cash' => $user->baseInfo->cash
         ));         # 返回值  
     }
 
@@ -134,7 +135,7 @@ class SweepGatesProc {
 //        $_md5 = md5($gateId . $difficulty . $rewardStr);
 //        my_Assert($md5 == $_md5, ErrCode::err_arenas_rewardIllegal);            # 奖励不匹配
         $isFirst = false;                                                       # 是否首次通关
-        self::recordFight(req(), $gateId, $difficulty, $star, $isFirst);         # 更新挑战记录 
+        self::recordFight($gateId, $difficulty, $star, $isFirst);         # 更新挑战记录 
         $smGate = GameConfig::gate_getItem($gateId);                            # 关卡配置数据
         $i = $difficulty + 1;                                                   # 按三个难度取不同的值. 
 //        $gold = self::getProperty_n($smGate, "gold", $i);
@@ -161,15 +162,16 @@ class SweepGatesProc {
         UserProc::updateUserInfo();                                             # 回写玩家数据.
 #
         TaskProc::OnPassGateN($gateId, $difficulty + 1);
+        $user = req()->userInfo->game;
         $result = array(
-            'store' => req()->userInfo->game->store,
-            'heros' => req()->userInfo->game->heros,
-            'gates' => req()->userInfo->game->gates,
-            'tili' => req()->userInfo->game->baseInfo->tili,
-            'time' => req()->userInfo->game->privateState->TiliTime,
-            'gold' => req()->userInfo->game->baseInfo->gold,
-            'resPoint' => req()->userInfo->game->baseInfo->resPoint,
-            'cash' => req()->userInfo->game->baseInfo->cash,
+            'store' => $user->store,
+            'heros' => $user->heros,
+            'gates' => $user->gates,
+            'tili' => $user->baseInfo->tili,
+            'time' => $user->privateState->TiliTime,
+            'gold' => $user->baseInfo->gold,
+            'resPoint' => $user->baseInfo->resPoint,
+            'cash' => $user->baseInfo->cash,
             'exp' => $exp,
 //            'rewardstr' => implode(';', $rewardArr),
             'isFirst' => $isFirst,
@@ -182,7 +184,7 @@ class SweepGatesProc {
      * @param Req $req
      * @param type $rewardStr
      */
-    public static function SetRewards($req, $rewardStr) {
+    public static function SetRewards($rewardStr) {
         $getedArr = array();                                                    # 统计所获奖励物品
         $rewardsArr = explode(";", $rewardStr);
         foreach ($rewardsArr as $r) {                                           #    
@@ -190,7 +192,7 @@ class SweepGatesProc {
 //            $percentStr = explode(',', $r)[2];
 //            $percent = intval(trim($percentStr, "%"));                          # 剔除%
 //            if (CommUtil::randomPercent($percent)) {
-                $err = StoreProc::AddMultiItemInStore($req, $r);                # 发放奖励物品
+                $err = StoreProc::AddMultiItemInStore($r);                      # 发放奖励物品
                 my_Assert($err == ErrCode::ok, $err);                           # 出错了
                 $getedArr[] = $r;                                               # 剔除最后一段概率字符串
 //            }
@@ -200,14 +202,13 @@ class SweepGatesProc {
     }
 
     /**
-     * 更新战斗记录
-     * @param req $req
+     * 更新战斗记录 
      * @param type $gateId
      * @param type $difficulty
      * @param type $star
      */
-    private static function isFirstChallenge($req, $gateId, $difficulty) {
-        $userGates = $req->userInfo->game->gates;
+    private static function isFirstChallenge($gateId, $difficulty) {
+        $userGates = req()->userInfo->game->gates;
         if ($difficulty == 0) {                                                 # 按照难度查找
             $diffCult = $userGates->normal;
         } else if ($difficulty == 1) {
@@ -226,7 +227,7 @@ class SweepGatesProc {
             Err(ErrCode::err_arenasgate_indexillegal);
         }
 
-        $uGate = new Ins_UGate();                                              # 当前关卡的记录数据
+        $uGate = new Ins_UGate();                                               # 当前关卡的记录数据
         if (isset($diffCult->gates->$gateId)) {
             $uGate = $diffCult->gates->$gateId;
         }
@@ -235,14 +236,13 @@ class SweepGatesProc {
     }
 
     /**
-     * 更新战斗记录
-     * @param req $req
+     * 更新战斗记录 
      * @param type $gateId
      * @param type $difficulty
      * @param type $star
      */
-    private static function recordFight($req, $gateId, $difficulty, $star, &$isFirst = false) {
-        $userGates = $req->userInfo->game->gates;
+    private static function recordFight($gateId, $difficulty, $star, &$isFirst = false) {
+        $userGates = req()->userInfo->game->gates;
         if ($difficulty == 0) {                                                 # 按照难度查找
             $diffCult = $userGates->normal;
         } else if ($difficulty == 1) {
@@ -264,7 +264,7 @@ class SweepGatesProc {
 
         if ($gateId == $diffCult->highest + 1 && $star > 0) {                   # 星级大于等于0,才可以推关
             $diffCult->highest += 1;                                            # 更新最高记录
-            RankProc::recordNewPassGateInfo($req->uid, $gateId);                # 更新通关记录
+            RankProc::recordNewPassGateInfo(req()->uid, $gateId);                # 更新通关记录
         }
         $diffCult->latest = $gateId;                                            # 记录上次挑战关卡id
 
@@ -282,56 +282,47 @@ class SweepGatesProc {
 
         $userGates->TotalNum++;                                                 # 总战斗次数+1 
         $userGates->Times++;
-        $req->userInfo->game->gates = $userGates;                               # 回写数据
+        req()->userInfo->game->gates = $userGates;                               # 回写数据
     }
 
     /**
-     * 清理每个难度副本的每日战斗次数
-     * @param Req $req
+     * 清理每个难度副本的每日战斗次数 
      */
-    public static function ClearGateTimes($req) {
-        $req->userInfo->game->gates->Times = 0;
+    public static function ClearGateTimes() {
+        req()->userInfo->game->gates->Times = 0;
     }
 
 //
 // <editor-fold defaultstate="collapsed" desc=" 扫荡  ">
 
     /**
-     * [6802]新扫荡
-     * @param req $req 
+     * [6802]新扫荡 
      */
-    public static function Arenas_NewSweepFight($req) {
+    public static function Arenas_NewSweepFight() {
         Err(ErrCode::err_method_obsoleted);                                     # 没开扫荡功能
-        $gateId = $req->paras[0];
-        $difficulty = $req->paras[1];                                           # 关卡难度 difficulty
-        $costItemId = $req->paras[2];                                           # 扫荡券id
+        list($gateId, $difficulty, $costItemId) = req()->paras;                 # 关卡id, 难度 difficulty, 扫荡券id
 
+        $user = req()->userInfo->game;
         $smGate = GameConfig::gate_getItem($gateId);
-
-        if (!CommUtil::isPropertyExists($req->userInfo->game->gates, "newGateRecord")) {
-            $req->userInfo->game->gates->newGateRecord = ObjectInit();          # 防御未初始化的变量
-        }
-        $gatesRecord = $req->userInfo->game->gates->newGateRecord;
-        if (!CommUtil::isPropertyExists($gatesRecord, "record")) {
-            $gatesRecord->record = ObjectInit();                                # 防御未初始化的变量
-        }
-
+        my_default_Obj($user->gates->newGateRecord);                            # 防御未初始化的变量
+        $gatesRecord = $user->gates->newGateRecord;
+        my_default_Obj($gatesRecord->record);                                   # 防御未初始化的变量
 
         $i = $difficulty + 1;                                                   // 按三个难度取不同的值.
         $tili = self::getProperty_n($smGate, "tili", $i);
         $reward = self::getProperty_n($smGate, "reward", $i);
         $gold = self::getProperty_n($smGate, "gold", $i);
         $exp = self::getProperty_n($smGate, "exp", $i);
-        $err = StoreProc::removeItemFromStore($req->userInfo->game->store, $costItemId, 1);
+        $err = StoreProc::removeItemFromStore($user->store, $costItemId, 1);
         my_Assert(ErrCode::ok == $err, $err);                                   # 扣除失败
-        $canfighterr = SweepGatesProc::CanFight($req, $gateId, $difficulty);    # 补充战斗记录
+        $canfighterr = SweepGatesProc::CanFight($gateId, $difficulty);          # 补充战斗记录
         if ($canfighterr) {#不能符合战斗要求
             return $canfighterr;
         }
-        $req->userInfo->game->gates->newGateRecord = $gatesRecord;              # 回写数据
+        $user->gates->newGateRecord = $gatesRecord;                             # 回写数据
         ActiveProc::ChangeTili(- $tili);                                        # 扣减体力
-        $req->userInfo->game->gates->TotalNum++;                                # 更新战斗次数统计
-        $req->userInfo->game->gates->Times++;
+        $user->gates->TotalNum++;                                               # 更新战斗次数统计
+        $user->gates->Times++;
 
         $rewardsArr = explode(";", $reward);
         $rwds = array();
@@ -341,24 +332,22 @@ class SweepGatesProc {
             $num = intval($arr[1]);
             $probability = intval($arr[2]);
             if (CommUtil::randomPercent($probability)) {                        # 投色子
-                $err = StoreProc::AddMultiItemInStore($req, "$itemid,$num");
-                if ($err) {
-                    return Resp::err($err);
-                }
+                $err = StoreProc::AddMultiItemInStore("$itemid,$num");
+                my_Assert(ErrCode::ok == $err, $err);
                 $rwds[] = "$itemid,$num";
             }
         }
 
-        Data_UserGame::Add_Gold($req->userInfo->game->baseInfo, $gold);         # 发放金币奖励
+        Data_UserGame::Add_Gold($user->baseInfo, $gold);                        # 发放金币奖励
         my_Assert(ErrCode::ok == $err, $err);                                   # 失败
-        Data_UserGame::Add_Exp($req->userInfo->game->baseInfo, $exp);           # 发放经验奖励
+        Data_UserGame::Add_Exp($user->baseInfo, $exp);                          # 发放经验奖励
         UserProc::updateUserInfo();                                             # 在获取战利品哪里已经update了.
         $result = array(
-            'store' => $req->userInfo->game->store,
-            'heros' => $req->userInfo->game->heros,
-            'gates' => $req->userInfo->game->gates,
-            'tili' => $req->userInfo->game->baseInfo->tili,
-            'time' => $req->userInfo->game->privateState->TiliTime,
+            'store' => $user->store,
+            'heros' => $user->heros,
+            'gates' => $user->gates,
+            'tili' => $user->baseInfo->tili,
+            'time' => $user->privateState->TiliTime,
             'gold' => $gold,
             'exp' => $exp,
             'rewardstr' => implode(';', $rwds)
@@ -367,14 +356,13 @@ class SweepGatesProc {
     }
 
     /**
-     * 是否可以战斗
-     * @param type $req
+     * 是否可以战斗 
      * @param $gateId
      * @param $difficulty
      * @return type
      */
-    static function CanFight($req, $gateId, $difficulty) {
-        $gatesRecord = $req->userInfo->game->gates->newGateRecord;
+    static function CanFight($gateId, $difficulty) {
+        $gatesRecord = req()->userInfo->game->gates->newGateRecord;
         $smGate = GameConfig::gate_getItem($gateId);
         if (!CommUtil::isPropertyExists($gatesRecord->record, $gateId)) {
             $gatesRecord->record->$gateId = ObjectInit();

Gameserver/Amfphp/process/HeroProc.php

@@ -10,58 +10,61 @@ class HeroProc {
 
     /**
      * 英雄处理逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    static function procMain($req) {
-        switch ($req->cmd) {
+    static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::cmd_hero_levelup:                                     #  [6301] 英雄升级
-                return HeroProc::HeroLevelUpCostExpItem($req);
+                return HeroProc::HeroLevelUpCostExpItem();
+            // <editor-fold defaultstate="collapsed" desc="过时 接口">                
             case CmdCode::cmd_hero_stageup:                                     #  [6304] 英雄进阶 SABCD
-                return HeroProc::HeroStageUp($req);
-            // <editor-fold defaultstate="collapsed" desc="过时 接口">
+                return HeroProc::HeroStageUp();
+
 //            case CmdCode::cmd_hero_upstar:                                    #  [6305] 英雄升星
-//                return HeroProc::HeroUpStarByPieces($req);
+//                return HeroProc::HeroUpStarByPieces();
 //            case CmdCode::cmd_hero_changelockstate:                           #  [6306] 英雄-修改锁定状态
-//                return HeroProc::HeroChangelockstate($req); 
+//                return HeroProc::HeroChangelockstate(); 
 //            case CmdCode::cmd_hero_buyCollectHeroLimtCount:                   #  [6312] 扩展英雄数量上限
-//                return HeroProc::BuyHeroMaxCountLimt($req); 
+//                return HeroProc::BuyHeroMaxCountLimt(); 
+            // <editor-fold defaultstate="collapsed" desc="---------------英雄评论----------------">
+//            case CmdCode::cmd_hero_GetDiscuss:                                  #  [6316]拉取英雄评论
+//                return HeroDiscussProc::GetDiscusses();
+//            case CmdCode::cmd_hero_PostDiscuss:                                 #  [6317]对英雄发表评论
+//                return HeroDiscussProc::Post();
+//            case CmdCode::cmd_hero_PraiseDiscuss:                               #  [6318]给某条评论点赞
+//                return HeroDiscussProc::PriaseMsg();
+//            case CmdCode::cmd_hero_DeleteDiscuss:                               #  [6319]删除评论
+//                return HeroDiscussProc::DeletePost();
+//            case CmdCode::cmd_hero_scoreit:                                     #  [6320]给某个英雄评分
+//                return HeroDiscussProc::Score();
+            // </editor-fold>
+            // <editor-fold defaultstate="collapsed" desc=" 英雄的解锁与购买 ">
+//            case CmdCode::cmd_hero_buyHero:                                     #  [6321]购买英雄
+//                return HeroProc::BuyHeroByCostPieces();
+//            case CmdCode::cmd_hero_upGodBlood:                                  #  [6322] 神血升级
+//                return HeroProc::UpGodBloodHeroByPieces();
+//            case CmdCode::cmd_hero_unlockByPieces:                            #  [6323] 解锁碎片
+//                return HeroProc::UnLockHeroByPieces();                
+// </editor-fold>
             // </editor-fold>
 # --------- 英雄技能 -----------                
             case CmdCode::cmd_hero_upgradeSkillLevel:                           #  [6314] 英雄的技能升级
-                return HeroProc::UpgradeSkillLevel($req);
+                return HeroProc::UpgradeSkillLevel();
             case CmdCode::cmd_hero_unlockSkill:                                 #  [6324] 英雄技能 - 解锁技能 
-                return HeroProc::UnlockSkill($req);
+                return HeroProc::UnlockSkill();
             case CmdCode::cmd_hero_skillLevel_onekeyupgrade:                    #  [6325] 英雄技能 - 一键升级
-                return HeroProc::OnekeyUpgradeSkillLevel($req);
+                return HeroProc::OnekeyUpgradeSkillLevel();
             case CmdCode::cmd_hero_saveHeroTeamConfig:                          #  [6315] 保存玩家战队数据
-                return HeroProc::SaveHeroTeamConfig($req);
+                return HeroProc::SaveHeroTeamConfig();
+
+            // <editor-fold defaultstate="collapsed" desc="   英雄升级 cyzhao  ">
 
-            // <editor-fold defaultstate="collapsed" desc="---------------英雄评论----------------">
 
-            case CmdCode::cmd_hero_GetDiscuss:                                  #  [6316]拉取英雄评论
-                return HeroDiscussProc::GetDiscusses($req);
-            case CmdCode::cmd_hero_PostDiscuss:                                 #  [6317]对英雄发表评论
-                return HeroDiscussProc::Post($req);
-            case CmdCode::cmd_hero_PraiseDiscuss:                               #  [6318]给某条评论点赞
-                return HeroDiscussProc::PriaseMsg($req);
-            case CmdCode::cmd_hero_DeleteDiscuss:                               #  [6319]删除评论
-                return HeroDiscussProc::DeletePost($req);
-            case CmdCode::cmd_hero_scoreit:                                     #  [6320]给某个英雄评分
-                return HeroDiscussProc::Score($req);
-            // </editor-fold>
-#----------- 英雄的解锁与购买 --------------
-            case CmdCode::cmd_hero_buyHero:                                     #  [6321]购买英雄
-                return HeroProc::BuyHeroByCostPieces($req);
-            case CmdCode::cmd_hero_upGodBlood:                                  #  [6322] 神血升级
-                return HeroProc::UpGodBloodHeroByPieces($req);
             case CmdCode::cmd_hero_StrengthenStar:                              #  [6326] 升星cmd_hero_YanlinUpLevel
-                return HeroProc::StrengthenStar($req);
+                return HeroProc::StrengthenStar();
             case CmdCode::cmd_hero_YanlinUpLevel:                               #  [6327] 升级
-                return HeroProc::YanlinUpLevel($req);
-//            case CmdCode::cmd_hero_unlockByPieces:                            #  [6323] 解锁碎片
-//                return HeroProc::UnLockHeroByPieces($req);                
-
+                return HeroProc::YanlinUpLevel();
+// </editor-fold>
             default:                                                            #  err: 未知的命令码
                 return Resp::err(ErrCode::cmd_err);
         }
@@ -72,13 +75,12 @@ class HeroProc {
     /**
      * [6324] 英雄技能解锁 
      * @version  2020.1.13  至今未进行对接, 再次整理版
-     *            2019.12.10 加班弄完第一版
-     * @param req $req
+     *            2019.12.10 加班弄完第一版 
      */
-    static function UnlockSkill($req) {
-        list($huid, $mainSkillId, $subSkillId) = $req->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能ID 
+    static function UnlockSkill() {
+        list($huid, $mainSkillId, $subSkillId) = req()->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能ID 
 
-        $user = $req->userInfo->game;                                           # user引用 
+        $user = req()->userInfo->game;                                           # user引用 
         $cHeros = $user->heros->collectHeros;
         my_default_Obj($cHeros);
         my_Assert(CommUtil::isPropertyExists($cHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要解锁的英雄
@@ -105,17 +107,16 @@ class HeroProc {
 
     /**
      * [6325] 英雄技能一键升级
-     * @param req $req
      */
-    static function OnekeyUpgradeSkillLevel($req) {
-        list($huid, $mainSkillId, $subSkillId, $targetSubSkillId, $costGold) = $req->paras; # 提取参数: 英雄的UID, 主技能ID, 要升级的子技能ID, 升级到的子技能ID, 升级要消耗的金币
+    static function OnekeyUpgradeSkillLevel() {
+        list($huid, $mainSkillId, $subSkillId, $targetSubSkillId, $costGold) = req()->paras; # 提取参数: 英雄的UID, 主技能ID, 要升级的子技能ID, 升级到的子技能ID, 升级要消耗的金币
 
-        $user = $req->userInfo->game;                                           # user引用#                                                                            
+        $user = req()->userInfo->game;                                           # user引用#                                                                            
         $collectHeros = $user->heros->collectHeros;
         my_default_Obj($collectHeros);                                          # 防御变量为空
         my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no);   # 1.检查是否存在要升级的英雄
 #                                                                               # 2.判断英雄的该技能能否升级....
-        $targetHero = new Ins_UserHero($cHeros->$huid);                        # 直接类型识别
+        $targetHero = new Ins_UserHero($collectHeros->$huid);                   # 直接类型识别
         $targteHeroSkills = $targetHero->subSkills;                            # 取出这个英雄的技能数据 
         my_default_Arr($targteHeroSkills->$mainSkillId);                       # 保护数据结构
         my_Assert(CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能id错误");     # 子技能id
@@ -136,12 +137,11 @@ class HeroProc {
     }
 
     /**
-     * [6314]英雄技能升级
-     * @param req $req
+     * [6314]英雄技能升级 
      */
-    static function UpgradeSkillLevel($req) {
-        list($huid, $mainSkillId, $subSkillId) = $req->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能Id 
-        $user = $req->userInfo->game;                                           # user引用
+    static function UpgradeSkillLevel() {
+        list($huid, $mainSkillId, $subSkillId) = req()->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能Id 
+        $user = req()->userInfo->game;                                           # user引用
 
         $collectHeros = $user->heros->collectHeros;
         my_default_Obj($collectHeros);                                          # 防御变量为空
@@ -169,12 +169,11 @@ class HeroProc {
     // <editor-fold defaultstate="collapsed" desc="英雄 强化">
 
     /**
-     * 6304 英雄 升阶(消耗碎片)
-     * @param Req $req
+     * 6304 英雄 升阶(消耗碎片) 
      */
-    static function HeroStageUp($req) {
-        list($huid, $nextGrade) = $req->paras;                                  # 提取参数: 英雄的UID,下一阶
-        $user = $req->userInfo->game;                                           # user引用
+    static function HeroStageUp() {
+        list($huid, $nextGrade) = req()->paras;                                  # 提取参数: 英雄的UID,下一阶
+        $user = req()->userInfo->game;                                           # user引用
         $collectHeros = $user->heros->collectHeros;                             # 角色容器
         my_default_Obj($collectHeros);                                          # 保证不为null
         my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no);  # 1.检查是否存在要升级的英雄 
@@ -190,21 +189,20 @@ class HeroProc {
         $collectHeros->$huid = $upHero;                                         # 更新Hero数据
         UserProc::updateUserInfo();                                             # 6.数据回存
         $resp = Resp::ok($upHero);
-        SystemProc::insertHero_StageUp($req->zoneid, $req->uid, $user->baseInfo->name, #  # 插入系统广播
+        SystemProc::insertHero_StageUp(req()->zoneid, req()->uid, $user->baseInfo->name, #  # 插入系统广播
                 GameConfig::hero_getItem($upHero->typeId)->name, $upHero->grade);
-        self::CalcUserFightPower($req->zoneid, $req->uid, $req->userInfo->game); # 跟新战力统计
+        self::CalcUserFightPower(req()->zoneid, req()->uid, req()->userInfo->game); # 跟新战力统计
         TaskProc::OnHeroGradeUp($upHero->typeId, $upHero->grade);
 //        var_dump($user->task->taskListDaily);
         return $resp;
     }
 
     /**
-     * [6301] 英雄升级 - 消耗经验道具,获得经验(按照经验提升等级)
-     * @param Req $req
+     * [6301] 英雄升级 - 消耗经验道具,获得经验(按照经验提升等级) 
      */
-    static function HeroLevelUpCostExpItem($req) {
-        list($huid, $costItemId, $costNumber) = $req->paras;                    # 提取参数: 玩家英雄实例编号, 消耗的道具ID, 消耗的道具数量 
-        $user = $req->userInfo->game;                                           # user引用 
+    static function HeroLevelUpCostExpItem() {
+        list($huid, $costItemId, $costNumber) = req()->paras;                    # 提取参数: 玩家英雄实例编号, 消耗的道具ID, 消耗的道具数量 
+        $user = req()->userInfo->game;                                           # user引用 
         $collectHeros = $user->heros->collectHeros;                             # 1. 检查是否存在要升级的英雄
         my_default_Obj($collectHeros);
         my_Assert(is_int($costNumber) && $costNumber >= 1, ErrCode::paras_err); # 参数合法性判断
@@ -231,13 +229,13 @@ class HeroProc {
         if ($myPacketItems->$costItemId < 0) {
             $myPacketItems->$costItemId = 0;
         }
-        $req->userInfo->game->store->items = $myPacketItems;                    # 更新背包数据
+        req()->userInfo->game->store->items = $myPacketItems;                    # 更新背包数据
         my_Assert($targetHero->xp >= 0, "英雄经验出错");
 
         UserProc::updateUserInfo();                                             # 回写玩家数据
-        TaskProc::OnHeroImprove();
+        TaskProc::OnHeroImprove();                                              # 事件检测
 
-        self::CalcUserFightPower($req->zoneid, $req->uid, $req->userInfo->game); # 跟新战力统计
+        self::CalcUserFightPower(req()->zoneid, req()->uid, req()->userInfo->game); # 跟新战力统计
         $ret = array(
             'hero' => $targetHero,
             'store' => $user->store
@@ -251,14 +249,13 @@ class HeroProc {
 
     /**
      * [6315]保存队伍的战斗配置信息
-     * @param Req $req
      */
-    static function SaveHeroTeamConfig($req) {
-        $teamsetting = $req->paras[0];                                          # 配置信息json文件
-        $req->userInfo->game->heroTeamConfig = $teamsetting;                    # 更新配置
+    static function SaveHeroTeamConfig() {
+        $teamsetting = req()->paras[0];                                          # 配置信息json文件
+        req()->userInfo->game->heroTeamConfig = $teamsetting;                    # 更新配置
         UserProc::updateUserInfo();                                             # 回写数据
 #       # 添加到战斗力隐藏榜单中, for pvp back matchers, -wg 2017.07.13
-        self::CalcTeamFightPower($req->zoneid, $req->uid, $req->userInfo->game);
+        self::CalcTeamFightPower(req()->zoneid, req()->uid, req()->userInfo->game);
         return Resp::ok(array('result' => "succeed"));
     }
 
@@ -267,458 +264,82 @@ class HeroProc {
 // <editor-fold defaultstate="collapsed" desc="已过时代码">
 
     /**
-     * 6323 解锁英雄
-     * @param type $req
+     * 6323 解锁英雄 
      */
-    static function UnLockHeroByPieces($req) {
-        $user = $req->userInfo->game;                                           # user引用
-        $heroModelId = $req->paras[0];
-        $piecesId = $req->paras[1];                                             # 英雄碎片的ID
-        $piecesNum = $req->paras[2];
-        if (!CommUtil::isPropertyExists($user->heros, "recordUnLockHeroDic")) {
-            $user->heros->recordUnLockHeroDic = ObjectInit();
-        }
-
-        $recordUnLockHeroDic = $user->heros->recordUnLockHeroDic;
-
-        #检查是不是已经解锁过了
-        $flag = 0;
-        if (!CommUtil::isPropertyExists($recordUnLockHeroDic, $heroModelId)) {
+    static function UnLockHeroByPieces() {
+        Err(ErrCode::err_method_obsoleted, "策划未设定解锁功能-2021.5.6");
+        $user = req()->userInfo->game;                                           # user引用
+        $heroModelId = req()->paras[0];
+        $piecesId = req()->paras[1];                                            # 英雄碎片的ID
+        $piecesNum = req()->paras[2];
+        my_default_Obj($user->heros->recordUnLockHeroDic);                      # 防御解锁列表未初始化,空对象
+        $recordUnLockHeroDic = $user->heros->recordUnLockHeroDic;               # 已解锁记录
+        if (!CommUtil::isPropertyExists($recordUnLockHeroDic, $heroModelId)) {  # 检查是不是已经解锁过了 
             $recordUnLockHeroDic->$heroModelId = 0;
         }
-        $flag = $recordUnLockHeroDic->$heroModelId;
-        if ($flag == 1) {
-            return Resp::err(ErrCode::hero_lockState);
-        }
-        #检查要解锁的英雄的常量配置是否存在
+        my_Assert(0 == $recordUnLockHeroDic->$heroModelId, ErrCode::hero_lockState); # 防御英雄已经解锁
+
         $heroCfg = GameConfig::hero_getItem($heroModelId);
-        if (!$heroCfg) {
-            return Resp::err(ErrCode::hero_const_no_err);
-        }
-        #检查需要消耗的碎片的常量配置是否存在
+        my_Assert(isset($heroCfg), ErrCode::hero_const_no_err);                 # 检查要解锁的英雄的常量配置是否存在
         $piecesCfg = GameConfig::segment_getItem($piecesId);
-        if (!$piecesCfg) {
-            return Resp::err(ErrCode::err_const_no);
-        }
-        # 5.检查道具的数量是否充足
+        my_Assert(isset($piecesCfg), ErrCode::err_const_no);                    # 检查需要消耗的碎片的常量配置是否存在
         $myPacketItems = $user->store->segement;
         $requirePiecesNum = $heroCfg->unlockConditionId;
-        # 检查道具数量是否充足
-        $enoughPieces = false;
-        if ($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum) {
-            if (!CommUtil::isPropertyExists($myPacketItems, $piecesId)) {       # 检查碎片
+        $enoughPieces = false;                                                  # 检查道具数量是否充足
+        my_Assert($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum, ErrCode ::paras_err);
+        if (!CommUtil::isPropertyExists($myPacketItems, $piecesId)) {           # 检查碎片
+            $enoughPieces = false;
+        } else {
+            if ($myPacketItems->$piecesId < $requirePiecesNum) {                # 5.检查道具的数量是否充足
                 $enoughPieces = false;
             } else {
-                if ($myPacketItems->$piecesId < $requirePiecesNum) {
-                    $enoughPieces = false;
-                } else {
-                    $enoughPieces = true;
-                }
+                $enoughPieces = true;
             }
-        } else {
-            return Resp::err(ErrCode ::paras_err, "error pieces para" . "req" . $piecesId . "_" . $requirePiecesNum . "/" . $piecesId . "_" . $piecesNum);
         }
-        if ($enoughPieces === true) {
-            # 6.进行 # # 消耗道具           
-            $myPacketItems->$piecesId -= $requirePiecesNum;
-            if ($myPacketItems->$piecesId < 0) {
-                $myPacketItems->$piecesId = 0;
-            }
-            $recordUnLockHeroDic->$heroModelId = 1;
-            $req->user->heros->recordUnLockHeroDic = $recordUnLockHeroDic;
-            $req->userInfo->game->store->segement = $myPacketItems;
-            UserProc::updateUserInfo();                                     # 回写数据
-            return Resp::ok(array('result' => "OK"));                           //返回OK
-        } else {
-            return Resp::err(ErrCode::hero_godblood_notengoughitem);
+        my_Assert($enoughPieces, ErrCode::hero_godblood_notengoughitem);
+        $myPacketItems->$piecesId -= $requirePiecesNum;
+        if ($myPacketItems->$piecesId < 0) {                                    # 6.进行 # # 消耗道具        
+            $myPacketItems->$piecesId = 0;
         }
+        $recordUnLockHeroDic->$heroModelId = 1;
+        req()->userInfo->game->heros->recordUnLockHeroDic = $recordUnLockHeroDic;
+        req()->userInfo->game->store->segement = $myPacketItems;
+        UserProc::updateUserInfo();                                             # 回写数据
+        return Resp::ok(array('result' => "OK"));                               # 返回OK
     }
 
     /**
      * [6322] 英雄神血
-     * @param Req $req
      */
-    static function UpGodBloodHeroByPieces($req) {
-        return Resp::err(ErrCode::err_method_obsoleted);
+    static function UpGodBloodHeroByPieces() {
+        Err(ErrCode::err_method_obsoleted, "策划未设定神血功能-2021.5.6");
     }
 
     /**
      * 英雄消耗碎片道具来升星
      * @param req $req
      */
-    static function HeroUpStarByPieces($req) {
-        $resp = Resp::err(ErrCode::err_method_notimplement);
-        $g = glc();
-        $user = $req->userInfo->game; # user引用
-        $huid = $req->paras[0]; # 英雄的UID
-        $piecesId = $req->paras[1]; # 英雄碎片的ID
-        $piecesNum = $req->paras[2];
-        $diamondId = $req->paras[3]; # 升星石道具的ID
-        $diamondNum = $req->paras[4];
-        $moneyType = $req->paras[5]; # 升星消耗金钱的类型
-        $moneyNum = $req->paras[6];
-
-# 1.检查是否存在要升级的英雄
-        $collectHeros = $user->heros->collectHeros;
-        if (!$collectHeros) {
-            $collectHeros = ObjectInit();
-        }
-        if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
-            return Resp::err(ErrCode::hero_no);
-        }
-# 2.检查是否已经达到最大星级
-        isEditor() and $strengthHero = new Ins_UserHero();
-        $strengthHero = $collectHeros->$huid;
-        if ($strengthHero->curStar >= $g->Hero_Star_MaxStarLevel) {
-            return Resp::err(ErrCode::hero_star_maxstarlevel);
-        }
-# 检查是否存在当前星级的升星消耗常量数据
-        $lvs = GameConfig::heroextra_star_getItem($strengthHero->curStar);
-        if (!$lvs) {
-            return Resp::err(ErrCode::hero_star_level_const_no_err);
-        }
-# 3检查是否存在这个英雄的模板
-        $heroModelId = $strengthHero->typeId;
-
-        $heroCfg = GameConfig::hero_getItem($heroModelId);
-        if (!$heroCfg) {
-            return Resp::err(ErrCode::hero_const_no_err);
-        }
-
-# 4.检查道具的数量是否充足以及消耗数量是否一致
-        $requireDiamondId = $lvs->itemid;
-        $requireDiamondNum = 0;
-        $arr_costDiamond = explode(";", $lvs->itemNum);
-        foreach ($arr_costDiamond as $value) {
-            $strArr = explode(",", $value);
-            if (count($strArr) == 2) {
-                $zhenxidu = $strArr[0];
-                $num = $strArr[1];
-                if ((int) $zhenxidu == $heroCfg->zhenxidu) {
-                    $requireDiamondNum = (int) $num;
-                    break;
-                }
-            }
-        }
-#检查碎片是否正确
-        $requirePieceId = $piecesId;
-        $requirePiecesNum = 0;
-        $arr_costPieces = explode(";", $lvs->pieces);
-        foreach ($arr_costPieces as $value) {
-            $strArr = explode(",", $value);
-            if (count($strArr) == 2) {
-                $zhenxidu = $strArr[0];
-                $num = $strArr[1];
-                if ((int) $zhenxidu == $heroCfg->zhenxidu) {
-                    $requirePiecesNum = (int) $num;
-                    break;
-                }
-            }
-        }
-
-        $piecesCfg = GameConfig::item_getItem($piecesId);
-        if (!$piecesCfg) {
-            return Resp::err(ErrCode::err_const_no);
-        }
-        $pos = strpos($piecesCfg->icon, strval($heroModelId));
-        if ($pos === false) {
-            return Resp::err(ErrCode::paras_err, $piecesCfg->icon . "?" . $heroModelId);
-        }
-
-# 4.检查道具的数量是否充足
-        $myPacketItems = $user->store->items;
-#检查道具数量是否充足
-        $enoughDiamond = false;
-        $enoughPieces = false;
-        if ($requirePieceId == $piecesId && $requirePiecesNum == $piecesNum) {
-            #检查碎片
-            if (!CommUtil::isPropertyExists($myPacketItems, $requirePieceId)) {
-                $enoughPieces = false;
-            } else {
-                if ($myPacketItems->$requirePieceId < $requirePiecesNum) {
-                    $enoughPieces = false;
-                } else {
-                    $enoughPieces = true;
-                }
-            }
-        } else {
-            return Resp::err(ErrCode ::paras_err, #
-                            "error pieces para" . "req" . $requirePieceId . "_" . $requirePiecesNum . "/" . $piecesId . "_" . $piecesNum);
-        }
-
-        if ($requireDiamondId == $diamondId && $requireDiamondNum == $diamondNum) {
-            #检查升星石
-            if (!CommUtil::isPropertyExists($myPacketItems, $requireDiamondId)) {
-                $enoughDiamond = false;
-            } else {
-                if ($myPacketItems->$requireDiamondId < $requireDiamondNum) {
-                    $enoughDiamond = false;
-                } else {
-                    $enoughDiamond = true;
-                }
-            }
-        } else {
-            return Resp::err(ErrCode ::paras_err, #
-                            "error diamond para" . "req" . $requireDiamondId . "_" . $requireDiamondNum . "/" . $diamondId . "_" . $diamondNum);
-        }
-        if ($enoughDiamond === true && $enoughPieces === true) {
-            
-        } else {
-            return Resp::err(ErrCode::hero_star_notengoughitem);
-        }
-# 5.检查账户余额是否充足
-#检查消耗是否正确
-        $enoughMoney = false;
-
-        $requireMoneyType = "";
-        $requireMoneyNum = 0;
-        $arr_costMoney = explode(";", $lvs->cost);
-        foreach ($arr_costMoney as $value) {
-            $strArr = explode(",", $value);
-            if (count($strArr) == 3) {
-                $zhenxidu = $strArr[0];
-                $type = $strArr[1];
-                $num = $strArr[2];
-                if ((int) $zhenxidu == $heroCfg->zhenxidu) {
-                    $requireMoneyType = $type;
-                    $requireMoneyNum = (int) $num;
-                    break;
-                }
-            }
-        }
-
-        if ($requireMoneyType == $moneyType && $requireMoneyNum == $moneyNum) {
-            if ($requireMoneyType === "gold") {
-                if ($user->baseInfo->gold >= $requireMoneyNum) {
-                    $enoughMoney = true;
-                } else {
-                    return Resp::err(ErrCode::notenough_gold_msg);
-                }
-            } else if ($requireMoneyType === "cash") {
-                if ($user->baseInfo->cash >= $requireMoneyNum) {
-                    $enoughMoney = true;
-                } else {
-                    return Resp::err(ErrCode::notenough_cash_msg);
-                }
-            } else {
-                return Resp::err(ErrCode ::paras_err, $moneyType);
-            }
-        } else {
-            return Resp::err(ErrCode ::paras_err, "error money para");
-        }
-
-        $bDeal = false;
-        if ($enoughMoney === true) {
-            if ($requireMoneyType === "gold") {
-                $bDeal = Data_UserGame:: Consume_Gold($user->baseInfo, $requireMoneyNum);
-            } else if ($requireMoneyType === "cash") {
-                $bDeal = Data_UserGame:: Consume_Cash($user->baseInfo, $requireMoneyNum);
-            }
-        }
-
-# 6.进行消耗升星
-        if ($bDeal) {
-            $strengthHero->curStar += 1;
-
-# # 消耗道具
-
-            $myPacketItems->$requireDiamondId -= $requireDiamondNum;
-            if ($myPacketItems->$requireDiamondId < 0) {
-                $myPacketItems->$requireDiamondId = 0;
-            }
-            $myPacketItems->$requirePieceId -= $requirePiecesNum;
-            if ($myPacketItems->$requirePieceId < 0) {
-                $myPacketItems->$requirePieceId = 0;
-            }
-
-            $req->userInfo->game->store->items = $myPacketItems;
-# 回写数据
-            UserProc::updateUserInfo();
-            $resp = Resp::ok($strengthHero);
-#  推送系统消息
-//            SystemProc::insertHero_Star($req->zoneid, $req->uid, $user->name, $heroCfg->name, $strengthHero->curStar);
-        }
-        ActiveProc::ChangeTaskCount($req);
-
-        return $resp;
+    static function HeroUpStarByPieces() {
+        Err(ErrCode::err_method_obsoleted, "策划未设定碎片升级功能-2021.5.6");
     }
 
     /**
      * 英雄升星
      * @param Req $req
      */
-    static function HeroUpStar($req) {
-        $resp = Resp::err(ErrCode::err_method_notimplement);
-        $g = glc();
-        $user = $req->userInfo->game; # user引用
-        $huid = $req->paras[0]; # 英雄的UID
-        $costHeroUids = $req->paras[1]; # 消耗掉的英雄UID
-        $costGold = $req->paras[2];
-# 1.检查是否存在要升级的英雄
-        $collectHeros = $user->heros->collectHeros;
-        if (!$collectHeros) {
-            $collectHeros = ObjectInit();
-        }
-        if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
-            return Resp::err(ErrCode::hero_no);
-        }
-# 2.检查是否已经达到最大星级
-        isEditor() and $strengthHero = new Ins_UserHero();
-        $strengthHero = $collectHeros->$huid;
-        if ($strengthHero->curStar >= $g->Hero_Star_MaxStarLevel) {
-            return Resp::err(ErrCode::hero_star_maxstarlevel);
-        }
-# 检查是否存在当前星级的升星消耗常量数据
-        $lvs = GameConfig::heroextra_star_getItem($strengthHero->curStar);
-        if (!$lvs) {
-            return Resp::err(ErrCode::hero_star_level_const_no_err);
-        }
-
-# 3.检查消耗的英雄数量,以及玩家是否都存在这些英雄UID.
-        $arr_costUID = explode(",", $costHeroUids);
-        $checkCostHeroAllRight = true;
-        if (count($arr_costUID) != $g->Hero_Star_MaxCostHeroCardNum) {
-            $checkCostHeroAllRight = false;
-        } else {
-            foreach ($arr_costUID as $value) {
-                if ($value == "" || !CommUtil::isPropertyExists($collectHeros, $value)) {
-                    $checkCostHeroAllRight = false;
-                    break;
-                }
-            }
-        }
-        if (!$checkCostHeroAllRight) {
-            return Resp::err(ErrCode::hero_star_costhero);
-        }
-# 获得升星英雄的模板数据,取得它的元素类型
-# 检查是否存在这个英雄的模板
-        $heroModelId = $strengthHero->typeId;
-
-        $heroCfg = GameConfig::hero_getItem($heroModelId);
-        if (!$heroCfg) {
-            return Resp::err(ErrCode::hero_const_no_err);
-        }
-
-        $queryCostGold = $lvs->costGold;
-        $costItemNum = $lvs->costItemNum;
-
-# 4.检查道具的数量是否充足
-        $myPacketItems = $user->store->items;
-        $checkHasEnoughItem = true;
-        $costItemId = "";
-        $record = ObjectInit();
-        $keyxxx = "Hero_Star_CostItem_" . $heroCfg->yuansu;
-
-        if (!CommUtil::isPropertyExists($g, $keyxxx)) {
-            return Resp::err(ErrCode::hero_star_noglobal_costitem);
-        } else {
-            $costItemId = $g->$keyxxx;
-        }
-# 检查道具种类与消耗数量是否匹配
-        $arr_costitemids = explode(",", $costItemId);
-        $arr_costnums = explode(",", $costItemNum);
-        if (count($arr_costitemids) != count($arr_costnums)) {
-            return Resp::err(ErrCode::hero_star_conststr_itemnotmathnum);
-        }
-
-        $index = 0;
-
-        foreach ($arr_costitemids as $requireiItemId) {
-
-            $requireCount = 0;
-
-            if ($index < count($arr_costnums)) {
-                $requireCount = $arr_costnums[$index];
-            }
-
-            $index += 1;
-# --判断对应的item是否存在相应的常量
-# 检查是否存在当前星级的升星消耗常量数据
-            $itemcfg = GameConfig::item_getItem($requireiItemId);
-            if (!$itemcfg) {
-                return Resp::err(ErrCode::err_const_no);
-            } else {
-                if (!CommUtil::isPropertyExists($record, $requireiItemId)) {
-                    $record->$requireiItemId = intval($requireCount);
-                } else {
-                    $count = intval($record->$requireiItemId) + intval($requireCount);
-                    $record->$requireiItemId = $count;
-                }
-            }
-        } foreach ($record as $key => $value) {
-            if ($value > 0) {
-                if (!CommUtil::isPropertyExists($myPacketItems, $key)) {
-                    $checkHasEnoughItem = false;
-                    break;
-                } else {
-                    if ($myPacketItems->$key < $value) {
-                        $checkHasEnoughItem = false;
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (!$checkHasEnoughItem) {
-            return Resp::err(ErrCode::hero_star_notengoughitem);
-        }
-# 5.检查金币是否充足
-        $bDeal = false;  # 成交
-        if ($queryCostGold != $costGold) {
-            return Resp::err(ErrCode::paras_err);
-        } else {
-            if ($costGold > 0) {
-                if ($user->baseInfo->gold < $costGold) {
-                    return Resp::err(ErrCode::notenough_gold_msg);
-                } else {
-                    $bDeal = Data_UserGame:: Consume_Gold($user->baseInfo, $costGold);
-                }
-            } else if ($costGold == 0) {
-                $bDeal = true;
-            } else {
-                return Resp::err(ErrCode::paras_err);
-            }
-        }
-
-# 6.进行消耗升星
-        if ($bDeal) {
-            $strengthHero->curStar += 1;
-# 消耗卡牌
-            foreach ($arr_costUID as $value) {
-                if ($value == "") {
-                    continue;
-                }
-                unset($collectHeros->$value);
-            }
-# # 消耗道具
-            foreach ($record as $key => $value) {
-                $myPacketItems->$key -= $value;
-                if ($myPacketItems->$key < 0) {
-                    $myPacketItems->$key = 0;
-                }
-            }
-
-            $req->userInfo->game->store->items = $myPacketItems;
-# 回写数据
-            UserProc::updateUserInfo();
-            $resp = Resp::ok($strengthHero);
-#  推送系统消息
-//            SystemProc::insertHero_Star($req->zoneid, $req->uid, $user->name, $heroCfg->name, $strengthHero->curStar);
-        }
-        ActiveProc::ChangeTaskCount($req);
-
-        return $resp;
+    static function HeroUpStar() {
+        Err(ErrCode::err_method_obsoleted, "策划未设定升星功能-2021.5.6");
     }
 
 // </editor-fold>
 
     /**
-     * 6321 购买英雄 消耗碎片
-     * @param req $req
+     * 6321 购买英雄 消耗碎片 
      */
-    static function BuyHeroByCostPieces($req) {
-        list($heroModelId, $costType, $costMoneyNum, $piecesId, $piecesNum) = $req->paras; # 提取参数
-        $user = $req->userInfo->game;                                           # user引用
+    static function BuyHeroByCostPieces() {
+        Err(ErrCode::err_method_obsoleted, "策划未设定碎片功能-2021.5.6");
+        list($heroModelId, $costType, $costMoneyNum, $piecesId, $piecesNum) = req()->paras; # 提取参数
+        $user = req()->userInfo->game;                                           # user引用
         $collectHeros = $user->heros->collectHeros;
         my_default_Obj($collectHeros);
         foreach ($collectHeros as $key => $value) {                             # 检查玩家是否已经拥有此类英雄
@@ -754,22 +375,21 @@ class HeroProc {
 
         # 4.消耗来获得英雄 
         $myPacketItems->$piecesId -= $requirePiecesNum;                         # 消耗道具 
-        $req->userInfo->game->store->items = $myPacketItems;                    # 回存背包
+        req()->userInfo->game->store->items = $myPacketItems;                    # 回存背包
         UserProc::updateUserInfo();                                             # 回写数据
-        $resp = HeroProc::GetHero($req);
-        SystemProc::GetHero($req->zoneid, $user->baseInfo, $heroModelId);       # 插入系统广播消息
+        $resp = HeroProc::GetHero();
+        SystemProc::GetHero(req()->zoneid, $user->baseInfo, $heroModelId);       # 插入系统广播消息
         return $resp;
     }
 
     /**
-     * 购买玩家可以收集的英雄的数量上限
-     * @param req $req
+     * 购买玩家可以收集的英雄的数量上限 
      * @return type
      */
-    static function BuyHeroMaxCountLimt($req) {
-        list($buyNum, $costCash) = $req->paras;                                 # 提取参数: 数量, 花费钻石
+    static function BuyHeroMaxCountLimt() {
+        list($buyNum, $costCash) = req()->paras;                                 # 提取参数: 数量, 花费钻石
         $g = glc();
-        $user = $req->userInfo->game;                                           # user引用
+        $user = req()->userInfo->game;                                           # user引用
         if (!CommUtil::isPropertyExists($user->heros, "maxCollectCount")) {
             $user->heros->maxCollectCount = $g->Game_CollectHero_BasicMaxCount;
         }
@@ -789,14 +409,13 @@ class HeroProc {
     }
 
     /**
-     * 获得英雄(测试已经OK)
-     * @param req $req
+     * 获得英雄(测试已经OK) 
      */
-    static function GetHero($req) {
-        $heroModelId = $req->paras[0];                                          # 英雄的模板ID 
+    static function GetHero() {
+        $heroModelId = req()->paras[0];                                          # 英雄的模板ID 
         $heroCfg = GameConfig::hero_getItem($heroModelId);                      # 1.检查是否存在这个英雄的模板
         my_Assert(null != $heroCfg, ErrCode::hero_const_no_err);
-        $hero = self::AddHeroTFromStore($req, $heroModelId);                    # 创建英雄
+        $hero = self::AddHeroTFromStore(req(), $heroModelId);                    # 创建英雄
         UserProc::updateUserInfo();
         $result = array('result' => "succeed", 'heros' => $hero);               #  4. 设置返回值
         return Resp::ok($result);
@@ -874,9 +493,8 @@ class HeroProc {
             }
         }
         if (null != $wp) {
-            $req = req();
-            $wuid = StoreProc::PutEquipInStore($wp->typeId, $req);
-            $req->userInfo->game->store->equipment->$wuid->herouid = $uid;
+            $wuid = StoreProc::PutEquipInStore($wp->typeId);
+            req()->userInfo->game->store->equipment->$wuid->herouid = $uid;
             $hero->equip->weapon = array("itemuid" => $wuid);
         }
 
@@ -947,13 +565,12 @@ class HeroProc {
 
     /**
      * [6306] 英雄-更改英雄的锁定状态
-     * (测试已经OK)
-     * @param type $req
+     * (测试已经OK) 
      */
-    static function HeroChangelockstate($req) {
-        $gamedata = $req->userInfo->game;
-        $heroUID = $req->paras[0];                                              # 玩家英雄实例编号
-        $lockstate = $req->paras[1];                                            # 玩家英雄锁定状态
+    static function HeroChangelockstate() {
+        $gamedata = req()->userInfo->game;
+        $heroUID = req()->paras[0];                                              # 玩家英雄实例编号
+        $lockstate = req()->paras[1];                                            # 玩家英雄锁定状态
         $collectHeros = $gamedata->heros->collectHeros;
         my_default_Obj($collectHeros);                                          # 默认值
         my_Assert(CommUtil::isPropertyExists($collectHeros, $heroUID), ErrCode::hero_no);
@@ -964,22 +581,20 @@ class HeroProc {
         return Resp::ok(ObjectInit());                                          # 4. 设置返回值
     }
 
-    /*     * 6326
-     * 言灵升星
-     * @param req $req
-     * @return type
+    /** 6326
+     * 言灵升星 2021.4(cyzhao)
+     * @return resp
      */
-
-    static function StrengthenStar($req) {
-        list($yanlingUid, $uidList) = $req->paras;
-        $store = $req->userInfo->game->store;
+    static function StrengthenStar() {
+        list($yanlingUid, $uidList) = req()->paras;
+        $store = req()->userInfo->game->store;
         my_Assert(StlUtil::dictHasProperty($store->yanling, $yanlingUid), ErrCode::hero_yanling_notfound);
         my_Assert(!in_array($yanlingUid, $uidList), ErrCode::hero_yanling_repeat);
         my_Assert($store->yanling->$yanlingUid->starLv < 5, ErrCode::hero_yanling_repeat);
 
         $tag = true;
         foreach ($uidList as $costUid) {
-            if (StlUtil::dictHasProperty($store->yanling, $costUid)) {          // 校验是否是同类型
+            if (StlUtil::dictHasProperty($store->yanling, $costUid)) {          # 校验是否是同类型
                 $confDic = GameConfig::item_yanling_getItem($store->yanling->$costUid->typeId);
                 my_Assert(null != $confDic, ErrCode::hero_const_no_err);
                 if ($confDic->type != GameConfig::item_yanling_getItem($store->yanling->$yanlingUid->typeId)->type) {
@@ -1010,23 +625,22 @@ class HeroProc {
             $store->yanling->$yanlingUid->typeId = $dic->nextId;
         }
 
-        $req->userInfo->game->store = $store;
+        req()->userInfo->game->store = $store;
         UserProc::updateUserInfo();
-        return Resp::ok(array('store' => $req->userInfo->game->store,));
+        return Resp::ok(array('store' => req()->userInfo->game->store,));
     }
 
     /** 6327
-     * 言灵升级
-     * @param req $req
+     * 言灵升级  2021.4(cyzhao)
      */
-    static function YanlinUpLevel($req) {
-        list($yanlingUid, $type) = $req->paras;                                 # 参数: 言灵uid,升级类型:1/5级.
-        $store = $req->userInfo->game->store;
+    static function YanlinUpLevel() {
+        list($yanlingUid, $type) = req()->paras;                                 # 参数: 言灵uid,升级类型:1/5级.
+        $store = req()->userInfo->game->store;
         my_Assert(StlUtil::dictHasProperty($store->yanling, $yanlingUid), ErrCode::hero_yanling_notfound);
         $allDic = GameConfig::yanlingLeve();
         $maxLevel = count((array) $allDic);
         $curlv = $store->yanling->$yanlingUid->level;
-        my_Assert($curlv <= $req->userInfo->game->baseInfo->level, "请提升指挥官等级."); # 言灵等级不能超过指挥官等级.-gwang 2021.4.20
+        my_Assert($curlv <= req()->userInfo->game->baseInfo->level, "请提升指挥官等级."); # 言灵等级不能超过指挥官等级.-gwang 2021.4.20
         my_Assert($curlv < $maxLevel, ErrCode::hero_yanling_levelMax);
 
         $maxLv = $curlv + $type;
@@ -1041,19 +655,19 @@ class HeroProc {
             $goldNum += $mo->goldCost;
             $pointNum += $mo->pointCost;
         }
-        my_Assert(Data_UserGame::Consume_Gold($req->userInfo->game->baseInfo, $goldNum), ErrCode::notenough_gold_msg);
-        my_Assert(Data_UserGame::Consume_ResPoint($req->userInfo->game->baseInfo, $pointNum), ErrCode::notenough_resPoint);
+        my_Assert(Data_UserGame::Consume_Gold(req()->userInfo->game->baseInfo, $goldNum), ErrCode::notenough_gold_msg);
+        my_Assert(Data_UserGame::Consume_ResPoint(req()->userInfo->game->baseInfo, $pointNum), ErrCode::notenough_resPoint);
 
         $store->yanling->$yanlingUid->level += $type;                           # 增加等级
         if ($store->yanling->$yanlingUid->level > $maxLevel) {
             $store->yanling->$yanlingUid->level = $maxLevel;
         }
         TaskProc::OnYanlingLevelUp($store->yanling->$yanlingUid->typeId, $store->yanling->$yanlingUid->level); # 言灵升级
-        $req->userInfo->game->store = $store;
+        req()->userInfo->game->store = $store;
         UserProc::updateUserInfo();                                             # 回写玩家数据
-        return Resp::ok(array('store' => $req->userInfo->game->store, #
-                    'gold' => $req->userInfo->game->baseInfo->gold, #
-                    'resPoint' => $req->userInfo->game->baseInfo->resPoint));
+        return Resp::ok(array('store' => req()->userInfo->game->store, #
+                    'gold' => req()->userInfo->game->baseInfo->gold, #
+                    'resPoint' => req()->userInfo->game->baseInfo->resPoint));
     }
 
 //
@@ -1085,8 +699,7 @@ class HeroProc {
                     }
                 }
             }
-            //todo: 这里的战斗力榜被总战力榜征用了key, 重启PVP机制时再
-//            gMem()->zadd(MemKey_GameRun::Game_FightPowerRank_zset($zoneid), array($uid => $fp)); 
+            //todo: 这里的战斗力榜被总战力榜征用了key, 重启PVP机制时再 
         }
         return $fp;
     }
@@ -1132,8 +745,8 @@ class HeroProc {
             $v = $kv[1];
             $factor[$k] = $v;
         }
-// todo: 哈哈, 奇葩的命名方案, 多处使用的命名不一致, 坑!
-        $a = (int) (self::calcHeroProperty($hero, 'hp') * $factor ["hp"]   //
+
+        $a = (int) (self::calcHeroProperty($hero, 'hp') * $factor ["hp"]   //// todo: 哈哈, 奇葩的命名方案, 多处使用的命名不一致, 坑!
                 + $hero->level * 10);
         return $a;
     }

Gameserver/Amfphp/process/PayProc.php

@@ -25,27 +25,26 @@ class PayProc {
 
     /**
      * 逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    public static function procMain($req) {
-        switch ($req->cmd) {
+    public static function procMain() {
+        switch (req()->cmd) {
             // 支付相关的活动
             case CmdCode::cmd_pay_getfirstpaygift:                              # 8802 领取首充礼包
-                return PayProc::m_GetFirstPayGift($req);
+                return PayProc::m_GetFirstPayGift();
             // <editor-fold defaultstate="collapsed" desc="  手机多渠道版 mpay  ">
             case CmdCode::cmd_mpay_pay:                                         # 8807 消费..
-                return self::m_pay($req);                                       # ::==> 购买普通商城物品
+                return self::m_pay();                                           # ::==> 购买普通商城物品
             case CmdCode::cmd_mpay_get_balance:                                 # 8808 刷新账号余额
-                return self::m_refreshChargeOrders($req);                       # ::==> 刷新订单-领取充值金额
+                return self::m_refreshChargeOrders();                           # ::==> 刷新订单-领取充值金额
             case CmdCode::cmd_mpay_buyDynamic:                                  # 8809 购买动态商城物品
-                return self::m_pay_buyDynamic($req);
+                return self::m_pay_buyDynamic();
             case CmdCode::cmd_mpay_getDynamic:                                  # 8810 刷新神秘商城物品
-                return self::m_pay_getDynamic($req);
+                return self::m_pay_getDynamic();
             case CmdCode::cmd_mpay_selfCheckOrders:                             # 8811 自助检查异常订单
-                return self::selfhelpCheckOrders($req);
+                return self::selfhelpCheckOrders();
             case CmdCode::cmd_mpay_getPayRecords:                               # 8812 查询订单记录
-                return self::GetPayRecoreds($req);
+                return self::GetPayRecoreds();
 // </editor-fold>
 
             default:
@@ -54,11 +53,10 @@ class PayProc {
     }
 
     /**
-     * 8812 查询充值记录
-     * @param Req $req
+     * 8812 查询充值记录 
      */
-    static function GetPayRecoreds($req) {
-        $uid = $req->uid;
+    static function GetPayRecoreds() {
+        $uid = req()->uid;
         $table = "tpl_order_tab";
         $arr = daoInst()->select(" cpOrderId as '订单' ,product_name as '道具',amount as '金额' ,from_unixtime(order_ts) as '时间' ")->from($table)
                 ->where("uid")->eq($uid)
@@ -71,17 +69,16 @@ class PayProc {
 // <editor-fold defaultstate="collapsed" desc="  移动支付 - 刷新订单  ">
 
     /**
-     *  刷新充值订单(领取充值结果)
-     * @param Req $req
+     *  刷新充值订单(领取充值结果) 
      */
-    public static function m_refreshChargeOrders($req) {
+    public static function m_refreshChargeOrders() {
 # 客户端参数解析
-        $uid = $req->uid;                                                       # userID
-        $zoneid = $req->zoneid;                                                 # 分区Id
-        if (count($req->paras) <= 0) {                                           # 参数为空, 执行自检逻辑
-            return self::selfhelpCheckOrders($req);
+        $uid = req()->uid;                                                      # userID
+        $zoneid = req()->zoneid;                                                # 分区Id
+        if (count(req()->paras) <= 0) {                                         # 参数为空, 执行自检逻辑
+            return self::selfhelpCheckOrders();
         }
-        $cpOrderId = $req->paras[0];                                            # 后台订单编号
+        $cpOrderId = req()->paras[0];                                           # 后台订单编号
         if (!$uid || ($zoneid < 1) || strlen($cpOrderId) != 16) {               # 订单编号长16位
             return Resp::err(ErrCode::paras_err);
         }
@@ -119,15 +116,14 @@ class PayProc {
             default :
                 return Resp::err(ErrCode::pay_systembusy_err);
         }
-        if (!$item) {
-            return Resp::err(ErrCode::pay_shopItem_cosnt_goods_err);
-        }
+        my_Assert(isset($item), ErrCode::pay_shopItem_cosnt_goods_err);
+
         if ($item->pricetype != 0) {
             CLog::pay(" 道具付费类型异常:" . $product_id);
             return Resp::err(ErrCode::pay_m_type_err);
         }
         for ($i = 0; $i < $product_count; $i++) {                                       # 默认为1,还没有设计为n的情况
-            StoreProc::AddMultiItemInStore($req, $item->goods, 5);                      # 发货
+            StoreProc::AddMultiItemInStore($item->goods, 5);                      # 发货
         }
         $n = daoInst()->update(self::orderTab)
                 ->data(array('drawed_ts' => now()))
@@ -135,14 +131,14 @@ class PayProc {
                 ->exec();
         my_Assert($n > 0, ErrCode::err_db);                                             # 数据库操作失败
 
-        $req->userInfo->game->baseInfo->charge_amt += $order->amount;                   # 历史充值记录(单位分)
+        req()->userInfo->game->baseInfo->charge_amt += $order->amount;                   # 历史充值记录(单位分)
         UserProc::updateUserInfo();                                                     # 更新玩家数据信息
         Event::trigger('pay', array('amt' => $order->amount));                          # 触发充值事件
         CLog::pay("订单发货成功: $cpOrderId");
         return Resp::ok(# 返回
-                        array('cash' => $req->userInfo->game->baseInfo->cash, #         # 直接将游戏币的最新值返回给客户端
-                            'charge_amt' => $req->userInfo->game->baseInfo->charge_amt, # 充值总记录
-                            'store' => $req->userInfo->game->store, #                   # 背包
+                        array('cash' => req()->userInfo->game->baseInfo->cash, #         # 直接将游戏币的最新值返回给客户端
+                            'charge_amt' => req()->userInfo->game->baseInfo->charge_amt, # 充值总记录
+                            'store' => req()->userInfo->game->store, #                   # 背包
                             'goods' => $item->goods, #                                  # 发货内容
                             'count' => $product_count, #                                # 发货数量
                         )
@@ -150,12 +146,11 @@ class PayProc {
     }
 
     /**
-     *  检查内侧订单
-     * @param Req $req
+     *  检查内侧订单 
      */
-    static function checkDeltest($req) {
-        $uid = $req->uid;
-        if (!isset($req->userInfo->game->privateState->deltest)) {
+    static function checkDeltest() {
+        $uid = req()->uid;
+        if (!isset(req()->userInfo->game->privateState->deltest)) {
             $orders = daoInst()->select()->from('tpl_order_tab_deltest')
                     ->where('uid')->eq(substr($uid, strpos($uid, "-") + 1))
                     ->andwhere('status')->eq(1)
@@ -185,24 +180,23 @@ class PayProc {
                         return Resp::err(ErrCode::pay_m_type_err);
                     }
                     for ($i = 0; $i < $product_count; $i++) {                       # 默认为1,还没有设计为n的情况 
-                        EmailProc::SendDelTestMail($req->zoneid, $uid, $item->name, $item->goods);
+                        EmailProc::SendDelTestMail(req()->zoneid, $uid, $item->name, $item->goods);
                     }
-                    CLog::pay($req->uid . '发送删档内侧补偿邮件' . $order->cpOrderId);
+                    CLog::pay(req()->uid . '发送删档内侧补偿邮件' . $order->cpOrderId);
                 }
             }
-            $req->userInfo->game->privateState->deltest = 0;
+            req()->userInfo->game->privateState->deltest = 0;
         }
     }
 
     /**
-     * 检查异常订单
-     * @param Req $req
+     * 检查异常订单 
      */
-    public static function selfhelpCheckOrders($req) {
+    public static function selfhelpCheckOrders() {
         if ('ios' == PLAT) {                                                    # ios版的创建订单时带着前缀了。。。
-            $uid = $req->uid;
+            $uid = req()->uid;
         } else {
-            $uid = substr($req->uid, strpos($req->uid, '-') + 1);
+            $uid = substr(req()->uid, strpos(req()->uid, '-') + 1);
         }
         $orders = daoInst()->select()
                 ->from('tpl_order_tab')
@@ -235,7 +229,7 @@ class PayProc {
                     return Resp::err(ErrCode::pay_m_type_err);
                 }
                 for ($i = 0; $i < $product_count; $i++) {                       # 默认为1,还没有设计为n的情况
-                    StoreProc::AddMultiItemInStore($req, $item->goods, 5);      # 发货
+                    StoreProc::AddMultiItemInStore($item->goods, 5);      # 发货
                 }
                 $goods .= $item->goods;
                 $n = daoInst()->update(self::orderTab)                          # 更新订单状态
@@ -243,16 +237,16 @@ class PayProc {
                         ->where('cpOrderId')->eq($order->cpOrderId)
                         ->exec();
                 if (!$n) {                                                      # 影响条数应为1
-                    CLog::pay($req->uid . ' 登录补发订单失败 ' . $order->cpOrderId);
+                    CLog::pay(req()->uid . ' 登录补发订单失败 ' . $order->cpOrderId);
                     return Resp::err(ErrCode::err_db);              # 数据库操作失败
                 }
-                $req->userInfo->game->baseInfo->charge_amt += $order->amount;             # 历史充值记录(单位分)
+                req()->userInfo->game->baseInfo->charge_amt += $order->amount;             # 历史充值记录(单位分)
                 UserProc::updateUserInfo();                                 # 回写玩家数据
-                CLog::pay($req->uid . ' 登录补发订单 ' . $order->cpOrderId);
+                CLog::pay(req()->uid . ' 登录补发订单 ' . $order->cpOrderId);
             }
             return Resp::ok(# 返回
-                            array('cash' => $req->userInfo->game->baseInfo->cash, #       # 直接将游戏币的最新值返回给客户端
-                                'store' => $req->userInfo->game->store, #               # 背包
+                            array('cash' => req()->userInfo->game->baseInfo->cash, #       # 直接将游戏币的最新值返回给客户端
+                                'store' => req()->userInfo->game->store, #               # 背包
                                 'goods' => $goods, #                                    # 发货内容
                                 'count' => count($orders), #                            # 发货数量
                                 'msg' => "找到并处理" . count($orders) . "条未发货订单."
@@ -268,13 +262,12 @@ class PayProc {
     /**
      *  【移动支付】获取神秘商城物品
      *  刷新规则: 根据玩家拥有的英雄、装备、道具等数据进行刷新。（因英雄、道具、装备数量不足以支撑该刷新规则，目前先按照随机刷新做，几率平等）
-     * @param Req $req
      */
-    public static function m_pay_getDynamic($req) {
-        $user = $req->userInfo->game;
+    public static function m_pay_getDynamic() {
+        $user = req()->userInfo->game;
         $userSecretshop = new Info_UserSecretshop($user->userSecretshop);
         // 参数提取
-        $refreshType = $req->paras[0];                                          # 刷新类型(参数)0,不刷,1,免费刷,2,钻石刷
+        $refreshType = req()->paras[0];                                          # 刷新类型(参数)0,不刷,1,免费刷,2,钻石刷
         switch ($refreshType) {
             case 1:                                                             # 免费刷
                 if (now() < $userSecretshop->lastRefreshTs + glc()->secretshop_refresh_interval) { // 检查是否达到免费刷新时间了, 执行自动更新
@@ -298,12 +291,12 @@ class PayProc {
                 break;
         }
         if ($refreshType != 0) {                                                   # 是否刷新
-            $err = self::refreshDynamicShopItems($req, $userSecretshop);        # 更新物品表
+            $err = self::refreshDynamicShopItems($userSecretshop);        # 更新物品表
             if ($err) {
                 return Resp::err($err);
             }
             $user->userSecretshop = $userSecretshop;
-            $req->userInfo->game = $user;
+            req()->userInfo->game = $user;
             UserProc::updateUserInfo();
         }
         // 返回最新物品表
@@ -316,11 +309,10 @@ class PayProc {
     }
 
     /**
-     * 更新神秘商城物品
-     * @param Req $req
+     * 更新神秘商城物品 
      * @param Info_UserSecretshop $userSecretshop Description
      */
-    private static function refreshDynamicShopItems($req, &$userSecretshop) {
+    private static function refreshDynamicShopItems(&$userSecretshop) {
         $userSecretshop->lastRefreshTs = now();
         // todo: 这里补完更新物品的函数,     //        第一版: 随机
         $userSecretshop->currentItems = ObjectInit();
@@ -344,7 +336,7 @@ class PayProc {
      */
     static function Dice($arr, $number, &$userSecretshop) {
         $max = 0;                                                               # 计算物品权重总和
-        array_walk($arr, function ($value) use(&$max) {
+        array_walk($arr, function ($value) use (&$max) {
             $max += $value->probability;
         });
         if (!$max) {                                                            # 配置数据有问题
@@ -372,62 +364,50 @@ class PayProc {
     }
 
     /**
-     * 清理每日各种上限
-     * @param Req $req
+     * 清理每日各种上限 
      */
-    private static function clearDailyLimits($req) {
-        $userSecretshop = new Info_UserSecretshop($req->userInfo->game->userSecretshop);
+    private static function clearDailyLimits() {
+        $userSecretshop = new Info_UserSecretshop(req()->userInfo->game->userSecretshop);
         $userSecretshop->refreshedTimes = 0;
-        $req->userInfo->game->userSecretshop = $userSecretshop;
+        req()->userInfo->game->userSecretshop = $userSecretshop;
     }
 
     /**
-     * 【移动支付】购买神秘商城物品
-     * 规则： 商城物品会刷新
-     * @param Req $req
+     * [8809]【移动支付】购买神秘商城物品
+     * 规则： 商城物品会刷新 
      */
-    public static function m_pay_buyDynamic($req) {
-        $user = new Data_UserGame($req->userInfo->game);
+    public static function m_pay_buyDynamic() {
+        $user = new Data_UserGame(req()->userInfo->game);
         $userSecretshop = new Info_UserSecretshop($user->userSecretshop);
-        // 参数提取
-        $itemId = $req->paras[0];                                               # 商品id (点一次购买一个)
+        $itemId = req()->paras[0];                                              # 商品id (点一次购买一个)
         $num = 1;                                                               # 暂时固定为一次购买一个
         #
-        if (!CommUtil::isPropertyExists($userSecretshop->currentItems, $itemId)) {
-            return Resp::err(ErrCode::pay_secretshop_noitem_err);
-        }
+        my_Assert(CommUtil::isPropertyExists($userSecretshop->currentItems, $itemId), ErrCode::pay_secretshop_noitem_err);
         $cishu = $userSecretshop->currentItems->$itemId;                        # 购买次数
-        if ($cishu >= glc()->secretshop_itembuy_maxtimes) {                     # 判断购买次数
-            return Resp::err(ErrCode::pay_secretshop_buytimes);
-        }
+        my_Assert($cishu < glc()->secretshop_itembuy_maxtimes, ErrCode::pay_secretshop_buytimes); # 判断购买次数
 
         $shopItem = GameConfig::secretshop_typeId_getItem($itemId);             # 常量数据
         $amt = $shopItem->price * pow(2, $cishu);                               # 计算价格
         switch ($shopItem->pricetype) {
             case 1:
-                if (!Data_UserGame::Consume_Cash($user->baseInfo, $amt)) {                # 扣除钻石
-                    return Resp::err(ErrCode::notenough_cash_msg);
-                }
+                my_Assert(Data_UserGame::Consume_Cash($user->baseInfo, $amt), ErrCode::notenough_cash_msg); # 扣除钻石
                 break;
             case 2:
-                if (!Data_UserGame::Consume_Gold($user->baseInfo, $amt)) {                # 扣除金币
-                    return Resp::err(ErrCode::notenough_gold_msg);
-                }
+                my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $amt), ErrCode::notenough_gold_msg); # 扣除金币
                 break;
-
             default :
                 return Resp::err(ErrCode::pay_m_type_err);
         }
         // 道具解包/发货
-        $err = self::expendSecretShopItem($shopItem, $num, $req);               # 发放商品()
+        $err = self::expendSecretShopItem($shopItem, $num);                     # 发放商品
 
         if ($err != ErrCode::ok) {                                              # 发货失败
             return Resp::err($err);
         }
         $userSecretshop->currentItems->$itemId += 1;                            # 购买次数+1
         $user->userSecretshop = $userSecretshop;
-        $req->userInfo->game = $user;
-        UserProc::updateUserInfo();                                         # 回写数据
+        req()->userInfo->game = $user;
+        UserProc::updateUserInfo();                                             # 回写数据
 //        StatProc::secretShopbuy($req->zoneid, $req->uid, $itemId, $num);        # 统计/监控数据
         return Resp::ok(array(#                                                 # 成功后将最新的玩家数据返回给客户端
                     'gold' => $user->baseInfo->gold,
@@ -442,12 +422,11 @@ class PayProc {
     /**
      *
      * @param sm_secretshop $shopItem
-     * @param type $num
-     * @param type $req
+     * @param type $num 
      */
-    private static function expendSecretShopItem($shopItem, $num, $req) {
+    private static function expendSecretShopItem($shopItem, $num) {
         for ($i = 0; $i < $num; $i++) {
-            $err = StoreProc::AddMultiItemInStore($req, $shopItem->goods, '神秘商城');
+            $err = StoreProc::AddMultiItemInStore($shopItem->goods, '神秘商城');
             if ($err) {
                 return $err;
             }
@@ -456,157 +435,87 @@ class PayProc {
     }
 
     /**
-     * 【移动支付】 购买普通商城物品
-     * @param Req $req
-     * @return type
+     * [8807]【移动支付】 购买普通商城物品 
      */
-    public static function m_pay($req) {
+    public static function m_pay() {
+        $user = req()->userInfo->game;                                          # user引用
+        my_Assert(count(req()->paras) >= 3, ErrCode::parasnotenough_msg);       # 参数不足
 
-        $zoneid = $req->zoneid;
-        $uid = $req->uid;
-        $user = $req->userInfo->game;                                           # user引用
-        if (count($req->paras) < 3) {                                           # 参数不足
-            return Resp::err(ErrCode::parasnotenough_msg);
-        }
-        $paytype = $req->paras[0];                                              # 付费类型, 1.钻石, 2.金币
-        $itemId = $req->paras[1];                                               # 道具ID
-        $num = $req->paras[2];                                                  # 数量, 默认为1
-        if ($num < 1) {                                                         # 参数非法,
-            return Resp::err(ErrCode::paras_err);
-        }
+        list($paytype, $itemId, $num) = req()->paras;                           # 付费类型, 1.钻石, 2.金币 ,道具ID ,数量, 默认为1
+        my_Assert($num >= 1, ErrCode::paras_err);                               # 参数非法,
         $shopItem = GameConfig::shop_getItem($itemId);                          # 取商品的常量数据
-        if ($shopItem == null) {                                                # 检测是否存在道具的常量数据
-            return Resp::err(ErrCode::err_const_no);
-        }
-        if ($shopItem->pricetype != $paytype) {                                 # 商品定价类型检查
-            return Resp::err(ErrCode::pay_price_err);
-        }
+        my_Assert(isset($shopItem), ErrCode::err_const_no);                     # 检测是否存在道具的常量数据
+        my_Assert($shopItem->pricetype == $paytype, ErrCode::pay_price_err);    # 商品定价类型检查
         $amt = $shopItem->price;                                                # 道具价格（钻石）
-        if ($amt <= 0) {                                                        # 商品定价数值检查
-            return Resp::err(ErrCode::pay_price_err);
-        }
+        my_Assert($amt > 0, ErrCode::pay_price_err);                            # 商品定价数值检查
         $bDeal = false;                                                         # 成交标志位
         switch ($paytype) {                                                     # 1. 钻石, 2. 金币, other:非法
             case 1:                                                             # 钻石
-                $err = self::_SaveUserCash($req, $amt * $num);                  # 更新(扣除)玩家游戏币(钻石)余额
-                if (ErrCode::ok != $err) {
-                    return Resp::err($err);
-                }
-                $bDeal = true;
+                $bDeal = Data_UserGame::Consume_Cash(req()->userInfo->game->baseInfo, $amt);   # 更新(扣除)玩家游戏币(钻石)余额
+                my_Assert($bDeal, ErrCode::notenough_cash_msg);                 # 防范扣除失败
                 break;
             case 2:                                                             # 金币
-                if (!Data_UserGame::Consume_Gold($user->baseInfo, $amt * $num)) {         # 更新玩家金币余额
-                    return Resp::err(ErrCode::notenough_gold_msg);
-                }                                                               # 更新(扣除)玩家游戏币(金币)余额
-                $bDeal = true;
+                $bDeal = Data_UserGame::Consume_Gold($user->baseInfo, $amt * $num);        # 更新玩家金币余额
+                my_Assert($bDeal, ErrCode::notenough_gold_msg);                 # 防范扣除失败
                 break;
             default :                                                           # 未知的支付类型
                 return Resp::err(ErrCode::pay_m_type_err);
         }
 
-        if ($bDeal) {
-//            var_dump($shopItem);
-            $err = self::expendShopItem($shopItem, $num, $req);                 # 发放商品(普通商城只有金币和体力)
-
-            if ($err != ErrCode::ok) {                                          # 发货失败
-                return Resp::err($err);
-            }
-            UserProc::updateUserInfo();                                     # 回写数据
+        my_Assert($bDeal, ErrCode::err_innerfault);                             # 交易失败
+        $err = self::expendShopItem($shopItem, $num);                           # 发放商品(普通商城只有金币和体力)
+        my_Assert(ErrCode::ok == $err, $err);                                   # 防范发货失败
+        UserProc::updateUserInfo();                                             # 回写数据
 //            StatProc::shopbuy($zoneid, $uid, $itemId, $num);                    # 统计/监控数据
-            return Resp::ok(array(#                                             # 成功后将最新的玩家数据返回给客户端
-                        'gold' => $user->baseInfo->gold,
-                        'tili' => $user->baseInfo->tili,
-                        'cash' => $user->baseInfo->cash,
-                        'store' => $user->store
-            ));
-        }
-
-        return Resp::err(ErrCode::err_innerfault);
+        return Resp::ok(array(#                                                 # 成功后将最新的玩家数据返回给客户端
+                    'gold' => $user->baseInfo->gold,
+                    'tili' => $user->baseInfo->tili,
+                    'cash' => $user->baseInfo->cash,
+                    'store' => $user->store
+        ));
     }
 
     /**
      * 解包商城物品
      * @param sm_Shop $shopItem
-     * @param int $num 数量
-     * @param Req $req
+     * @param int $num 数量 
      */
-    static function expendShopItem($shopItem, $num, $req) {
+    static function expendShopItem($shopItem, $num) {
         for ($i = 0; $i < $num; $i++) {
-            $err = StoreProc::AddMultiItemInStore($req, $shopItem->goods, '商城');
-            if ($err) {
-                return $err;
-            }
+            $err = StoreProc::AddMultiItemInStore($shopItem->goods, '商城');
+            my_Assert(ErrCode::ok == $err, $err);
         }
         return ErrCode::ok;
     }
 
-    /**
-     * 扣除玩家钻石
-     * @param Req $req
-     * @param int $amt
-     * @return int
-     */
-    static function _SaveUserCash($req, $amt) {
-        $err = ErrCode::ok;
-        if ($amt > 0) {                                     # 防御，数量不可能小于0
-            $user = $req->userInfo->game;
-            if ($user->cash < $amt) {                       # 余额不足
-                $err = ErrCode::notenough_cash_msg;
-            } else {                                        # 更新玩家游戏币余额
-                Data_UserGame::set_Cash($user, $user->cash - $amt);
-            }
-        }
-        return $err;
-    }
-
-    /**
-     * 扣除玩家金币
-     * @param req $req
-     * @param type $amt
-     * @param type $source
-     * @param type $itemId
-     * @return type
-     */
-    static function _SaveUserGold($req, $amt) {
-        $err = ErrCode::ok;
-        $user = $req->userInfo->game;
-        if (!Data_UserGame::Consume_Gold($user->baseInfo, $amt)) {        # 更新玩家金币余额
-            $err = ErrCode::notenough_gold_msg;
-        }
-        return $err;
-    }
-
 // </editor-fold>
 // 
     //
 // <editor-fold defaultstate="collapsed" desc="  支付活动 - 首付礼包">
 
     /**
-     * 领取首付礼包
-     * @param Req $req
-     * @return Resp
+     * [8802] 领取首付礼包 
      */
-    public static function m_GetFirstPayGift($req) {
+    public static function m_GetFirstPayGift() {
         $itemId = glc()->FirstPay_ItemId;
-        $privateState = $req->userInfo->game->privateState;
+        $privateState = req()->userInfo->game->privateState;
 
         if (CommUtil::isPropertyExists($privateState, "firstPayGift") #
                 && $privateState->firstPayGift) {                               # 如果已经领取首付礼包
             return Resp::err(ErrCode::pay_firstpaygetted);
         }
-        if ($req->userInfo->game->baseInfo->charge_amt <= 0) {                            # 如果尚未完成首付
-            return Resp::err(ErrCode::pay_firstpayno_err);
-        }
+        my_Assert(req()->userInfo->game->baseInfo->charge_amt > 0, ErrCode::pay_firstpayno_err);                            # 如果尚未完成首付
+
         $itemModel = GameConfig::shop_getItem($itemId);                         # 取商品常量
         if ($itemModel == null) {                                               # 检测首付礼包是否存在
             return Resp::err(ErrCode::err_const_no);
         }
-        $req->userInfo->game->privateState->firstPayGift = true;                # 设置首付标志
-        StoreProc::AddMultiItemInStore($req, $itemModel->goods);                # 发放首付礼包到玩家仓库
+        req()->userInfo->game->privateState->firstPayGift = true;               # 设置首付标志
+        StoreProc::AddMultiItemInStore($itemModel->goods);                      # 发放首付礼包到玩家仓库
         UserProc::updateUserInfo();                                             # 更新玩家数据
         return Resp::ok(array('itemid' => $itemId,
                     'rewardstr' => $itemModel->goods,
-                    'store' => $req->userInfo->game->store));                   # 回送成功信息
+                    'store' => req()->userInfo->game->store));                   # 回送成功信息
     }
 
 // </editor-fold>

Gameserver/Amfphp/process/PayProc/YuanBaoPayProc.php

@@ -65,24 +65,24 @@ class YuanBaoPayProc {
                         CLog::err("[Cheating] m_payByYuanbao:" . $req->uid, __CLASS__);
                         $resp = Resp::err(ErrCode::notenought_yuanbao);
                     } else { # 发货
-                        StoreProc::addSeprateItem($itemModel, $req);
+                        StoreProc::addSeprateItem($itemModel);
                         $amt = $itemModel->cost;
                         $source = "商城购买-" . $itemModel->name;
                         self::mn_SaveUserYuanbao($req, $amt, $source);       // 更新玩家游戏币余额
                         UserProc::updateUserInfo(); // 直接将$user的最新值返回给客户端
                         $resp = Resp::ok("success");
                     }
-                } else { # 钻石、金币
-                    $prize = JsonUtil::decode($itemModel->prize); # 价格
-                    if (property_exists($prize, "c") && $prize->c > 0) {// 钻石购买
+                } else {                                                        # 钻石、金币
+                    $prize = JsonUtil::decode($itemModel->prize);               # 价格
+                    if (property_exists($prize, "c") && $prize->c > 0) {        // 钻石购买
                         $amt = self::_getItemCashPrize($itemModel); // 道具价格（钻石）
                         if ($amt <= 0) {
                             $resp = Resp::err(ErrCode::pay_price_err);
                         } else {
-                            if ($user->cash < $amt) { // 余额不足
+                            if ($user->cash < $amt) {                           // 余额不足
                                 $resp = Resp::err(ErrCode::notenough_cash_msg);
                             } else { // 发货
-                                StoreProc::addSeprateItem($itemModel, $req); // 更新玩家游戏币余额
+                                StoreProc::addSeprateItem($itemModel);          // 更新玩家游戏币余额
 //                                $user->cash -= $amt;
                                 self::mn_SaveUserCash($req, $amt, "商城购买-花钻", $itemId);
                                 UserProc::updateUserInfo(); // 直接将$user的最新值返回给客户端
@@ -94,7 +94,7 @@ class YuanBaoPayProc {
                         if ($req->userInfo->game->baseInfo->gold < $prize->g) {
                             $resp = Resp::err(ErrCode::notenough_gold_msg);
                         } else {// 发货
-                            StoreProc::addSeprateItem($itemModel, $req); // 更新玩家金币余额
+                            StoreProc::addSeprateItem($itemModel); // 更新玩家金币余额
                             UserModel::Comsume_Gold($user, $prize->g); // 更新玩家数据信息
                             UserProc::updateUserInfo(); // 直接将$user的最新值返回给客户端
                             $resp = Resp::ok($user);

Gameserver/Amfphp/process/RankProc.php

@@ -13,29 +13,28 @@ class RankProc {
 
     /**
      * 处理逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    static function procMain($req) {
-        switch ($req->cmd) {
+    static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::rank_fpower_getRank:                                  # 6601 拉取战斗力榜单信息
-                return self::GetFpowerRank($req);
+                return self::GetFpowerRank();
             case CmdCode::rank_fpower_drawReward:                               # 6602 领取战斗力榜单突破奖励
-                return self::DrawFpowerBreakThrougReward($req);
+                return self::DrawFpowerBreakThrougReward();
             case CmdCode::rank_fpower_getRanking:                               # 6603 查询玩家战斗力排名
-                return self::GetRankingOfUserFightPower($req);
+                return self::GetRankingOfUserFightPower();
             case CmdCode::rank_fpower_breachLog:                                # 6607 查询战力榜突破记录
-                return self::GetFpowerBreachLog($req);
+                return self::GetFpowerBreachLog();
             case CmdCode::rank_getTop1:                                         # 6604 查询top1信息
-                return self::RankGetAllTop1($req);
+                return self::RankGetAllTop1();
 
             case CmdCode::rank_passgate_getrank:                                # 6605 查询通关榜榜单信息
-                return self::GetPassgateRank($req);
+                return self::GetPassgateRank();
             case CmdCode::rank_passgate_drawReward:                             # 6606 领取通关榜突破奖励
-                return self::DrawPassgateReward($req);
+                return self::DrawPassgateReward();
 
             case CmdCode::rank_passgate_breachLog:                              # 6608 查询通关帮突破记录
-                return self::GetPassgateBreachLog($req);
+                return self::GetPassgateBreachLog();
 
             default:
                 return Resp::err(ErrCode::cmd_err);
@@ -43,15 +42,14 @@ class RankProc {
     }
 
     /**
-     * 查询指定榜单的top1
-     * @param type $req
+     * 查询指定榜单的top1 
      * @param type $key
      * @return type
      */
-    static function _RankGetTop1($req, $key) {
+    static function _RankGetTop1($key) {
         $no1 = gMem()->zrevrange($key, 0, 0, true);                             # 取第一名信息
         foreach ($no1 as $uid => $score) {                                      # 
-            $uinfo = UserProc::getUserInfo($req->zoneid, $uid);         # 读取玩家信息
+            $uinfo = UserProc::getUserInfo(req()->zoneid, $uid);                # 读取玩家信息
             return array(#                                                      # 拼装玩家信息
                 'uid' => $uid,
                 'name' => my_null_default($uinfo->game->baseInfo->name, ""),
@@ -67,15 +65,14 @@ class RankProc {
     //   <editor-fold defaultstate="collapsed" desc="  战斗力榜  ">
 
     /**
-     * [6607] 排行榜 - 查询战力榜突破记录
-     * @param req $req
+     * [6607] 排行榜 - 查询战力榜突破记录 
      */
-    static function GetFpowerBreachLog($req) {
-        $key = MemKey_GameRun::Game_Rank_FPowerBreakLog_hash($req->zoneid);     # redis key 战力榜突破记录
+    static function GetFpowerBreachLog() {
+        $key = MemKey_GameRun::Game_Rank_FPowerBreakLog_hash(req()->zoneid);     # redis key 战力榜突破记录
         $kv = gMem()->hgetall($key);
         $ret = array();
         foreach ($kv as $condition => $uid) {
-            $uinfo = UserProc::getUserInfo($req->zoneid, $uid);      # 读取玩家信息
+            $uinfo = UserProc::getUserInfo(req()->zoneid, $uid);      # 读取玩家信息
             $ret[$condition] = array(#                                          # 拼装玩家信息
                 'uid' => $uid,
                 'name' => my_null_default($uinfo->game->baseInfo->name, ""),
@@ -88,15 +85,14 @@ class RankProc {
     }
 
     /**
-     * [6601]拉取战斗力榜单数据
-     * @param req $req
+     * [6601]拉取战斗力榜单数据 
      */
-    static function GetFpowerRank($req) {
+    static function GetFpowerRank() {
         $RowsPerPage = 10;                                                      # 常量:每页数据条数10条
         $MaxRankId = 100;                                                       # 常量:最大上榜人数.
-        $pageId = $req->paras[0];                                               # 参数:页码, 从零开始.
+        $pageId = req()->paras[0];                                               # 参数:页码, 从零开始.
 
-        $key = MemKey_GameRun::Game_FightPowerRank_zset($req->zoneid);          # redis key
+        $key = MemKey_GameRun::Game_FightPowerRank_zset(req()->zoneid);          # redis key
         $startid = 0 + $RowsPerPage * ($pageId - 1);                            # 起始id
         $endId = $startid + $RowsPerPage - 1;                                   # 结束id
         if ($endId > $MaxRankId) {                                              # 榜单长度 
@@ -105,7 +101,7 @@ class RankProc {
         $uids = gMem()->zrevrange($key, $startid, $endId, true);                # 取上榜玩家
         $userInfos = array();                                                   # 玩家信息
         foreach ($uids as $uid => $score) {
-            $uinfo = UserProc::getUserInfo($req->zoneid, $uid);      # 读取玩家信息
+            $uinfo = UserProc::getUserInfo(req()->zoneid, $uid);      # 读取玩家信息
             $userInfos[] = array(#                                              # 拼装玩家信息
                 'uid' => $uid,
                 'name' => my_null_default($uinfo->game->baseInfo->name, ""),
@@ -114,8 +110,8 @@ class RankProc {
                 'headImg' => my_null_default($uinfo->game->baseInfo->headImg, "")
             );
         }
-        $user_ranking = gMem()->zrevrank($key, $req->uid);                      # 查询玩家排名
-        $user_score = gMem()->zscore($key, $req->uid);                          # 查询积分
+        $user_ranking = gMem()->zrevrank($key, req()->uid);                      # 查询玩家排名
+        $user_score = gMem()->zscore($key, req()->uid);                          # 查询积分
         return Resp::ok(array(#                                                 # 返回值
                     'rankInfo' => $userInfos,
                     'ranking' => my_null_default($user_ranking, 100) + 1, #     # 修正下排名(zset中是从零开始的)
@@ -124,13 +120,12 @@ class RankProc {
     }
 
     /**
-     * [6602]领取战斗力突破奖励
-     * @param req $req
+     * [6602]领取战斗力突破奖励 
      */
-    static function DrawFpowerBreakThrougReward($req) {
-        $rewardCondition = $req->paras[0];                                      # 领取奖励的档次条件(战斗力数值)
+    static function DrawFpowerBreakThrougReward() {
+        $rewardCondition = req()->paras[0];                                      # 领取奖励的档次条件(战斗力数值)
 
-        $key = MemKey_GameRun::Game_FightPowerRank_zset($req->zoneid);          # redis key
+        $key = MemKey_GameRun::Game_FightPowerRank_zset(req()->zoneid);          # redis key
         $no1 = gMem()->zrevrange($key, 0, 0, true);                             # 取第一名信息
         $_power = 0;
         foreach ($no1 as $uid => $power) {                                      # 
@@ -140,25 +135,24 @@ class RankProc {
         if ($_power < $rewardCondition) {                                       # 不满足领取条件
             return Resp::err(ErrCode::rank_fpower_unlocked);
         }
-        if (in_array($rewardCondition, $req->userInfo->game->privateState->RankFpowerRewardRec)) { # 检查是否已经领取过了
+        if (in_array($rewardCondition, req()->userInfo->game->privateState->RankFpowerRewardRec)) { # 检查是否已经领取过了
             return Resp::err(ErrCode::rank_reward_hasgetted);
         }
-        $req->userInfo->game->privateState->RankFpowerRewardRec[] = $rewardCondition; # 添加领取记录
+        req()->userInfo->game->privateState->RankFpowerRewardRec[] = $rewardCondition; # 添加领取记录
 
         $rewardMo = GameConfig::rankreward_fpower_getItem($rewardCondition);    # 奖励mo
-        StoreProc::AddMultiItemInStore($req, $rewardMo->reward, $req->userInfo->game); # 发放奖励字符串.
+        StoreProc::AddMultiItemInStore($rewardMo->reward, req()->userInfo->game); # 发放奖励字符串.
         UserProc::updateUserInfo();                                             # 流程结束,回写玩家数据
         return Resp::ok();
     }
 
     /**
      * [6603]查询玩家战斗力排名
-     * @param req $req
      */
-    static function GetRankingOfUserFightPower($req) {
-        $key = MemKey_GameRun::Game_FightPowerRank_zset($req->zoneid);          # redis key
-        $ranking = gMem()->zrevrank($key, $req->uid);                           # 查询排名
-        $power = gMem()->zscore($key, $req->uid);                               # 查询战斗力
+    static function GetRankingOfUserFightPower() {
+        $key = MemKey_GameRun::Game_FightPowerRank_zset(req()->zoneid);          # redis key
+        $ranking = gMem()->zrevrank($key, req()->uid);                           # 查询排名
+        $power = gMem()->zscore($key, req()->uid);                               # 查询战斗力
         $ret = array(
             'ranking' => $ranking + 1, #                                        # 修正下排名(zset中是从零开始的)
             'power' => intval($power)
@@ -167,16 +161,15 @@ class RankProc {
     }
 
     /**
-     * [6604] 排行榜查询战斗力最高值
-     * @param Req $req
+     * [6604] 排行榜查询战斗力最高值 
      */
-    static function RankGetAllTop1($req) {
-        $key_fPower = MemKey_GameRun::Game_FightPowerRank_zset($req->zoneid);   # redis key 战力榜
-        $key_passgate = MemKey_GameRun::Game_Rank_passgate_zset($req->zoneid);  # redis key 通关榜
+    static function RankGetAllTop1() {
+        $key_fPower = MemKey_GameRun::Game_FightPowerRank_zset(req()->zoneid);   # redis key 战力榜
+        $key_passgate = MemKey_GameRun::Game_Rank_passgate_zset(req()->zoneid);  # redis key 通关榜
 //        $key_yanling ="";
         $ret = array(
-            "FightPower" => self::_RankGetTop1($req, $key_fPower),
-            "PassGate" => self::_RankGetTop1($req, $key_passgate),
+            "FightPower" => self::_RankGetTop1($key_fPower),
+            "PassGate" => self::_RankGetTop1($key_passgate),
             "Yanling" => null
         );
         return Resp::ok($ret);
@@ -188,14 +181,13 @@ class RankProc {
 
     /**
      * [6608]排行榜 - 查询通关榜突破记录
-     * @param req $req
      */
-    static function GetPassgateBreachLog($req) {
-        $key = MemKey_GameRun::Game_Rank_passage_BreachLog_hash($req->zoneid);     # redis key 战力榜突破记录
+    static function GetPassgateBreachLog() {
+        $key = MemKey_GameRun::Game_Rank_passage_BreachLog_hash(req()->zoneid);     # redis key 战力榜突破记录
         $kv = gMem()->hgetall($key);
         $ret = array();
         foreach ($kv as $condition => $uid) {
-            $uinfo = UserProc::getUserInfo($req->zoneid, $uid);      # 读取玩家信息
+            $uinfo = UserProc::getUserInfo(req()->zoneid, $uid);      # 读取玩家信息
             $ret[$condition] = array(#                                          # 拼装玩家信息
                 'uid' => $uid,
                 'name' => my_null_default($uinfo->game->baseInfo->name, ""),
@@ -211,14 +203,13 @@ class RankProc {
     }
 
     /**
-     * [6606] 领取通关榜突破奖励
-     * @param req $req
+     * [6606] 领取通关榜突破奖励 
      */
-    static function DrawPassgateReward($req) {
-        $rewardCondition = $req->paras[0];                                      # 领取奖励的档次条件(战斗力数值)
+    static function DrawPassgateReward() {
+        $rewardCondition = req()->paras[0];                                      # 领取奖励的档次条件(战斗力数值)
 
-        $privateState = $req->userInfo->game->privateState;
-        $key = MemKey_GameRun::Game_Rank_passgate_zset($req->zoneid);           # redis key
+        $privateState = req()->userInfo->game->privateState;
+        $key = MemKey_GameRun::Game_Rank_passgate_zset(req()->zoneid);           # redis key
         $no1 = gMem()->zrevrange($key, 0, 0, true);                             # 取第一名信息
         $score = 0;
         foreach ($no1 as $uid => $_score) {                                     # 
@@ -234,22 +225,21 @@ class RankProc {
         $privateState->RankPassGateRewardRec[] = $rewardCondition;              # 添加领取记录
 
         $rewardMo = GameConfig::rankreward_passgate_getItem($rewardCondition);    # 奖励mo
-        StoreProc::AddMultiItemInStore($req, $rewardMo->reward, $req->userInfo->game); # 发放奖励字符串.
+        StoreProc::AddMultiItemInStore($rewardMo->reward, req()->userInfo->game); # 发放奖励字符串.
         UserProc::updateUserInfo();                                             # 流程结束,回写玩家数据
         return Resp::ok();
     }
 
     /**
      * [6605] 查询通关榜榜单信息
-     * @param type $req
      * @return type
      */
-    static function GetPassgateRank($req) {
+    static function GetPassgateRank() {
         $RowsPerPage = 10;                                                      # 常量:每页数据条数10条
         $MaxRankId = 100;                                                       # 常量:最大上榜人数.
-        $pageId = $req->paras[0];                                               # 参数:页码, 从零开始.
+        $pageId = req()->paras[0];                                               # 参数:页码, 从零开始.
 
-        $key = MemKey_GameRun::Game_Rank_passgate_zset($req->zoneid);           # redis key
+        $key = MemKey_GameRun::Game_Rank_passgate_zset(req()->zoneid);           # redis key
         $startid = 0 + $RowsPerPage * ($pageId - 1);                            # 起始id
         $endId = $startid + $RowsPerPage - 1;                                   # 结束id
         if ($endId > $MaxRankId) {                                              # 榜单长度 
@@ -258,7 +248,7 @@ class RankProc {
         $uids = gMem()->zrevrange($key, $startid, $endId, true);                # 取上榜玩家
         $userInfos = array();                                                   # 玩家信息
         foreach ($uids as $uid => $score) {
-            $uinfo = UserProc::getUserInfo($req->zoneid, $uid);                 # 读取玩家信息
+            $uinfo = UserProc::getUserInfo(req()->zoneid, $uid);                 # 读取玩家信息
             $userInfos[] = array(#                                              # 拼装玩家信息
                 'uid' => $uid,
                 'name' => my_null_default($uinfo->game->baseInfo->name, ""),
@@ -268,8 +258,8 @@ class RankProc {
             );
         }
 
-        $user_ranking = gMem()->zrevrank($key, $req->uid);                      # 查询玩家排名
-        $user_score = gMem()->zscore($key, $req->uid);                          # 查询积分
+        $user_ranking = gMem()->zrevrank($key, req()->uid);                      # 查询玩家排名
+        $user_score = gMem()->zscore($key, req()->uid);                          # 查询积分
         return Resp::ok(array(#                                                 # 返回值
                     'rankInfo' => $userInfos,
                     'ranking' => my_null_default($user_ranking, 100) + 1, #      # 修正下排名(zset中是从零开始的), 如果是null => 榜单之外

Gameserver/Amfphp/process/ShopProc.php

@@ -12,34 +12,33 @@ class ShopProc {
 
     /**
      * 逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param Req $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    public static function procMain($req) {
-        switch ($req->cmd) {
+    public static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::shop_limit_maininfo:
-                return self::GetLimitMainInfo($req);
+                return self::GetLimitMainInfo();
             case CmdCode::shop_limit_buy:
-                return self::BuyLimitPackage($req);
+                return self::BuyLimitPackage();
             case CmdCode::shop_monthlyVIP_Info:
-                return self::GetMonthlyVipInfo($req);
+                return self::GetMonthlyVipInfo();
             case CmdCode::shop_monthlyVIP_Buy:
-                return self::BuyMonthlyVip($req);
+                return self::BuyMonthlyVip();
 
             default:
                 Err(ErrCode::cmd_err);
         }
     }
 
-    public static function GetMonthlyVipInfo($req) {
+    public static function GetMonthlyVipInfo() {
         return Resp::ok(array(
-                    "shopdata" => $req->userInfo->game->shopdata
+                    "shopdata" => req()->userInfo->game->shopdata
         ));
     }
 
-    public static function BuyMonthlyVip($req) {
-        $packageId = $req->paras[0];                                            # 参数; 礼包id
-        $shopdata = new Info_UserShop($req->userInfo->game->shopdata);
+    public static function BuyMonthlyVip() {
+        $packageId = req()->paras[0];                                            # 参数; 礼包id
+        $shopdata = new Info_UserShop(req()->userInfo->game->shopdata);
         $packageCfg = GameConfig::shop_monthVIP_getItem($packageId);
         my_Assert(null != $packageCfg, ErrCode::err_const_no);
         if ($packageCfg->subType == 4) {
@@ -47,43 +46,42 @@ class ShopProc {
         } elseif ($packageCfg->subType == 5) {
             my_Assert($shopdata->monthlyVIP2_ts + $packageCfg->ExpireTs * 3600 * 24 < now(), ErrCode::shop_monthlyvip_buyed);
         }
-        $err = StoreProc::AddMultiItemInStore($req, $packageCfg->pri_reward);   # 发放一次性奖励
+        $err = StoreProc::AddMultiItemInStore($packageCfg->pri_reward);         # 发放一次性奖励
         my_Assert(ErrCode::ok == $err, $err);
         if ($packageCfg->subType == 4) {
             $shopdata->monthlyVIP1_ts = 3600 * 24 * (tsDay() + 1) - 1;
         } elseif ($packageCfg->subType == 5) {
             $shopdata->monthlyVIP2_ts = 3600 * 24 * (tsDay() + 1) - 1;
         }
-        $req->userInfo->game->shopdata = $shopdata;                             # 回写数据
+        req()->userInfo->game->shopdata = $shopdata;                             # 回写数据
         UserProc::updateUserInfo();
+        $user = req()->userInfo->game;
         return Resp::ok(array(
                     "reward" => $packageCfg->pri_reward,
                     "shopdata" => $shopdata,
-                    'gold' => $req->userInfo->game->baseInfo->gold,
-                    'cash' => $req->userInfo->game->baseInfo->cash,
-                    'tili' => $req->userInfo->game->baseInfo->tili,
-                    'store' => $req->userInfo->game->store,
-                    'hero' => $req->userInfo->game->heros
+                    'gold' => $user->baseInfo->gold,
+                    'cash' => $user->baseInfo->cash,
+                    'tili' => $user->baseInfo->tili,
+                    'store' => $user->store,
+                    'hero' => $user->heros
         ));
     }
 
     /**
-     * 【7101】限购礼包主界面
-     * @param Req $req
+     * 【7101】限购礼包主界面 
      */
-    public static function GetLimitMainInfo($req) {
+    public static function GetLimitMainInfo() {
         return Resp::ok(array(
-                    "shopdata" => $req->userInfo->game->shopdata
+                    "shopdata" => req()->userInfo->game->shopdata
         ));
     }
 
     /**
-     * 【7102】 购买限购礼包
-     * @param Req $req
+     * 【7102】 购买限购礼包 
      */
-    public static function BuyLimitPackage($req) {
-        $packageId = $req->paras[0];                                            # 参数; 礼包id
-        $shopdata = new Info_UserShop($req->userInfo->game->shopdata);
+    public static function BuyLimitPackage() {
+        $packageId = req()->paras[0];                                            # 参数; 礼包id
+        $shopdata = new Info_UserShop(req()->userInfo->game->shopdata);
         $packageCfg = GameConfig::shop_limit_getItem($packageId);
         my_Assert(null != $packageCfg, ErrCode::err_const_no);
 
@@ -104,37 +102,37 @@ class ShopProc {
             default:
                 Err(ErrCode::err_innerfault);
         }
-        $hasN = count(array_filter($arr, function($val)use($packageId) {
+        $hasN = count(array_filter($arr, function ($val)use ($packageId) {
                     return $val == $packageId;
                 }));
         my_Assert($hasN <= $packageCfg->limit_num, ErrCode::shop_limit_max);
         $itemid = explode(',', $packageCfg->reward)[0];                         # 奖励礼包Id
         $itemMO = GameConfig::item_package_getItem($itemid);
         my_Assert(null != $itemMO, ErrCode::err_const_no);
-        $err = StoreProc::AddMultiItemInStore($req, $itemMO->contents);         # 发放奖励
+        $err = StoreProc::AddMultiItemInStore($itemMO->contents);               # 发放奖励
         my_Assert(ErrCode::ok == $err, $err);
-        $req->userInfo->game->shopdata = $shopdata;                             # 回写数据
+        req()->userInfo->game->shopdata = $shopdata;                             # 回写数据
         UserProc::updateUserInfo();
+        $user = req()->userInfo->game;
         return Resp::ok(array(
                     "reward" => $itemMO->contents,
                     "shopdata" => $shopdata,
-                    'gold' => $req->userInfo->game->baseInfo->gold,
-                    'cash' => $req->userInfo->game->baseInfo->cash,
-                    'tili' => $req->userInfo->game->baseInfo->tili,
-                    'store' => $req->userInfo->game->store,
-                    'hero' => $req->userInfo->game->heros
+                    'gold' => $user->baseInfo->gold,
+                    'cash' => $user->baseInfo->cash,
+                    'tili' => $user->baseInfo->tili,
+                    'store' => $user->store,
+                    'hero' => $user->heros
         ));
     }
 
     /**
-     * 每日检查
-     * @param req $req
+     * 每日检查 
      */
-    static function DailyCheck($req) {
+    static function DailyCheck() {
         CLog::info("shop-每日检查-清除每日/周限量礼包购买记录");
-        $zoneid = $req->zoneid;
-        $uid = $req->uid;
-        $shopdata = new Info_UserShop($req->userInfo->game->shopdata);
+        $zoneid = req()->zoneid;
+        $uid = req()->uid;
+        $shopdata = new Info_UserShop(req()->userInfo->game->shopdata);
         $shopdata->purchasedDailyLimitPackages = array();                       # 每天重置
         if (date("N") == 1) {                                                   # 周一重置
             $shopdata->purchasedWeeklyLimitPackages = array();

Gameserver/Amfphp/process/StoreProc.php

@@ -13,65 +13,63 @@ class StoreProc {
 
     /**
      * 逻辑分发
-     * 所有的Proc中必须有这样一个方法
-     * @param type $req
+     * 所有的Proc中必须有这样一个方法 
      */
-    static function procMain($req) {
-        switch ($req->cmd) {
+    static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::cmd_store_put:                                        # 6401 放入仓库
-                return StoreProc::AddItemInStore($req);
+                return StoreProc::AddItemInStore();
             case CmdCode::cmd_store_singleSell:                                 # 6402 出售单个道具
-                return StoreProc::sellItem($req);
+                return StoreProc::sellItem();
             case CmdCode::cmd_store_mutliSell:                                  # 6403 批量出售 卖掉
-                return StoreProc::sellMultiItemFromStore($req);
+                return StoreProc::sellMultiItemFromStore();
             case CmdCode::cmd_store_use:                                        # 6404 使用道具
-                return StoreProc::useItem($req);
+                return StoreProc::useItem();
             case CmdCode::cmd_store_refresh:                                    # 6405 获取最新的仓库数据
-                return StoreProc::refreshStore($req);
+                return StoreProc::refreshStore();
             case CmdCode::cmd_store_delItem:                                    # 6406 从仓库删除道具
-                return StoreProc::delItemFromStore($req);
+                return StoreProc::delItemFromStore();
             case CmdCode::cmd_store_Testcmd:                                    # 6407 测试方法
-                return StoreProc::Test($req);
+                return StoreProc::Test();
 //            case CmdCode::cmd_store_ItemUpgrade:                                # 6408 装备升级
 //                return StoreProc::ItemUpgrade($req);
 //            case CmdCode::cmd_store_GemCompose:                                 # 6408 装备合成
 //                return StoreProc::composeItem($req);
 //
             case CmdCode::cmd_store_WearEquip:                                  # 6410 给英雄穿装备
-                return StoreProc::WearEquipToHero($req);
+                return StoreProc::WearEquipToHero();
             case CmdCode::cmd_store_UnWieldEquip:                               # 6411 将该装备从指定英雄上脱下
-                return StoreProc::UnWieldEquip($req);
+                return StoreProc::UnWieldEquip();
 
 // 
             case CmdCode::cmd_store_AddMaxPacketNum:                            # 6412 扩展包裹格子数量
-                return StoreProc::AddPacketNum($req);
+                return StoreProc::AddPacketNum();
 //            case CmdCode::cmd_store_MeltEquip:                                  # 6413 装备融合
 //                Err(ErrCode::err_method_obsoleted);
 ////                return StoreProc::MeltEquip($req);
 //            case CmdCode::cmd_store_PiecesCompose:                              # 6415 碎片合成
 //                return StoreProc::composePieces($req);
             case CmdCode::cmd_store_WearYanling:                                # 6416 装备言灵
-                return StoreProc::WearYanlingToHero($req);
+                return StoreProc::WearYanlingToHero();
             case CmdCode::cmd_store_UnWieldYanling:                             # 6417 卸下言灵
-                return StoreProc::UnWieldYanling($req);
+                return StoreProc::UnWieldYanling();
             case CmdCode::cmd_store_mergeYanlingbook:                           # 6418 利用言灵召唤书碎片合成召唤书
-                return self::MergeYanlingBook($req);
+                return self::MergeYanlingBook();
             case CmdCode::cmd_store_callyanling:                                # 6419 利用言灵召唤书召唤言灵
-                return self::CallYanlingByBook($req);
+                return self::CallYanlingByBook();
             case CmdCode::cmd_store_yanling_upgrade:                            # 6420 言灵进阶
-                return self::YanlingUpgrade($req);
+                return self::YanlingUpgrade();
             default:
                 Err(ErrCode::cmd_err);
         }
     }
 
     /**
-     * [6420] 言灵进阶
-     * @param req $req
+     * [6420] 言灵进阶 
      */
-    static function YanlingUpgrade($req) {
-        list($yanlingUid) = $req->paras;                                        # 参数 言灵uid(指定进阶的言灵实例id)
-        $user = $req->userInfo->game;
+    static function YanlingUpgrade() {
+        list($yanlingUid) = req()->paras;                                        # 参数 言灵uid(指定进阶的言灵实例id)
+        $user = req()->userInfo->game;
         my_Assert(property_exists($user->store->yanling, $yanlingUid), "找不到这个言灵");
         $yanlingObj = $user->store->yanling->$yanlingUid;
         $yanlingMoId = $yanlingObj->typeId;
@@ -91,17 +89,16 @@ class StoreProc {
         $user->store->yanling->$yanlingUid = $yanlingObj;                       # 回写言灵数据 
         UserProc::updateUserInfo();                                             # 回写玩家数据 
         return Resp::ok(array(
-                    "store" => $req->userInfo->game->store, #                   # 目前来看只涉及到items变化
+                    "store" => $user->store, #                                  # 目前来看只涉及到items变化
         ));
     }
 
     /**
-     * [6418] 利用言灵召唤书碎片合成召唤书
-     * @param req $req
+     * [6418] 利用言灵召唤书碎片合成召唤书 
      */
-    static function MergeYanlingBook($req) {
-        list($bookId) = $req->paras;                                            # 参数 言灵召唤书id
-        $user = $req->userInfo->game;
+    static function MergeYanlingBook() {
+        list($bookId) = req()->paras;                                            # 参数 言灵召唤书id
+        $user = req()->userInfo->game;
         $bookIdCfg = GameConfig::item_yanlingbook_getItem($bookId);
         my_Assert(null != $bookIdCfg, ErrCode::err_const_no);                   # 找不到言灵书常量
         list($segId, $num) = explode(',', $bookIdCfg->seg_num);                 # 解析所需碎片信息
@@ -110,17 +107,16 @@ class StoreProc {
         self::PutOverlyingItemInStore($bookId);                                 # 添加召唤书
         UserProc::updateUserInfo();                                             # 回写数据 
         return Resp::ok(array(
-                    "store" => $req->userInfo->game->store, #                   # 目前来看只涉及到items变化
+                    "store" => $user->store, #                                  # 目前来看只涉及到items变化
         ));
     }
 
     /**
-     * [6419] 利用言灵召唤书召唤言灵
-     * @param req $req
+     * [6419] 利用言灵召唤书召唤言灵 
      */
-    static function CallYanlingByBook($req) {
-        list($bookId) = $req->paras;                                            # 参数 利用的言灵召唤书id
-        $user = $req->userInfo->game;
+    static function CallYanlingByBook() {
+        list($bookId) = req()->paras;                                            # 参数 利用的言灵召唤书id
+        $user = req()->userInfo->game;
         $bookIdCfg = GameConfig::item_yanlingbook_getItem($bookId);
         my_Assert(null != $bookIdCfg, ErrCode::err_const_no);                   # 找不到言灵书常量
         $err = self::removeItemFromStore($user->store, $bookId);                # 扣除 召唤书
@@ -132,64 +128,58 @@ class StoreProc {
             $err = self::removeItemFromStore($user->store, $itemId, $num);      # 扣除 材料
             my_Assert(ErrCode::ok == $err, $err);                               # 防御扣除材料失败
         }
-        self::PutYanLingInStore($bookIdCfg->yanling_id, $req);                  # 添加言灵 
+        self::PutYanLingInStore($bookIdCfg->yanling_id);                        # 添加言灵 
         UserProc::updateUserInfo();                                             # 回写数据 
         return Resp::ok(array(
-                    "store" => $req->userInfo->game->store, #                   # 目前来看只涉及到items变化
+                    "store" => $user->store, #                                  # 目前来看只涉及到items变化
         ));
     }
 
     /**
-     * 测试方法
-     * @param Req $req
+     * 测试方法 
      * @return type
      */
-    static public function Test($req) {
+    static public function Test() {
         Err(ErrCode::msg_method_obsoleted, "代码需更新");
     }
 
     /**
-     * [6404] 使用仓库道具
-     * @param Req $req
+     * [6404] 使用仓库道具 
      */
-    static function useItem($req) {
+    static function useItem() {
         Err(ErrCode::msg_method_obsoleted, "代码需更新");
     }
 
     /**
-     * [6405] 刷新仓库列表
-     * @param Req $req
+     * [6405] 刷新仓库列表 
      */
-    static function refreshStore($req) {
-        StoreProc::CheckItemNum($req);
-        return Resp::ok(array('store' => $req->userInfo->game->store));
+    static function refreshStore() {
+        StoreProc::CheckItemNum();
+        return Resp::ok(array('store' => req()->userInfo->game->store));
     }
 
     /**
-     * [6406] 从仓库删除道具
-     * @param req $req
+     * [6406] 从仓库删除道具 
      */
-    static function delItemFromStore($req) {
-        list($itemId, $num) = $req->paras;
-        $err = self::removeItemFromStore($req->userInfo->game->store, $itemId, $num);
+    static function delItemFromStore() {
+        list($itemId, $num) = req()->paras;
+        $err = self::removeItemFromStore(req()->userInfo->game->store, $itemId, $num);
         my_Assert(ErrCode::ok == $err, $err);
         UserProc::updateUserInfo();
-        return Resp::ok(array('store' => $req->userInfo->game->store));
+        return Resp::ok(array('store' => req()->userInfo->game->store));
     }
 
     /**
      * [6409] 合成道具
-     * @param Req $req
      */
-    static public function composeItem($req) {
+    static public function composeItem() {
         Err(ErrCode::err_method_notimplement);
     }
 
     /**
-     * [6409] 合成碎片（几个碎片合成获得同品质或者更高品质的新碎片）
-     * @param Req $req
+     * [6409] 合成碎片（几个碎片合成获得同品质或者更高品质的新碎片） 
      */
-    static public function composePieces($req) {
+    static public function composePieces() {
         Err(ErrCode::err_method_notimplement);
     }
 
@@ -222,11 +212,11 @@ class StoreProc {
      * @param Info_Store $store
      * @return boolean
      */
-    static function removeEquipFromStore($uid, $typeId, &$req) {
+    static function removeEquipFromStore($uid, $typeId) {
         $ok = false;
-        if (CommUtil::isPropertyExists($req->userInfo->game->store->equipment, $uid)) {
-            my_Assert($typeId == $req->userInfo->game->store->equipment->$uid->typeId, "typeid检验错误"); // typeid相同;
-            unset($req->userInfo->game->store->equipment->$uid);
+        if (CommUtil::isPropertyExists(req()->userInfo->game->store->equipment, $uid)) {
+            my_Assert($typeId == req()->userInfo->game->store->equipment->$uid->typeId, "typeid检验错误"); // typeid相同;
+            unset(req()->userInfo->game->store->equipment->$uid);
             $ok = true;
         }
         return $ok;
@@ -285,18 +275,16 @@ class StoreProc {
     /**
      * 解包多种物品到玩家身上 【警告】此函数的异常处理功能残废，不安全
      * 检测如果当前物品格子大于物品总数,则可以获取战利品,否则不可以 
-     * @param Req $req
      * @param string $goodsStr itemid,num;itemid,num;...
      * @param int $src 1:战斗奖励, 2: 任务奖励, 3: 抽奖奖品, 4: 邮件领取, 5: 现金充值
      * @deprecated since version 0
      * @return type
      */
-    public static function AddMultiItemInStore($req, $goodsStr, $src = 1) {
+    public static function AddMultiItemInStore($goodsStr, $src = 1) {
         $user = req()->userInfo->game;
         $ary = explode(";", $goodsStr);
         foreach ($ary as $value) {
             $val = explode(",", $value);
-//            var_dump($ary);
             $cid = "";
             my_Assert(count($val) > 1, "解析奖励字符串出错");
             list( $itemId, $num) = $val;                                        # ID, 数量
@@ -312,7 +300,7 @@ class StoreProc {
                     Data_UserGame::Add_Cash($user->baseInfo, $num);
                     break;
                 case META_tili_ITEMID:                                          # 体力       
-                    Data_UserGame::Add_tili(req(), $num);
+                    Data_UserGame::Add_tili($num);
                     break;
                 case META_FriendShipPoit_ItemId:                                # 友情值
                     Data_UserGame::Add_FriendPoint($user->baseInfo, $num);
@@ -328,13 +316,13 @@ class StoreProc {
                     break;
                 case 101:                                                       # 武器 
                     for ($n = 0; $n < $num; $n++) {
-                        $cid = StoreProc::PutEquipInStore($itemId, req());
+                        $cid = StoreProc::PutEquipInStore($itemId);
                     }
                     CornerSignEventProc::OnBag_new_Weapon();
                     break;
                 case 401:                                                       # 言灵
                     for ($n = 0; $n < $num; $n++) {
-                        $cid = StoreProc::PutYanLingInStore($itemId, req());
+                        $cid = StoreProc::PutYanLingInStore($itemId);
                     }
                     CornerSignEventProc::OnBag_new_Yanling();
                     break;
@@ -342,11 +330,11 @@ class StoreProc {
                     var_dump("-== 礼包解包 nil ==-");
                     $itemMO = GameConfig::item_package_getItem($itemId);
                     my_Assert(null != $itemMO, ErrCode::err_const_no);
-                    $err = StoreProc::AddMultiItemInStore(req(), $itemMO->contents);         # 发放奖励
+                    $err = StoreProc::AddMultiItemInStore($itemMO->contents);         # 发放奖励
                     my_Assert(ErrCode::ok == $err, $err);
                     break;
                 case 601:                                                       # 任务卡
-                    $cid = StoreProc::PutTaskCardInStore($itemId, req());
+                    $cid = StoreProc::PutTaskCardInStore($itemId);
                     break;
                 case 201:                                                       # 碎片
                     $segMo = GameConfig::item_segment_getItem($itemId);
@@ -399,14 +387,12 @@ class StoreProc {
     }
 
     /**
-     * [6401]向包裹中添加物品
-     * @param req $req
-     * @return type
+     * [6401]向包裹中添加物品 
      */
-    public static function AddItemInStore($req) {
-        list($rwdStr) = $req->paras;
-        $user = $req->userInfo->game;
-        $err = self::AddMultiItemInStore($req, $rwdStr);
+    public static function AddItemInStore() {
+        list($rwdStr) = req()->paras;
+        $user = req()->userInfo->game;
+        $err = self::AddMultiItemInStore($rwdStr);
         my_Assert(ErrCode::ok == $err, $err);
         UserProc::updateUserInfo();
         return Resp::ok(array(
@@ -414,57 +400,54 @@ class StoreProc {
                     'tili' => $user->baseInfo->tili,
                     'cash' => $user->baseInfo->cash,
                     'resPoint' => $user->baseInfo->resPoint,
-                    'store' => $req->userInfo->game->store));
+                    'store' => $user->store));
     }
 
     /**
      * 将装备放入背包
-     * @param type $itemId
-     * @param Req $req
+     * @param type $itemId 
      */
-    static function PutEquipInStore($itemId, &$req) {
-        $privateState = $req->userInfo->game->privateState;
+    static function PutEquipInStore($itemId) {
+        $privateState = req()->userInfo->game->privateState;
         if (!CommUtil::isPropertyExists($privateState, "currentId")) {          // 如果仓库中已经有这种元素，则其数目+1
-            $req->userInfo->game->privateState->currentId = 1;
+            req()->userInfo->game->privateState->currentId = 1;
         }
-        $cid = $req->userInfo->game->privateState->currentId++;
+        $cid = req()->userInfo->game->privateState->currentId++;
         $equip = ObjectInit();
         $equip->typeId = $itemId;
-        $req->userInfo->game->store->equipment->$cid = $equip;
+        req()->userInfo->game->store->equipment->$cid = $equip;
         return $cid;
 //        SystemProc::GetEquip($req->zoneid, $req->userInfo->game, $itemId);      # 添加获得装备的消息
     }
 
     /**
      * 将言灵放入背包
-     * @param type $itemId
-     * @param Req $req
+     * @param type $itemId 
      */
-    static function PutYanLingInStore($itemId, &$req) {
-        my_Assert(count((array) $req->userInfo->game->store->yanling) < 100, ErrCode::store_yanling_bagfull);
-        $privateState = $req->userInfo->game->privateState;
+    static function PutYanLingInStore($itemId) {
+        my_Assert(count((array) req()->userInfo->game->store->yanling) < 100, ErrCode::store_yanling_bagfull);
+        $privateState = req()->userInfo->game->privateState;
         if (!CommUtil::isPropertyExists($privateState, "currentId")) {          # 如果仓库中已经有这种元素，则其数目+1
-            $req->userInfo->game->privateState->currentId = 1;
+            req()->userInfo->game->privateState->currentId = 1;
         }
-        $cid = $req->userInfo->game->privateState->currentId++;
+        $cid = req()->userInfo->game->privateState->currentId++;
         //$equip = ObjectInit();
         $equip = new Ins_YanLin();
         $equip->typeId = $itemId;
-        $req->userInfo->game->store->yanling->$cid = $equip;
+        req()->userInfo->game->store->yanling->$cid = $equip;
         return $cid;
     }
 
     /**
      * 将任务卡放入背包
-     * @param type $itemId
-     * @param Req $req
+     * @param type $itemId 
      */
-    static function PutTaskCardInStore($itemId, &$req) {
-        $privateState = $req->userInfo->game->privateState;
+    static function PutTaskCardInStore($itemId) {
+        $privateState = req()->userInfo->game->privateState;
         if (!CommUtil::isPropertyExists($privateState, "currentId")) {          # 如果仓库中已经有这种元素，则其数目+1
-            $req->userInfo->game->privateState->currentId = 1;
+            req()->userInfo->game->privateState->currentId = 1;
         }
-        $cid = $req->userInfo->game->privateState->currentId++;
+        $cid = req()->userInfo->game->privateState->currentId++;
         $mo = GameConfig::item_taskcard_getItem($itemId);                       # 任务卡常量
         my_Assert(null != $mo, ErrCode::err_const_no);
         $itembaseMo = GameConfig::item_base_getItem($itemId);
@@ -490,11 +473,11 @@ class StoreProc {
         } else {
             $taskCard = new Ins_TaskCard($itemId);
             $taskCard->uid = $cid;
-            $req->userInfo->game->store->taskcards->$cid = $taskCard;
+            req()->userInfo->game->store->taskcards->$cid = $taskCard;
         }
         NormalEventProc::OnTaskBag_new_Card($cid, 1);                           # 播放获得任务卡事件
         if (null != $taskCard) {
-            $req->paras = array($cid);
+            req()->paras = array($cid);
             TaskProc::OnTaskCard_active();                                      # 自动激活任务卡
         }
         return $cid;
@@ -516,23 +499,19 @@ class StoreProc {
 
     /**
      * 物品包裹打散成独立道具到仓库
-     * @param GoodsItemModel $itemModel
-     * @param Req $req
-     * @return type
+     * @param GoodsItemModel $itemModel 
      * @deprecated since version now
      */
-    static function addSeprateItem($itemModel, $req) {
+    static function addSeprateItem($itemModel) {
         Err(ErrCode::err_method_obsoleted, "未更新包裹操作");
     }
 
     /**
      * [6416] 给英雄装上言灵
-     * @param req $req
-     * @return type
      */
-    static function WearYanlingToHero($req) {
-        $user = $req->userInfo->game;                                           # user引用
-        list($itemtype, $yanling_uid, $herouid) = $req->paras;                  # 提取参数: 装备类型, 装备的UID, 英雄的UID 
+    static function WearYanlingToHero() {
+        $user = req()->userInfo->game;                                           # user引用
+        list($itemtype, $yanling_uid, $herouid) = req()->paras;                  # 提取参数: 装备类型, 装备的UID, 英雄的UID 
         my_Assert(CommUtil::isPropertyExists($user->store->yanling, $yanling_uid), ErrCode::store_itemno_err); # 检测是否存在该言灵
         $yanlingVo = new Ins_YanLin($user->store->yanling->$yanling_uid);       # 取言灵对象
         if (isset($yanlingVo->herouid) && $yanlingVo->herouid > 0               #
@@ -556,19 +535,17 @@ class StoreProc {
         $ret = array('resp' => "succeed!",
             'store' => $user->store);
         $resp = Resp::ok($ret);                                                 // 返回 
-        HeroProc::CalcUserFightPower($req->zoneid, $req->uid, $user);           # 更新总战力榜
+        HeroProc::CalcUserFightPower(req()->zoneid, req()->uid, $user);           # 更新总战力榜
         return $resp;
     }
 
     /**
-     * [6417] 给英雄卸下言灵
-     * @param req $req
-     * @return type
+     * [6417] 给英雄卸下言灵 
      * @deprecated since version 无法卸下,只能更换
      */
-    static function UnWieldYanling($req) {
-        $user = $req->userInfo->game;                                           # user引用
-        list($itemtype, $yanling_uid, $herouid) = $req->paras;                  # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 
+    static function UnWieldYanling() {
+        $user = req()->userInfo->game;                                           # user引用
+        list($itemtype, $yanling_uid, $herouid) = req()->paras;                  # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 
 
         $collectHeros = $user->heros->collectHeros;
         my_Assert(null != $collectHeros, ErrCode::err_innerfault);              # 防御
@@ -592,13 +569,11 @@ class StoreProc {
     }
 
     /**
-     * [6410] 给英雄穿装备
-     * @param req $req
-     * @return type
+     * [6410] 给英雄穿装备 
      */
-    static function WearEquipToHero($req) {
-        list($itemtype, $equipuid, $herouid) = $req->paras;                     # 提取参数: 装备类型, 装备的UID, 英雄的UID  
-        $user = $req->userInfo->game;                                           # user引用
+    static function WearEquipToHero() {
+        list($itemtype, $equipuid, $herouid) = req()->paras;                    # 提取参数: 装备类型, 装备的UID, 英雄的UID  
+        $user = req()->userInfo->game;                                          # user引用
         my_Assert(CommUtil::isPropertyExists($user->store->equipment, $equipuid), ErrCode::store_itemno_err);  # 检测是否存在该装备
         $equipVo = new Ins_Weapon($user->store->equipment->$equipuid);          # 取装备对象
         if ($equipVo->herouid > 0) {                                            # 检测该装备是否装备到其他英雄身上 
@@ -635,20 +610,18 @@ class StoreProc {
         UserProc::updateUserInfo();                                             // 5.回写数据
 //        StoreProc::CheckItemNum($req);
         TaskProc::OnHeroWearWeapon($collectHeros->$herouid->typeId, $user->store->equipment->$equipuid->typeId);
-        HeroProc::CalcUserFightPower($req->zoneid, $req->uid, $user);           # 更新总战力榜
+        HeroProc::CalcUserFightPower(req()->zoneid, req()->uid, $user);           # 更新总战力榜
         return Resp::ok(array('resp' => "succeed!",
                     'store' => $user->store));                           // 返回 
     }
 
     /**
      * [6411] 给英雄脱装备
-     * @deprecated since version 不能卸下装备, 只能更换.
-     * @param req $req
-     * @return type
+     * @deprecated since version 不能卸下装备, 只能更换.  
      */
-    static function UnWieldEquip($req) {
-        list($itemtype, $equipuid, $herouid) = $req->paras;                     # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 
-        $user = $req->userInfo->game;                                           # user引用
+    static function UnWieldEquip() {
+        list($itemtype, $equipuid, $herouid) = req()->paras;                    # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 
+        $user = req()->userInfo->game;                                          # user引用
 
         $collectHeros = $user->heros->collectHeros;
         my_default_Obj($collectHeros);
@@ -679,8 +652,7 @@ class StoreProc {
             default :
                 Err(ErrCode::store_equip_type);
         }
-        UserProc::updateUserInfo();                                             # 回写数据
-//        StoreProc::CheckItemNum($req);
+        UserProc::updateUserInfo();                                             # 回写数据 
         return Resp::ok(array('resp' => "succeed!"));                           // 返回
     }
 
@@ -691,37 +663,31 @@ class StoreProc {
 
     /**
      * 检查背包中物品的个数
-     * @param req $req
      * @return int
      */
-    public static function CheckItemNum($req) {
-        $ItemObj = $req->userInfo->game->store->items;
-        $EquipObj = $req->userInfo->game->store->equipment;
-        $SegementObj = $req->userInfo->game->store->segement;
-        $HeroObj = $req->userInfo->game->heros->collectHeros;
+    public static function CheckItemNum() {
+        $ItemObj = req()->userInfo->game->store->items;
+        $EquipObj = req()->userInfo->game->store->equipment;
+        $SegementObj = req()->userInfo->game->store->segement;
+        $HeroObj = req()->userInfo->game->heros->collectHeros;
         $ItemNum = 0;
-////检查宝石类可叠加物品的格子占用
         if ($ItemObj) {
-            foreach ($ItemObj as $value) {
+            foreach ($ItemObj as $value) {                                      ////检查宝石类可叠加物品的格子占用
                 $ItemNum++;
             }
         }
         if ($SegementObj) {
-            foreach ($SegementObj as $value) {
+            foreach ($SegementObj as $value) {                                  # 碎片
                 $ItemNum++;
             }
         }
-////检测装备类物品格子占用
         if ($EquipObj) {
-            foreach ($EquipObj as $value) {
+            foreach ($EquipObj as $value) {                                     // 检测装备类物品格子占用
                 $ItemNum++;
             }
         }
-////检测英雄装备到身上的情况,装备到英雄身上不占格子,要减去.
         if ($HeroObj) {
-            foreach ($HeroObj as $value) {
-                //  echo var_dump($HeroObj);
-
+            foreach ($HeroObj as $value) {                                      // 检测英雄装备到身上的情况,装备到英雄身上不占格子,要减去.
                 $HeroEquipId = $value->equip->weapon->itemuid;
                 if ($HeroEquipId > 0) {
                     $ItemNum--;
@@ -736,7 +702,7 @@ class StoreProc {
                 }
             }
         }
-        $req->userInfo->game->privateState->ItemNum = $ItemNum;
+        req()->userInfo->game->privateState->ItemNum = $ItemNum;
         return $ItemNum;
     }
 
@@ -753,12 +719,10 @@ class StoreProc {
     }
 
     /**
-     * 背包扩容
-     * @param type $req
-     * @return req
+     * 6412 背包扩容
      */
-    public static function AddPacketNum($req) {
-        $user = $req->userInfo->game;                                           # user引用
+    public static function AddPacketNum() {
+        $user = req()->userInfo->game;                                           # user引用
         if (!CommUtil::isPropertyExists($user->privateState, "maxItemNum")) {
             $user->privateState->maxItemNum = glc()->Item_Packet_MaxNum;
         }
@@ -769,7 +733,7 @@ class StoreProc {
         $user->privateState->maxItemNum += 10;                                  # 扩容
         UserProc::updateUserInfo();                                             # 保存玩家数据
         $resp = Resp::ok(array('maxItemNum' => $user->privateState->maxItemNum)); # 返回值
-        StoreProc::CheckItemNum($req);
+        StoreProc::CheckItemNum();
         return $resp;
     }
 
@@ -780,49 +744,43 @@ class StoreProc {
 
     /**
      * 出售单一的物品
-     * @param Req $req
-     * @return type
      */
-    static function sellItem($req) {
+    static function sellItem() {
         Err(ErrCode::err_method_obsoleted, "代码需要更新");
     }
 
     /**
-     * 卖出一堆物品时候，检测每个单个物品是否符合卖的条件
-     * @param Req $req
-     * @return type
+     * 卖出一堆物品时候，检测每个单个物品是否符合卖的条件 
      */
-    static function preSellSingleFromStore(&$req, $type, $itemId, $count, $uid) {
+    static function preSellSingleFromStore($type, $itemId, $count, $uid) {
         Err(ErrCode::err_method_obsoleted, "代码需要更新");
     }
 
     /**
-     * 从背包出售多个物品
-     * @param Req $req
-     * @return type
+     * 6403 从背包出售多个物品
      */
-    static function sellMultiItemFromStore($req) {
+    static function sellMultiItemFromStore() {
         Err(ErrCode::err_method_obsoleted, "代码需要更新");
-        $obj = $req->paras[0];                                                  // 获取物品的结构数组  
+        $obj = req()->paras[0];                                                  // 获取物品的结构数组  
         foreach ($obj as $value) {
             $type = $value[0];
             $itemId = $value[1];
-////先判断一下物品类型，如果是可叠加的，就按数量取值，如果是不可叠加的就按uid取值
+
             if ($type > 3) {
                 $count = intval($value[2]);  // 数量
                 $uid = 0;
-            } else {
+            } else {          ////先判断一下物品类型，如果是可叠加的，就按数量取值，如果是不可叠加的就按uid取值
                 $count = 1;
                 $uid = $value[2];
             }//物品的uid
-            $resp = StoreProc:: preSellSingleFromStore($req, $type, $itemId, $count, $uid);
+            $resp = StoreProc:: preSellSingleFromStore($type, $itemId, $count, $uid);
         }
 
         if (0 == $resp->err) {
             UserProc::updateUserInfo();
         }
 
-        StoreProc::CheckItemNum($req);
+        StoreProc::CheckItemNum();
         return $resp;
     }
 

Gameserver/Amfphp/process/SystemProc.php

@@ -79,15 +79,15 @@ class SystemProc {
      * @return type
      */
     static function procMain($req) {
-        switch ($req->cmd) {
+        switch (req()->cmd) {
             case CmdCode::cmd_system_userSendsysmessage:                        # 6904 玩家发送系统广播
-                return self::userPushSysMessage($req);
+                return self::userPushSysMessage();
             case CmdCode::cmd_system_getsysmessage:                             # 6901 拉取系统消息
-                return self::getSysMessage($req);
+                return self::getSysMessage();
             case CmdCode::cmd_system_logreport:                                 # 6902 客户端上报日志
-                return self::logReport($req);
+                return self::logReport();
             case CmdCode::cmd_system_clienttick:                                # 6903 客户端心跳包 
-                return self::clientTick($req);
+                return self::clientTick();
             default :
                 return Resp::err(ErrCode::cmd_err);
         }
@@ -98,33 +98,30 @@ class SystemProc {
 //
 
     /**
-     * 客户端心跳包
-     * @param Req $req
+     * [6903] 客户端心跳包 
      */
-    static function clientTick($req) {
-        $timespan = now() - $req->userInfo->game->baseInfo->lastSaveTs;
+    static function clientTick() {
+        $timespan = now() - req()->userInfo->game->baseInfo->lastSaveTs;
         if ($timespan < 300) {                                                  # 间隔超过5分钟的不算
             if ($timespan < 30) {                                               # 心跳包固定30秒1次
                 $timespan = 30;
             }
-            $req->userInfo->game->privateState->onlineGiftts += $timespan;
+            req()->userInfo->game->privateState->onlineGiftts += $timespan;
             UserProc::updateUserInfo();
         }
         return Resp::ok();
     }
 
     /**
-     * 客户端日志上报
-     * @param Req $req
-     * @return type
+     * [6902] 客户端日志上报 
      */
-    static function logReport($req) {
+    static function logReport() {
         $max = 300;
         $once = 30;
         $key = "report-log";
-        $log = $req->paras[0];                                                  # 客户端参数解析: 本地日志
+        $log = req()->paras[0];                                                 # 客户端参数解析: 本地日志
         $logItem = array(#                                                      # 组装对象
-            'uid' => $req->uid,
+            'uid' => req()->uid,
             'log' => $log,
             'ts' => TimeUtil::dtCurrent()
         );
@@ -169,16 +166,15 @@ class SystemProc {
     }
 
     /**
-     * [6901]获取系统广播消息列表
-     * @param Req $req
+     * [6901]获取系统广播消息列表 
      */
-    static function getSysMessage($req) {
+    static function getSysMessage() {
         //客户端参数解析
-        $ts = $req->paras[0];                                                   # 消息列表有效时间戳
+        $ts = req()->paras[0];                                                   # 消息列表有效时间戳
         $defaultwaitcont = 60;                                                  # 暂时使用60秒作为频率,若是有压力就调大些. 若是没有问题,可以调小些.
         $itemDisplayTime = 7;                                                   # 7秒显示完一条消息
 
-        $sysMessage = self::mem_getSysMsg_zset($req->zoneid, $ts);
+        $sysMessage = self::mem_getSysMsg_zset(req()->zoneid, $ts);
 
         $count = count($sysMessage) * $itemDisplayTime;                         # 计算下次取消息的时间
         if ($count < $defaultwaitcont) {                                        # 最低刷新时间
@@ -193,13 +189,12 @@ class SystemProc {
     }
 
     /**
-     * [6904]玩家发送系统广播消息
-     * @param Req $req
+     * [6904]玩家发送系统广播消息 
      */
-    static function userPushSysMessage($req) {
-        list($msg, $type) = $req->paras;                                        # 提取参数: 消息内容, 消耗道具类型,1:钻石,2:xx
-        $user = $req->userInfo->game;
-        $uid = $req->uid;
+    static function userPushSysMessage() {
+        list($msg, $type) = req()->paras;                                        # 提取参数: 消息内容, 消耗道具类型,1:钻石,2:xx
+        $uid = req()->uid;
+        $user = req()->userInfo->game;
         $cost = 0;                                                              // 花费
         switch ($type) {
             case 1:                                                             # 钻石
@@ -210,7 +205,7 @@ class SystemProc {
             default :
                 Err(ErrCode::paras_err);                                        // 其他类型:参数非法
         }
-        self::pushSysMessage($req->zoneid, #
+        self::pushSysMessage(req()->zoneid, #
                 SysMessageType::UserSendMessage, array($uid, $user->name, $msg));
         UserProc::updateUserInfo();                                             // 回存账号数据
         return Resp::ok(array('ret' => "succeed"));                             # 返回值

Gameserver/Amfphp/process/TaskProc.php

@@ -21,8 +21,8 @@ class TaskProc {
      */
     const TaskCardShop_Refresh_ItemNum = 5;
 
-    static function procMain($req) {
-        switch ($req->cmd) {
+    static function procMain() {
+        switch (req()->cmd) {
             case CmdCode::cmd_task_getInfo:                                     # 6201 刷新任务状态
                 return TaskProc::GetTaskInfo();
             case CmdCode::cmd_task_getReward:                                   # 6202 领取任务奖励
@@ -118,7 +118,7 @@ class TaskProc {
                 break;
         }
 
-        $cid = StoreProc::PutTaskCardInStore($typeId, req());                    # 添加任务卡到背包
+        $cid = StoreProc::PutTaskCardInStore($typeId);                          # 添加任务卡到背包
         $userInfo->taskCardShop->selled[] = $typeId;                            # 添加售罄记录
         UserProc::updateUserInfo();
 
@@ -226,7 +226,7 @@ class TaskProc {
                 } else if (strtolower($plot->presentItem) == strtolower("zhaohuanyanling")) {
                     // 跳过特殊指令
                 } else {                                                        # 普通奖励
-                    StoreProc::AddMultiItemInStore(req(), $plot->presentItem);
+                    StoreProc::AddMultiItemInStore($plot->presentItem);
                 }
             }
             if (!empty($plot->recycleItem)) {
@@ -370,7 +370,7 @@ class TaskProc {
             }
         }
         if (strlen($taskCard->mo()->reward) > 0) {                              # 防御奖励串为空
-            StoreProc::AddMultiItemInStore(req(), $taskCard->mo()->reward);      # 发放奖励
+            StoreProc::AddMultiItemInStore($taskCard->mo()->reward);      # 发放奖励
         }
         if ($taskCard->mo()->exp > 0) {                                         # 任务卡增加了指挥官经验
             Data_UserGame::Add_Exp(req()->userInfo->game->baseInfo, $taskCard->mo()->exp);
@@ -385,7 +385,7 @@ class TaskProc {
         NormalEventProc::OnTaskCard_Reward($taskCard->mo()->reward, null);      # 带入事件
         self::OnFinishTaskCard();                                               # 触发检查任务卡的任务卡[・_・?]
         if (!empty($taskCard->mo()->newTaskCard)) {                             # 下一个任务卡存在  
-            StoreProc::PutTaskCardInStore($taskCard->mo()->newTaskCard, req());  # 放卡入背包
+            StoreProc::PutTaskCardInStore($taskCard->mo()->newTaskCard);        # 放卡入背包
         }
         StlUtil::dictRemove(req()->userInfo->game->store->taskcards, $taskCardUID); # 移除任务卡           
         req()->userInfo->game->store = $store;
@@ -442,7 +442,7 @@ class TaskProc {
         my_Assert(null != $rewardCfg, ErrCode::err_const_no);                   # 防御: 常量丢失
         my_Assert(!in_array($num, $userTask->dailyActiveGetedRewardArr), ErrCode::task_reward_geted); # 判断尚未领取
         my_Assert($userTask->dailyActivePoint >= $num, ErrCode::task_activePoint_notenough);          # 判断活跃点数足够
-        $ok = StoreProc::AddMultiItemInStore(req(), $rewardCfg->reward);         # 按照配置发放奖励
+        $ok = StoreProc::AddMultiItemInStore($rewardCfg->reward);         # 按照配置发放奖励
         my_Assert($ok == ErrCode::ok, $ok);                                     # 发放成功
         $userTask->dailyActiveGetedRewardArr[] = $num;                          # 添加领取记录
         UserProc::updateUserInfo();                                             # 回存数据
@@ -487,7 +487,7 @@ class TaskProc {
                 my_Assert($task->rewardGeted < 1, ErrCode::task_reward_geted);          # 奖励不可重复领取
                 $taskCfg = GameConfig::task_getItem($taskId);                           # 任务配置数据
                 my_Assert($taskCfg != null, ErrCode::err_const_no);
-                $ok = StoreProc::AddMultiItemInStore(req(), $taskCfg->reward);           # 发放任务奖励
+                $ok = StoreProc::AddMultiItemInStore($taskCfg->reward);           # 发放任务奖励
                 my_Assert($ok == ErrCode::ok, $ok);
                 $task->rewardGeted = 1;
                 $userTask->taskListPlot->$taskId = $task;
@@ -534,10 +534,9 @@ class TaskProc {
 // </editor-fold>
 
     /**
-     * 重置每日任务
-     * @param Req $req
+     * 重置每日任务 
      */
-    static function ResetDailyTask($req) {
+    static function ResetDailyTask() {
         return;
         $userTask = new Info_UserTask(req()->userInfo->game->task);
         $userTask->resetDailyTask();
@@ -837,8 +836,7 @@ class TaskProc {
     // 
 
     /**
-     * 自动修复状态型任务
-     * @param RequestVo $req
+     * 自动修复状态型任务 
      */
     static function autoRecoverStateMissions() {
         $tasks = req()->userInfo->game->store->taskcards;

Gameserver/Amfphp/process/UserProc.php

@@ -19,29 +19,29 @@ class UserProc {
     public static function procMain($req) {
         switch ($req->cmd) {
             case CmdCode::cmd_user_getzonelist:                                 # 6000 分区列表
-                return UserProc::GetZoneList($req);
+                return UserProc::GetZoneList();
             case CmdCode::cmd_user_loginuserinfo:                               # 6001 登录
-                return UserProc::loginUserInfo($req);
+                return UserProc::loginUserInfo();
             case CmdCode::cmd_user_gameconstinfo:                               # 6002 下载游戏配置
-                return UserProc::downloadConstInfo($req);
+                return UserProc::downloadConstInfo();
             case CmdCode::cmd_user_acceptcontidaysgift:                         # 6003 领取连续登陆奖励
-                return UserProc::acceptContiDaysGift($req);
+                return UserProc::acceptContiDaysGift();
             case CmdCode::cmd_user_registerNewRole:                             # 6006 注册新角色
-                return UserProc::RegisterNewRole($req);
+                return UserProc::RegisterNewRole();
             case CmdCode::cmd_user_completeNewbieGuide:                         # 6007 提交新手引导步骤
-                return UserProc::completeNewbieGuide($req);
+                return UserProc::completeNewbieGuide();
 //            case CmdCode::cmd_user_setNewbieGuideCards:                         # 6008 发放新手引导所需卡牌
 //                return self::SetNewbieGuideCards($req);                
             case CmdCode::cmd_user_setNewbieGuideOver:                          # 6009 跳过新手引导
-                return UserProc::setNewbieGuideOver($req);
+                return UserProc::setNewbieGuideOver();
             case CmdCode::cmd_user_setNickname:                                 # 6010 设置/修改玩家昵称
-                return self::SetUserNickname($req);
+                return self::SetUserNickname();
             case CmdCode::cmd_user_SetUserHeadImageBorder:                      # 6011 修改玩家头像框
-                return self::SetUserImageBorder($req);
+                return self::SetUserImageBorder();
             case CmdCode::cmd_user_setUserImage:                                # 6012 更换玩家形象
-                return self::SetUserImage($req);
+                return self::SetUserImage();
             case CmdCode::cmd_user_changeUserHeadImg:                           # 6013 更换玩家头像
-                return self::SetUserHeadImage($req);
+                return self::SetUserHeadImage();
             default:
                 Err(ErrCode::cmd_err);
         }
@@ -51,54 +51,50 @@ class UserProc {
 // <editor-fold defaultstate="collapsed" desc="玩家信息 修改">
 
     /**
-     * [6013]修改玩家头像
-     * @param Req $req
+     * [6013]修改玩家头像 
      */
-    static function SetUserHeadImage($req) {
-        list($headImage) = $req->paras;                                         # 参数, 新头像
-        $req->userInfo->game->baseInfo->headImg = $headImage;
+    static function SetUserHeadImage() {
+        list($headImage) = req()->paras;                                         # 参数, 新头像
+        req()->userInfo->game->baseInfo->headImg = $headImage;
         UserProc::updateUserInfo();
         return Resp::ok(array('ret' => 'ok'));
     }
 
     /**
-     * [6012]修改玩家形象
-     * @param Req $req
+     * [6012]修改玩家形象 
      */
-    static function SetUserImage($req) {
-        list($image) = $req->paras;                                             # 参数, 新形象
-        $req->userInfo->game->baseInfo->img = $image;
+    static function SetUserImage() {
+        list($image) = req()->paras;                                             # 参数, 新形象
+        req()->userInfo->game->baseInfo->img = $image;
         UserProc::updateUserInfo();
         return Resp::ok(array('ret' => 'ok'));
     }
 
     /**
-     * [6011]修改玩家头像框
-     * @param Req $req
+     * [6011]修改玩家头像框  
      */
-    static function SetUserImageBorder($req) {
-        list($imgborderId) = $req->paras;                                       # 参数, 新头像框ID
-        $req->userInfo->game->baseInfo->imgBorderId = $imgborderId;
+    static function SetUserImageBorder() {
+        list($imgborderId) = req()->paras;                                       # 参数, 新头像框ID
+        req()->userInfo->game->baseInfo->imgBorderId = $imgborderId;
         UserProc::updateUserInfo();
         return Resp::ok(array('ret' => 'ok'));
     }
 
     /**
-     * [6010] 设置/修改玩家昵称
-     * @param Req $req
+     * [6010] 设置/修改玩家昵称 
      */
-    static function SetUserNickname($req) {
-        list($newname) = $req->paras;                                           # 参数: 新昵称, 头像
+    static function SetUserNickname() {
+        list($newname) = req()->paras;                                           # 参数: 新昵称, 头像
         my_Assert(isset(glc()->User_SetNickname_Cost), "全局变量中未找到改名消耗钻石数量的配置字段");
         $amt = glc()->User_SetNickname_Cost;                                    # 改名需要消耗钻石
-        $ok = Data_UserGame::Consume_Cash($req->userInfo->game->baseInfo, $amt); # 扣除钻石
+        $ok = Data_UserGame::Consume_Cash(req()->userInfo->game->baseInfo, $amt); # 扣除钻石
         my_Assert($ok, ErrCode::notenough_cash_msg);
         my_Assert(self::checkRoleNameNotExist($newname), ErrCode::user_nicknameexist); # 昵称已存在
-        $req->userInfo->game->baseInfo->name = $newname;
+        req()->userInfo->game->baseInfo->name = $newname;
         daoInst()->update(self::role_Table)
                 ->data(array('roleName' => $newname))
-                ->where('userID')->eq($req->uid)
-                ->andWhere('zoneid')->eq($req->zoneid)
+                ->where('userID')->eq(req()->uid)
+                ->andWhere('zoneid')->eq(req()->zoneid)
                 ->exec();
         UserProc::updateUserInfo();
         return Resp::ok(array('ret' => 'ok'));
@@ -109,21 +105,20 @@ class UserProc {
 // <editor-fold defaultstate="collapsed" desc="新手引导">
 
     /**
-     * [6009] 新手引导 发送n张碎片到玩家身上
-     * @param Req $req
+     * [6009] 新手引导 发送n张碎片到玩家身上 
      */
-    static function SetNewbieGuideCards($req) {
+    static function SetNewbieGuideCards() {
         Err(ErrCode::function_notopen_msg);                                     # 功能已经废弃 -wg
-        $private = $req->userInfo->game->privateState;
+        $private = req()->userInfo->game->privateState;
         if (!property_exists($private, 'newbieguideCards')) {                   # 逻辑检查, 是否已经发放过
             $private->newbieguideCards = true;
-            $req->userInfo->game->privateState = $private;                      # 回写私有数据
+            req()->userInfo->game->privateState = $private;                      # 回写私有数据
             $sp = explode(';', glc()->User_SetNewbieGuideCards);                # 碎片
             foreach ($sp as $cardinfo) {
                 $arr = explode(',', $cardinfo);
                 $itemid = $arr[0];
                 $num = $arr[1];
-                StoreProc::addSegmentIntoStore($req->userInfo->game->store, $itemid, $num);
+                StoreProc::addSegmentIntoStore(req()->userInfo->game->store, $itemid, $num);
             }
             $exp = explode(';', glc()->User_SetNewbieGuideExps);                # 经验卡
             foreach ($exp as $expinfo) {
@@ -133,22 +128,21 @@ class UserProc {
                 StoreProc::PutOverlyingItemInStore($itemid, $num);
             }
             UserProc::updateUserInfo();                                         # 回存玩家数据
-            return Resp::ok(array('store' => $req->userInfo->game->store));
+            return Resp::ok(array('store' => req()->userInfo->game->store));
         }
         return Resp::err(ErrCode::active_hasgetted);
     }
 
     /**
-     * [6011] 增加 设置引导结束的标志位
-     * @param type $req
+     * [6011] 增加 设置引导结束的标志位 
      */
-    public static function setNewbieGuideOver($req) {
-        $user = new Data_UserGame($req->userInfo->game);                        # user
+    public static function setNewbieGuideOver() {
+        $user = new Data_UserGame(req()->userInfo->game);                        # user
         if (!CommUtil::isPropertyExists($user, "NewbieGuideOver")) {            # 防御: 变量未初始化
             $user->NewbieGuideOver = 1;
         }
         $user->NewbieGuideOver = 1;
-        $req->userInfo->game = $user;
+        req()->userInfo->game = $user;
         UserProc::updateUserInfo();                                         # 回写数据
         return Resp::ok(array(#                                                 # 返回值
                     'result' => "succeed"
@@ -157,12 +151,11 @@ class UserProc {
 
     /**
      * [6007] 更新初始的强制的新手引导阶段步骤
-     * 第一阶段的引导
-     * @param Req $req
+     * 第一阶段的引导 
      */
-    public static function completeNewbieGuide($req) {
-        $guideIndex = $req->paras[0];                                           # 参数: 新手引导步骤
-        $user = new Data_UserGame($req->userInfo->game);                        # user
+    public static function completeNewbieGuide() {
+        $guideIndex = req()->paras[0];                                           # 参数: 新手引导步骤
+        $user = new Data_UserGame(req()->userInfo->game);                        # user
         if (!CommUtil::isPropertyExists($user, "NewbieGuide")) {                # 防御: 变量未初始化
             $user->NewbieGuide = ObjectInit();
         }
@@ -183,10 +176,10 @@ class UserProc {
         }
         $NewbieGuide->guideStep = $guideIndex;
         $user->NewbieGuide = $NewbieGuide;
-        $req->userInfo->game = $user;
+        req()->userInfo->game = $user;
         UserProc::updateUserInfo();                                             # 回写数据
         return Resp::ok(array(
-                    "store" => $req->userInfo->game->store, #                   # 目前来看只涉及到items变化
+                    "store" => $user->store, #                                  # 目前来看只涉及到items变化
                     "heros" => $user->heros, #                                  # 英雄数据
         ));
     }
@@ -195,19 +188,18 @@ class UserProc {
 //
 
     /**
-     * 6006 注册新角色
-     * @param Req $req
+     * 6006 注册新角色 
      */
-    public static function RegisterNewRole($req) {
-        $userID = $req->uid;
-        list($rolename, $gender, $profile_img) = $req->paras;                   # 参数: 昵称,性别,头像
-        $id = gMem()->increment(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid));   # 增加玩家数量计数
-        $rolename = "No." . sprintf("%03d", $req->zoneid) . sprintf("%07d", $id); # 生成编号
+    public static function RegisterNewRole() {
+        $userID = req()->uid;
+        list($rolename, $gender, $profile_img) = req()->paras;                   # 参数: 昵称,性别,头像
+        $id = gMem()->increment(MemKey_GameRun::Stat_UserCountByZone_int(req()->zoneid));   # 增加玩家数量计数
+        $rolename = "No." . sprintf("%03d", req()->zoneid) . sprintf("%07d", $id); # 生成编号
         if (self::checkRoleNameNotExist($rolename)) {                           # 记录玩家
-            $userinfo = self::createUser($req, $rolename, $gender, $profile_img);
-            if (1 == self::regRole($req->zoneid, $userID, $rolename, $gender, $profile_img, $userinfo->getPlatStr())) {
+            $userinfo = self::createUser($rolename, $gender, $profile_img);
+            if (1 == self::regRole(req()->zoneid, $userID, $rolename, $gender, $profile_img, $userinfo->getPlatStr())) {
                 $resp = Resp::ok($userinfo);
-                self::updtateUserZoneInfo($req);
+                self::updtateUserZoneInfo();
             } else {
                 $resp = Resp::err(ErrCode::err_db);
             }
@@ -219,14 +211,13 @@ class UserProc {
     }
 
     /**
-     * 6000 【移动端】 获取分区列表
-     * @param Req $req
+     * 6000 【移动端】 获取分区列表 
      */
-    public static function GetZoneList($req) {
+    public static function GetZoneList() {
         $defaultZone = new Ins_ZoneInfo(1, 0, "");                             # 新用户默认分区
         $bGetRecommended = false;
-        if (count($req->paras) > 0) {                                           # 是否只拉取推荐分区
-            $bGetRecommended = $req->paras[0];
+        if (count(req()->paras) > 0) {                                           # 是否只拉取推荐分区
+            $bGetRecommended = req()->paras[0];
         }
         $zoneList = array();
         $ts = now();
@@ -247,10 +238,10 @@ class UserProc {
             }
             unset($zone->isRecommended);
         }
-        UserProc::_AddTesterZonelist($req, $zoneList);                          # 添加测试分区
+        UserProc::_AddTesterZonelist($zoneList);                                # 添加测试分区
 #
 // <editor-fold defaultstate="collapsed" desc="    取玩家分区记录    ">
-        $userZoneInfo = self::getUserZoneInfo($req);                            # 玩家分区记录
+        $userZoneInfo = self::getUserZoneInfo();                                # 玩家分区记录
         $isNewUser = false;
         if ($userZoneInfo == null) {           // 这里使用推荐分区的数据，推荐分区信息，在后台编辑，编辑器可用
             $userZoneInfo = new Data_UserZoneInfo();
@@ -279,19 +270,18 @@ class UserProc {
         return Resp::ok($ret);                                                  # 返回值
     }
 
-    private static function _AddTesterZonelist($req, &$zoneList) {
-        if (config::Inst()->isTester($req->uid)) {                              # 添加测试分区
+    private static function _AddTesterZonelist(&$zoneList) {
+        if (config::Inst()->isTester(req()->uid)) {                              # 添加测试分区
             $zoneList[] = array('zoneid' => 999, 'name' => '内测专区', 'status' => 2, 'publicTs' => 0);
         }
     }
 
     /**
-     * 6002 客户端下载常量配置信息
-     * @param Req $req
+     * 6002 客户端下载常量配置信息 
      * @return type
      */
-    public static function downloadConstInfo($req) {
-        list($clientDataVer) = $req->paras;                                     # 客户端数据版本号,程序版本号
+    public static function downloadConstInfo() {
+        list($clientDataVer) = req()->paras;                                     # 客户端数据版本号,程序版本号
         $serverVer = GameConfig::ver();                                         # 最新数据版本号
         my_Assert($serverVer, ErrCode::err_const_no);                           # 找不到常量数据
         if ($clientDataVer == $serverVer) {                                         # 如果版本一致，数据体抹掉，只传回版本号
@@ -307,35 +297,33 @@ class UserProc {
     }
 
     /**
-     * 6001 客户端登录并返还玩家信息
-     * @param Req $req
+     * 6001 客户端登录并返还玩家信息 
      * @return Resp
      */
-    public static function loginUserInfo($req) {
-        $userInfo = UserProc::getUserInfo($req->zoneid, $req->uid);     # 取玩家信息
+    public static function loginUserInfo() {
+        $userInfo = UserProc::getUserInfo(req()->zoneid, req()->uid);     # 取玩家信息
         if ($userInfo == null) {                                                # 新用户, -> 6006创建账号
             $ret = array(
                 'isNewUser' => true
             );
             return Resp::ok($ret);
         } else {                                                                # 2.如果玩家已存在，则处理普通登录流程
-            $req->userInfo = $userInfo;                                         # 给Req挂载userInfo
-            UserProc::checkContidays($req);                                     # 连续登录,状态检查
-            PayProc::m_refreshChargeOrders($req);                               # 刷新订单, 多平台版本
-            PayProc::checkDeltest($req);                                        # 检查内侧充值记录(函数内部会只检查一次)
+            req()->userInfo = $userInfo;                                         # 给Req挂载userInfo
+            UserProc::checkContidays();                                     # 连续登录,状态检查
+            PayProc::m_refreshChargeOrders();                                   # 刷新订单, 多平台版本
+            PayProc::checkDeltest();                                        # 检查内侧充值记录(函数内部会只检查一次)
             UserProc::updateUserInfo();                                         # 这一步回存操作只有在 userInfo正常存在的情况下才进行
             $resp = Resp::ok($userInfo);                                        # 设置返回值
-            self::backupUserInfo($req);                                         # 数据回写
-            self::updtateUserZoneInfo($req);                                    # 1. 更新玩家分区记录
+            self::backupUserInfo();                                         # 数据回写
+            self::updtateUserZoneInfo();                                    # 1. 更新玩家分区记录
         }
         return $resp;
     }
 
     /**
-     * 6003 领取连续登录奖励
-     * @param Req $req
+     * 6003 领取连续登录奖励 
      */
-    public static function acceptContiDaysGift($req) {
+    public static function acceptContiDaysGift() {
         $resp = Resp::err(ErrCode::err_method_notimplement);
 
         return $resp;
@@ -379,49 +367,45 @@ class UserProc {
     }
 
     /**
-     * 检测连续登录状态，重置必要字段[时间戳自动记录]
-     * @param Req $req
+     * 检测连续登录状态，重置必要字段[时间戳自动记录] 
      */
-    static function checkContidays($req, $isnew = 0) {
-        $ret = TimeUtil::tsDay() - TimeUtil::tsDay($req->userInfo->game->baseInfo->lastLogin); // 对比登录日期
+    static function checkContidays($isnew = 0) {
+        $ret = TimeUtil::tsDay() - TimeUtil::tsDay(req()->userInfo->game->baseInfo->lastLogin); // 对比登录日期
         if ($ret > 0) {                                                         # 当天第一次登录
-            self::OnNewDay($req, $isnew);
-        } else {
-# 更新下登录次数记录(任务计数器)
+            self::OnNewDay($isnew);
+        } else {                                                                # 更新下登录次数记录(任务计数器)
         }
         if ($ret == 1) {                                                        # 连续登录
         } else if ($ret >= 2) {                                                 # 隔天登录
         }
-        $req->userInfo->game->baseInfo->lastLogin = now();                                # 更新下访问时间
-        TaskProc::ResetDailyTask($req);                                         # 重置每日任务
+        req()->userInfo->game->baseInfo->lastLogin = now();                     # 更新下访问时间
+        TaskProc::ResetDailyTask();                                             # 重置每日任务
         TaskProc::OnUserLogin();
         return $ret;
     }
 
     /**
-     *  处理当天第一次登录
-     * @param RequesstVo $req
+     *  处理当天第一次登录 
      * @param bool $isnew Description
      */
-    static function OnNewDay($req, $isnew) {
-        self::updatePlatUserRecord($req, $isnew);                               # 添加到到当天活跃玩家记录集合
-        ActiveProc::DailyReset($req);                                           # 抽奖、每日任务状态,计数器...
-        FightProc::ClearByDay($req);                                            # 战斗相关状态每日清理
-        ShopProc::DailyCheck($req);
+    static function OnNewDay($isnew) {
+        self::updatePlatUserRecord($isnew);                               # 添加到到当天活跃玩家记录集合
+        ActiveProc::DailyReset();                                               # 抽奖、每日任务状态,计数器...
+        FightProc::ClearByDay();                                                # 战斗相关状态每日清理
+        ShopProc::DailyCheck();
     }
 
 // <editor-fold defaultstate="collapsed" desc="创建新用户">
 
     /**
-     * 创建用户
-     * @param Req $req
+     * 创建用户 
      * @return UserInfoMo
      */
-    static function createUser($req, $rolename, $gender, $profile_img) {
+    static function createUser($rolename, $gender, $profile_img) {
         $userInfo = new UserInfoMo();
-        $req->userInfo = $userInfo;                                             # 更新Req的userinfo,
-        $userInfo->uid = $req->uid;
-        $userInfo->zoneid = $req->zoneid;
+        req()->userInfo = $userInfo;                                             # 更新Req的userinfo,
+        $userInfo->uid = req()->uid;
+        $userInfo->zoneid = req()->zoneid;
         $userInfo->game = new Data_UserGame();
         $userInfo->game->initialize();                                          # 初始化玩家数据
         $userInfo->game->baseInfo->name = $rolename;
@@ -432,7 +416,7 @@ class UserProc {
 //        $userInfo->game->NewbieGuideOver = 1;
 //        UserProc::_intiHeroManual($userInfo->game);                             # 初始化图鉴 
 #Ps 6006是没有获得到Userinfo到Req中的
-        UserProc::checkContidays($req, 1);                                      # 每日状态检查
+        UserProc::checkContidays(1);                                            # 每日状态检查
 //        UserProc::fetchFromInteract($mem, $req);  # 从interact拉取数据，Ps.初始化的过程应该还拉取不到什么有效数据
         UserProc::updateUserInfo();                                         # 回存用户数据
 //        FriendProc::Init($req);
@@ -443,14 +427,13 @@ class UserProc {
     }
 
     /**
-     * 整理平台玩家记录集
-     * @param Req $req
+     * 整理平台玩家记录集 
      * @param int $isnew
      */
-    private static function updatePlatUserRecord($req, $isnew = 0) {
-        $zoneid = $req->zoneid;
-        $uid = $req->uid;
-        $user = $req->userInfo->game->baseInfo;
+    private static function updatePlatUserRecord($isnew = 0) {
+        $zoneid = req()->zoneid;
+        $uid = req()->uid;
+        $user = req()->userInfo->game->baseInfo;
         $day = tsDay();
         $level = $user->level;
         $platUser = ObjectInit();
@@ -522,12 +505,11 @@ class UserProc {
 // <editor-fold defaultstate="collapsed" desc="玩家分区记录">
 
     /**
-     * 读取玩家的分区记录
-     * @param Req $req
+     * 读取玩家的分区记录 
      * @return Data_UserZoneInfo Description
      */
-    public static function getUserZoneInfo($req) {
-        $ret = gMem()->get(MemKey_User::Union_PlayedZoneInfo_normal($req->uid));
+    public static function getUserZoneInfo() {
+        $ret = gMem()->get(MemKey_User::Union_PlayedZoneInfo_normal(req()->uid));
         return $ret;
     }
 
@@ -536,7 +518,7 @@ class UserProc {
      */
     public static function updtateUserZoneInfo() {
         $req = req();
-        $userZoneInfo = self::getUserZoneInfo($req);                            # 取玩家分区记录
+        $userZoneInfo = self::getUserZoneInfo();                                # 取玩家分区记录
         if (!$userZoneInfo) {
             $userZoneInfo = new Data_UserZoneInfo;
         }
@@ -571,13 +553,12 @@ class UserProc {
      *           version 2.0.0 Redis storage 从MySQL转到Redis中存储. 这个备份数据没有大规模导出硬盘的需求
      *                      因为mysql版本实在是负载太大了, 上百毫秒. 所以改在redis中了.
      *           version 1.0.0 Mysql storagef 1. 分表不做了, 2. 存储过程不用了 3. 先能用再说
-     * @param Req $req
      */
-    public static function backupUserInfo($req) {
+    public static function backupUserInfo() {
         $tsday = TimeUtil::tsDay();                                             # 精确到天,保留10个最近记录.
-        $value = base64_encode(gzdeflate(JsonUtil::encode($req->userInfo)));    # blob数据,序列化下
+        $value = base64_encode(gzdeflate(JsonUtil::encode(req()->userInfo)));    # blob数据,序列化下
         $sql = sprintf("call insertUserInfo('%s', %d, %d, '%s');", #            # 所以直接将序列化后的结果存进去吧,
-                $req->uid, $req->zoneid, $tsday, $value);                       # zoneid, uid, tsday
+                req()->uid, req()->zoneid, $tsday, $value);                       # zoneid, uid, tsday
         daoInst()->exec($sql);                                                  # 也可以用exec($sql)
     }
 

Gameserver/Amfphp/test.php

@@ -22,5 +22,11 @@ $i = 9;
 
 var_dump($i++);
 var_dump($i);
+$user = ObjectInit();
 
-var_dump(Resp::err(3503, "时尚杂志opencv"));
+my_default_Obj($user->heros->recordUnLockHeroDic);
+//if (!CommUtil::isPropertyExists($user->heros, "recordUnLockHeroDic")) {
+//    $user->heros->recordUnLockHeroDic = ObjectInit();
+//}
+var_dump($user);
+//var_dump(Resp::err(3503, "时尚杂志opencv"));