server/Gameserver/Amfphp/process/HeroProc.php

<?php

namespace loyalsoft;

/**
 * 英雄处理逻辑
 * @author gwang
 */
class HeroProc {

    /**
     * 英雄处理逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::cmd_hero_levelup:                                     #  [6301] 英雄升级
                return HeroProc::HeroLevelUpCostExpItem($req);
            case CmdCode::cmd_hero_stageup:                                     #  [6304] 英雄进阶 SABCD
                return HeroProc::HeroStageUp($req);
            // <editor-fold defaultstate="collapsed" desc="过时 接口">
//            case CmdCode::cmd_hero_upstar:                                    #  [6305] 英雄升星
//                return HeroProc::HeroUpStarByPieces($req);
//            case CmdCode::cmd_hero_changelockstate:                           #  [6306] 英雄-修改锁定状态
//                return HeroProc::HeroChangelockstate($req); 
//            case CmdCode::cmd_hero_buyCollectHeroLimtCount:                   #  [6312] 扩展英雄数量上限
//                return HeroProc::BuyHeroMaxCountLimt($req); 
            // </editor-fold>
# --------- 英雄技能 -----------                
            case CmdCode::cmd_hero_upgradeSkillLevel:                           #  [6314] 英雄的技能升级
                return HeroProc::UpgradeSkillLevel($req);
            case CmdCode::cmd_hero_unlockSkill:                                 #  [6324] 英雄技能 - 解锁技能 
                return HeroProc::UnlockSkill($req);
            case CmdCode::cmd_hero_skillLevel_onekeyupgrade:                    #  [6325] 英雄技能 - 一键升级
                return HeroProc::OnekeyUpgradeSkillLevel($req);
            case CmdCode::cmd_hero_saveHeroTeamConfig:                          #  [6315] 保存玩家战队数据
                return HeroProc::SaveHeroTeamConfig($req);

            // <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] 升星
                return HeroProc::StrengthenStar($req);
//            case CmdCode::cmd_hero_unlockByPieces:                            #  [6323] 解锁碎片
//                return HeroProc::UnLockHeroByPieces($req);                

            default:                                                            #  err: 未知的命令码
                return Resp::err(ErrCode::cmd_err);
        }
    }

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

    /**
     * [6324] 英雄技能解锁 
     * @version  2020.1.13  至今未进行对接, 再次整理版
     *            2019.12.10 加班弄完第一版
     * @param req $req
     */
    static function UnlockSkill($req) {
        list($huid, $mainSkillId, $subSkillId) = $req->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能ID 

        $user = $req->userInfo->game;                                           # user引用 
        $cHeros = $user->heros->collectHeros;
        my_default_Obj($cHeros);
        my_Assert(CommUtil::isPropertyExists($cHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要解锁的英雄
#                                                                               # 2.判断英雄的该技能能否升级.... 
        $targetHero = new Ins_UserHero($cHeros->$huid);                        # 直接类型识别 
        $targteHeroSkills = $targetHero->subSkills;                             # 取出这个英雄的技能数据 
        my_default_Arr($targteHeroSkills->$mainSkillId);                        # 保护子技能数组数据结构
        my_Assert(!CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能已解锁"); # 子技能已经解锁
//        if (!$targetHero->IsSkillUnlockAble($mainSkillId, $subSkillId)) {       # 3.判断技能是否处于待解锁状态
//            return Resp::err(ErrCode::hero_upgradeSkill_maxLevel);
//        }

        $sm = GameConfig::subSkill_getItem($subSkillId);                        # 4.取出该技能升级消耗的常量数据
        my_Assert(null != $sm, ErrCode::err_const_no);                          # 找不到子技能配置数据 
        my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $sm->unlockCost), #        # 5. 扣除金币消耗
                ErrCode::notenough_gold_msg);
        array_push($targteHeroSkills->$mainSkillId, $subSkillId);               # 添加技能
        $targetHero->subSkills = $targteHeroSkills;
        $cHeros->$huid = $targetHero;                                           # 回存Hero对象
        UserProc::updateUserInfo();                                             # 回写数据
        TaskProc::OnHeroUnlocSkill($targetHero->typeId, $subSkillId);
        return Resp::ok($targetHero);
    }

    /**
     * [6325] 英雄技能一键升级
     * @param req $req
     */
    static function OnekeyUpgradeSkillLevel($req) {
        list($huid, $mainSkillId, $subSkillId, $targetSubSkillId, $costGold) = $req->paras; # 提取参数: 英雄的UID, 主技能ID, 要升级的子技能ID, 升级到的子技能ID, 升级要消耗的金币

        $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);                        # 直接类型识别
        $targteHeroSkills = $targetHero->subSkills;                            # 取出这个英雄的技能数据 
        my_default_Arr($targteHeroSkills->$mainSkillId);                       # 保护数据结构
        my_Assert(CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能id错误");     # 子技能id
//        if (!$targetHero->IsSkillUpdateAble($mainSkillId, $subSkillId)) {       # 3.判断技能等级能否在继续升级了
//            return Resp::err(ErrCode::hero_upgradeSkill_maxLevel);
//        }
//        $sm = GameConfig::subSkill_getItem($subSkillId);                        # 4.取出该技能升级消耗的常量数据
//        if (null == $sm) {
//            return \Resp::err(ErrCode::err_const_no, '找不到子技能配置数据');
//        }
        my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $costGold), ErrCode::notenough_gold_msg); # 5. 扣除金币消耗
        unset($targteHeroSkills->$mainSkillId, $subSkillId);                    # 替换技能
        array_push($targteHeroSkills->$mainSkillId, $targetSubSkillId);
        $targetHero->subSkills = $targteHeroSkills;
        $collectHeros->$huid = $targetHero;                                     # 更新Hero数据
        UserProc::updateUserInfo();                                             # 回写数据
        return Resp::ok($targetHero);
    }

    /**
     * [6314]英雄技能升级
     * @param req $req
     */
    static function UpgradeSkillLevel($req) {
        list($huid, $mainSkillId, $subSkillId) = $req->paras;                   # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能Id 
        $user = $req->userInfo->game;                                           # user引用

        $collectHeros = $user->heros->collectHeros;
        my_default_Obj($collectHeros);                                          # 防御变量为空
        my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no);   # 1.检查是否存在要升级的英雄
        $targetHero = new Ins_UserHero($collectHeros->$huid);
        $targteHeroSkills = $targetHero->subSkills;                             # 取出这个英雄的技能数据 
        my_Assert(CommUtil::isPropertyExists($targteHeroSkills, $mainSkillId), "玩家数据结构有问题.");     # 主技能Id.
        my_Assert(CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能id错误");     # 子技能id
        my_Assert($targetHero->IsSkillUpdateAble($mainSkillId, $subSkillId), ErrCode::hero_upgradeSkill_maxLevel);       # 3.判断技能等级能否在继续升级了

        $sm = GameConfig::subSkill_getItem($subSkillId);                        # 4.取出该技能升级消耗的常量数据
        my_Assert(null != $sm, ErrCode::err_const_no);                          # 找不到子技能配置数据
        my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $sm->upgradeCost), ErrCode::notenough_gold_msg);  # 5. 扣除金币消耗

        unset($targteHeroSkills->$mainSkillId, $subSkillId);                    # 替换技能
        array_push($targteHeroSkills->$mainSkillId, $sm->nextLevel_Id);
        $targetHero->subSkills = $targteHeroSkills;
        $collectHeros->$huid = $targetHero;                                     # 更新hero数据
        UserProc::updateUserInfo();                                             # 回写数据
        return Resp::ok($targetHero);
    }

// </editor-fold>
//
    // <editor-fold defaultstate="collapsed" desc="英雄 强化">

    /**
     * 6304 英雄 升阶(消耗碎片)
     * @param Req $req
     */
    static function HeroStageUp($req) {
        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.检查是否存在要升级的英雄 
        $upHero = new Ins_UserHero($collectHeros->$huid);                      # 直接类型识别
        my_Assert($upHero->grade < "S", ErrCode::hero_strength_maxstrengthlevel); # 已经达到S级 
        $heroUpgradeCostCfg = GameConfig::heroextra_level_getItem($upHero->typeId, $nextGrade);

        my_Assert($heroUpgradeCostCfg, ErrCode::hero_strength_cost_const_no);    # 1.检查是否存在这个升阶数据的模板
        my_Assert(Data_UserGame::Consume_HeroSegment($user, #                    # 扣除碎片  
                        $heroUpgradeCostCfg->segID, $heroUpgradeCostCfg->segNum), ErrCode::hero_segment_not_enough);                              # 碎片数量不足
        # 扣除碎片成功
        $upHero->grade = $nextGrade;                                            # 5.强化英雄进行成功升阶 
        $collectHeros->$huid = $upHero;                                         # 更新Hero数据
        UserProc::updateUserInfo();                                             # 6.数据回存
        $resp = Resp::ok($upHero);
        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); # 跟新战力统计
        TaskProc::OnHeroGradeUp($upHero->typeId, $upHero->grade);
//        var_dump($user->task->taskListDaily);
        return $resp;
    }

    /**
     * [6301] 英雄升级 - 消耗经验道具,获得经验(按照经验提升等级)
     * @param Req $req
     */
    static function HeroLevelUpCostExpItem($req) {
        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); # 参数合法性判断
        my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no); # 玩家拥有此英雄
        $targetHero = new Ins_UserHero($collectHeros->$huid);                  # 智能感知辅助
        my_Assert($targetHero->HeroCanLevelUp(), "英雄不可升级");                # 2. 检查玩家等级是否可以继续升级, Ps. 全局限制 + 指挥官等级限制
        $myPacketItems = $user->store->items;                                   # 检查道具的数量，在背包中是否充足
        my_Assert(CommUtil::isPropertyExists($myPacketItems, $costItemId), ErrCode::store_itemnotenough); # 
        my_Assert($myPacketItems->$costItemId >= $costNumber, ErrCode::store_itemnotenough);
        $totalEXP = 0;                                                          # 4.计算消耗的道具一共给多少经验值以及 一共要消耗多少金币 
        $costItemConst = GameConfig::item_stones_getItem($costItemId);
        my_Assert(null != $costItemConst, ErrCode::err_const_no);
        $totalEXP += $costItemConst->baseExp;
        $heroConst = GameConfig::hero_getItem($targetHero->typeId);             # 英雄模板数据
        my_Assert(null != $heroConst, ErrCode::err_const_no, "英雄 模板数据");
        if ($costItemConst->element != 0 #                                      # 相同元素加成
                && $costItemConst->element == $heroConst->element) {
            $totalEXP += $costItemConst->extraExp;
        }
        $totalEXP *= $costNumber;                                               # 消耗N个道具 
        $targetHero = self:: HeroAddEXP($huid, $totalEXP);                      # 获得经验 
        $myPacketItems->$costItemId -= $costNumber;                             # 消耗道具
        if ($myPacketItems->$costItemId < 0) {
            $myPacketItems->$costItemId = 0;
        }
        $req->userInfo->game->store->items = $myPacketItems;                    # 更新背包数据
        if ($targetHero->xp < 0) {
            Err(ErrCode::err_innerfault, "英雄经验出错");
        } else {
            UserProc::updateUserInfo();                                         # 回写玩家数据
            TaskProc::OnHeroImprove();
        }
//        var_dump($user->task->taskListDaily);
        self::CalcUserFightPower($req->zoneid, $req->uid, $req->userInfo->game); # 跟新战力统计
        return Resp::ok($targetHero);
    }

// </editor-fold>
// 
// <editor-fold defaultstate="collapsed" desc="队伍配置">

    /**
     * [6315]保存队伍的战斗配置信息
     * @param Req $req
     */
    static function SaveHeroTeamConfig($req) {
        $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);
        return Resp::ok(array('result' => "succeed"));
    }

// </editor-fold>
// 
// <editor-fold defaultstate="collapsed" desc="已过时代码">

    /**
     * 6323 解锁英雄
     * @param type $req
     */
    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)) {
            $recordUnLockHeroDic->$heroModelId = 0;
        }
        $flag = $recordUnLockHeroDic->$heroModelId;
        if ($flag == 1) {
            return Resp::err(ErrCode::hero_lockState);
        }
        #检查要解锁的英雄的常量配置是否存在
        $heroCfg = GameConfig::hero_getItem($heroModelId);
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }
        #检查需要消耗的碎片的常量配置是否存在
        $piecesCfg = GameConfig::segment_getItem($piecesId);
        if (!$piecesCfg) {
            return Resp::err(ErrCode::err_const_no);
        }
        # 5.检查道具的数量是否充足
        $myPacketItems = $user->store->segement;
        $requirePiecesNum = $heroCfg->unlockConditionId;
        # 检查道具数量是否充足
        $enoughPieces = false;
        if ($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum) {
            if (!CommUtil::isPropertyExists($myPacketItems, $piecesId)) {       # 检查碎片
                $enoughPieces = false;
            } else {
                if ($myPacketItems->$piecesId < $requirePiecesNum) {
                    $enoughPieces = false;
                } else {
                    $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);
        }
    }

    /**
     * [6322] 英雄神血
     * @param Req $req
     */
    static function UpGodBloodHeroByPieces($req) {
        return Resp::err(ErrCode::err_method_obsoleted);
    }

    /**
     * 英雄消耗碎片道具来升星
     * @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;
    }

    /**
     * 英雄升星
     * @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;
    }

// </editor-fold>

    /**
     * 6321 购买英雄 消耗碎片
     * @param req $req
     */
    static function BuyHeroByCostPieces($req) {
        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) {                             # 检查玩家是否已经拥有此类英雄
            my_Assert($value->typeId != $heroModelId, ErrCode::hero_existSameHero_err);
        }
        $heroCfg = GameConfig::hero_getItem($heroModelId);                      # 英雄模板数据
        my_Assert(null != $heroCfg, ErrCode::hero_const_no_err);
        my_Assert($heroCfg->isCanBuy != 0, ErrCode::paras_err);                 # 是否可以直接购买
        $piecesCfg = GameConfig::segment_getItem($piecesId);                    # 检查需要消耗的碎片的常量配置是否存在
        my_Assert(null != $piecesCfg, ErrCode::err_store_itemnoconst);
        $myPacketItems = $user->store->items;
        $requirePiecesNum = $piecesCfg->mergePrototypeNeedNum;
        my_Assert($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum, ErrCode::paras_err);
        my_Assert(CommUtil::isPropertyExists($myPacketItems, $piecesId), ErrCode::hero_godblood_notengoughitem);
        my_Assert($myPacketItems->$piecesId > $requirePiecesNum, ErrCode::hero_godblood_notengoughitem);       # 检查碎片道具数量是否充足

        switch ($costType) {
            case "cash":
                $realPrice = $heroCfg->cashPrice;
                my_Assert($realPrice == $costMoneyNum, ErrCode::paras_err);
                my_Assert($costMoneyNum >= 0, ErrCode::paras_err);
                my_Assert(Data_UserGame::Consume_Cash($user->baseInfo, $costMoneyNum), ErrCode::err_msg_cashnotenough);
                break;
            case "gold":
                $realPrice = $heroCfg->goldPrice;
                my_Assert($realPrice == $costMoneyNum, ErrCode::paras_err);
                my_Assert($costMoneyNum >= 0, ErrCode::paras_err);
                my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $costMoneyNum), ErrCode::err_msg_goldnotenough);
                break;
            default :
                Err(ErrCode::paras_err, "参数错误: [costType] " . $costType);
        }

        # 4.消耗来获得英雄 
        $myPacketItems->$piecesId -= $requirePiecesNum;                         # 消耗道具 
        $req->userInfo->game->store->items = $myPacketItems;                    # 回存背包
        UserProc::updateUserInfo();                                             # 回写数据
        $resp = HeroProc::GetHero($req);
        SystemProc::GetHero($req->zoneid, $user->baseInfo, $heroModelId);                 # 插入系统广播消息
        return $resp;
    }

    /**
     * 购买玩家可以收集的英雄的数量上限
     * @param req $req
     * @return type
     */
    static function BuyHeroMaxCountLimt($req) {
        list($buyNum, $costCash) = $req->paras;                                 # 提取参数: 数量, 花费钻石
        $g = glc();
        $user = $req->userInfo->game;                                           # user引用
        if (!CommUtil::isPropertyExists($user->heros, "maxCollectCount")) {
            $user->heros->maxCollectCount = $g->Game_CollectHero_BasicMaxCount;
        }
        $index = ceil(($user->heros->maxCollectCount - $g->Game_CollectHero_BasicMaxCount) #
                / $g->Game_CollectHero_OneBuyLimtNum);
        $arr = explode(",", $g->Game_CollectHero_BasicMaxPrice);
        my_Assert($index < count($arr), "已达上限");
        $realCost = $arr[$index];
        my_Assert($realCost == $costCash, ErrCode::paras_err);                  # 参数错误
        my_Assert($costCash >= 0, ErrCode::paras_err);
        my_Assert(Data_UserGame::Consume_Cash($user->baseInfo, $costCash), ErrCode::err_msg_goldnotenough); # 扣除宝石
        $user->heros->maxCollectCount += $buyNum;                               # 修改上限
        UserProc::updateUserInfo();
        return Resp::ok(array(
                    'maxCollectCount' => $user->heros->maxCollectCount
        ));
    }

    /**
     * 获得英雄(测试已经OK)
     * @param req $req
     */
    static function GetHero($req) {
        $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);                    # 创建英雄
        UserProc::updateUserInfo();
        $result = array('result' => "succeed", 'heros' => $hero);               #  4. 设置返回值
        return Resp::ok($result);
    }

// <editor-fold defaultstate="collapsed" desc="辅助方法">

    /**
     * 获得一个英雄, 并且给他指定星级
     * @param Req $req
     * @param int $heromodelId 原型数据id
     * @param int $star        星级
     * @return Ins_UserHero
     */
    static function AddHeroWithStar(&$req, $heromodelId, $star) {
        $user = $req->userInfo->game;
        my_Assert(null != $user, ErrCode::err_innerfault);
        $collectHeros = $user->heros->collectHeros;
        $uid = self::CreateNewGameHeroUID($collectHeros, $user->heros->recordMaxUID); # 先生成一个hero的UID
        $user->heros->recordMaxUID = $uid;
        $hero = self::getGameHeroModelInstance($heromodelId, $uid);
        if ($star > 0) {
            $hero->curStar = $star;                                               # 设定star
        }
        $collectHeros->$uid = $hero;                                            # 回写
        $user->heros->collectHeros = $collectHeros;                             # 回写 
        return $hero;                                                           # 返回
    }

    /**
     * 获得一个英雄(实例)
     * @param req $req
     * @param int $heromodelId
     * @return type
     */
    static function AddHeroTFromStore(&$req, $heromodelId) {
        $user = $req->userInfo->game;                                           # 玩家数据
        $collectHeros = $user->heros->collectHeros;                             # 
        my_default_Obj($collectHeros);
        $uid = self::CreateNewGameHeroUID($collectHeros, $user->heros->recordMaxUID); # 先生成一个UID
        $user->heros->recordMaxUID = $uid;                                      # 更新最大编号记录
        $hero = self::getGameHeroModelInstance($heromodelId, $uid);             # 3.创建英雄实例
        $collectHeros->$uid = $hero;
        $user->heros->collectHeros = $collectHeros;
        return $hero;
    }

    /**
     * 根据一个英雄的模板id,来获得一个英雄的实例数据 
     * @param string $heroModelId 模板数据ID
     * @param string $uid 唯一ID
     * @return Ins_UserHero
     */
    static function getGameHeroModelInstance($heroModelId, $uid) {
        $heroCfg = GameConfig::hero_getItem($heroModelId);
        my_Assert(null != $heroCfg, ErrCode::err_const_no);                     # 检查是否存在这个英雄的模板
        $hero = new Ins_UserHero();
//        $hero->strengthLevel = $heroCfg->dengjie;
        $hero->curStar = $heroCfg->xingji;
        $hero->typeId = $heroCfg->heroId;
        $hero->uid = $uid;
        $hero->xp = 0;
        $lvs = GameConfig::hero_levelexp_getItem($hero->level + 1);
        $hero->maxXp = $lvs->requiredExp;

        //  取可用武器中第一个初始化 -- 策划要求初始英雄要带有武器 -- 王刚 2020年1月
        $wp = null;
        $arr = (array) GameConfig::item_weapon();
        ksort($arr);                                                            // todo: 排序不正常
        foreach ($arr as $id => $mo) {
//            isEditor() and $mo = new \sm_item_weapon();
            if ($mo->hero_id == $hero->typeId) {
                $wp = $mo;
                break;
            }
        }
        if (null != $wp) {
            $req = req();
            $wuid = StoreProc::PutEquipInStore($wp->typeId, $req);
            $req->userInfo->game->store->equipment->$wuid->herouid = $uid;
            $hero->equip->weapon = array("itemuid" => $wuid);
        }

        return $hero;
    }

    /**
     * 查找下一个玩家获得英雄的UID
     * @param type $req
     * @return int
     */
    static function CreateNewGameHeroUID($collectHeros, $oldMaxUID) {
        $maxID = 10000;
        my_default_Obj($collectHeros);
        foreach ($collectHeros as $itemId => $hero) {
            if ($itemId > $maxID) {
                $maxID = $itemId;
            }
        }
        $max = max($maxID, $oldMaxUID);
        return $max + 1;
    }

    /**
     *  英雄卡牌增加经验值
     * @param string $heroUID
     * @param int $totalEXP 
     */
    static function HeroAddEXP($heroUID, $totalEXP) {
        $req = req();
        $collectHeros = $req->userInfo->game->heros->collectHeros;
        my_default_Obj($collectHeros);
        my_Assert(CommUtil::isPropertyExists($collectHeros, $heroUID), ErrCode::hero_no); # 要升级的英雄不存在
        $targetHero = new Ins_UserHero($collectHeros->$heroUID);               # 英雄对象 
        $playerLimit = GameConfig::playerlevel_getItem($req->userInfo->game->baseInfo->level)->hero_max_level;
        $maxLevel = min(glc()->Hero_Upgrade_BasicMaxLevel, $playerLimit);       # 最大等级= max(英雄最高等级上限,玩家等级限制的上限)
        if ($targetHero->level >= $maxLevel) {
            return;                                                             # 已达顶级
        }
        $lvs = GameConfig::hero_levelexp_getItem($targetHero->level + 1);
        $targetHero->xp += $totalEXP;
        my_Assert($targetHero->xp >= 0, "[" . $req->uid . "] : HeroLevelUpgrade Exp is negative!");
        $initLevel = $targetHero->level;
        while ($targetHero->xp >= $lvs->needExp) {
            if ($targetHero->level < $maxLevel) {                               # 如果未到达最大等级
                $targetHero->level += 1;
                if ($targetHero->level >= $maxLevel) {
                    $targetHero->xp = $lvs->needExp;
                } else {
                    $targetHero->xp -= $lvs->needExp;
                }
                $lvs = GameConfig::hero_levelexp_getItem($targetHero->level + 1);
            } else {                                                            # 如果已到达最大等级则仅补齐缺失的经验即可
                $targetHero->xp = $targetHero->maxXp;                           # 经验不能超过最大值
                break;
            }
        } // end while
        my_Assert($targetHero->xp >= 0, "[" . $req->uid . "] : HeroLevelUpgrade Exp is negative!");
        $collectHeros->$heroUID = $targetHero;                                  # 更新英雄的数据 
//        if ($targetHero->level != $initLevel) {
        TaskProc::OnHeroLevelUp($targetHero->typeId, $targetHero->level);
//        }
        return $targetHero;                                                     # 将英雄对象返回
    }

// </editor-fold>

    /**
     * [6306] 英雄-更改英雄的锁定状态
     * (测试已经OK)
     * @param type $req
     */
    static function HeroChangelockstate($req) {
        $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);
//        isEditor() and $hero = new UserHeroModel;
        $hero = $collectHeros->$heroUID;                                        # 1. 获取这个英雄的实例数据是
        $hero->isLocked = $lockstate;                                           # 2. 修改英雄状态
        UserProc::updateUserInfo();                                             # 3. 保存玩家数据
        return Resp::ok(ObjectInit()); # 4. 设置返回值
    }

    /**
     * 升星
     * @param req $req
     * @return type
     */
    static function StrengthenStar($req) {
        list($yanlingUid,$uidList) = $req->paras;
   
        $store = $req->userInfo->game->store;
        if(!StlUtil::dictHasProperty($store->yanling,$yanlingUid)){
            return Resp::err(ErrCode::hero_yanling_notfound);
        }
        $tag = true;
        foreach ($uidList as $costUid) {
            if(StlUtil::dictHasProperty($store->yanling,$costUid)){//校验是否是同类型
                $confDic = GameConfig::item_yanling_getItem($costUid);
                if($confDic->type != GameConfig::item_yanling_getItem($yanlingUid)->type){
                    $tag = false;
                    break;
                }                
            } else {
                $tag = false;
                break;
            }
        }
        
        if(!$tag){
            return Resp::err(ErrCode::hero_yanling_notfound);
        }
             
        $exp = 0;
        foreach ($uidList as $costuid) {
            $confDic = GameConfig::item_yanling_getItem($costuid);
            $exp += $confDic->addStarExp;
            
            StlUtil::dictRemove($store->yanling, $costuid);
        }
        
        $store->yanling->$yanlingUid->curStarExp += $exp;
        $dic = GameConfig::item_yanling_getItem($store->yanling->$yanlingUid->typeId);
        
        if($store->yanling->$yanlingUid->curStarExp >= $dic->maxStarExp){
            $store->yanling->$yanlingUid->curStarExp = 0;
            $store->yanling->$yanlingUid->starLv += 1;
            if($dic->nextId = 0){
                $store->yanling->$yanlingUid->starLv = 5;
            }
        }
        
        $req->userInfo->game->store = $store;                                     
        UserProc::updateUserInfo();   
        return Resp::ok(array('store' => $req->userInfo->game->store,)); 
    }


//
// <editor-fold defaultstate="collapsed" desc="计算战队战斗力, for pvp back matchers, -wg 2017.07.13">

    /**
     * 计算队伍战斗力, 添加到战斗力隐藏榜单中, for pvp back matchers, -wg 2017.07.13
     * @param type $zoneid
     * @param type $uid
     * @param Data_UserGame $user
     * @return type
     */
    static function CalcTeamFightPower($zoneid, $uid, $user) {
        $teamsetting = $user->heroTeamConfig;                                   # 战队配置
//        var_dump($user);
        $heros = $user->heros;
        $teamCfg = JsonUtil::decode($teamsetting);
        $tid = $teamCfg->curUseTeamID;
        $team = $teamCfg->teamDic->$tid;
        $fp = 0;                                                                # 返回值
        if ($team) {
            foreach ($team->heros as $hid) {
                if ($hid) {
                    $hero = $heros->collectHeros->$hid;
                    if ($hero) {
//                        $fp += self::calcHeroFightPower($hero);
                        $h = new Ins_UserHero($hero);
                        $fp += $h->GetPower();
                    }
                }
            }
            //todo: 这里的战斗力榜被总战力榜征用了key, 重启PVP机制时再
//            gMem()->zadd(MemKey_GameRun::Game_FightPowerRank_zset($zoneid), array($uid => $fp)); 
        }
        return $fp;
    }

    /**
     * 计算玩家总战斗力, 添加到战斗力榜单中
     * @version 1.0.0 改造自原来的队伍战斗力统计方法 --gwang 2020.4.23
     * @param type $zoneid
     * @param type $uid
     * @param Data_UserGame $user
     * @return type
     */
    static function CalcUserFightPower($zoneid, $uid, $user) {
        $fp = 0;                                                                # 总战力:返回值
        foreach ($user->heros->collectHeros as $hid => $hero) {
            $h = new Ins_UserHero($hero);
            $fp += $h->GetPower();
        }
        $key_fp = MemKey_GameRun::Game_FightPowerRank_zset($zoneid);            # 战力榜
        $key_log = MemKey_GameRun::Game_Rank_FPowerBreakLog_hash($zoneid);      # 突破记录
        gMem()->zadd($key_fp, array($uid => $fp));                              # 更新战力记录
        foreach (GameConfig::rankreward_fpower() as $condition => $reward) {    # 遍历突破奖励数据
            if ($fp >= $condition && !gMem()->hexists($key_log, $condition)) {  # 判断是否达成突破奖励标准
                gMem()->hset($key_log, $condition, $uid);                       # 添加突破记录
                CornerSignEventProc::OnRanking_PowerReward_new(req());
            }
        }
        TaskProc::OnUserFightPowerN($fp);
        return $fp;
    }

    /**
     * 计算hero战斗力, for pvp back matchers, -wg 2017.07.13
     * @param Ins_UserHero $hero
     * @return int
     */
    static private function calcHeroFightPower($hero) {
        $arr = explode(';', glc()->Battle_PowerFactor);
        $factor = ArrayInit();
        foreach ($arr as $s) {
            $kv = explode(',', $s);
            $k = $kv[0];
            $v = $kv[1];
            $factor[$k] = $v;
        }
// todo: 哈哈, 奇葩的命名方案, 多处使用的命名不一致, 坑!
        $a = (int) (self::calcHeroProperty($hero, 'hp') * $factor ["hp"]   //
                + $hero->level * 10);
        return $a;
    }

    /**
     * 计算hero的属性,, for pvp back matchers, -wg 2017.07.13
     * @param Ins_UserHero $hero
     * @param type $propertyname
     */
    private static function calcHeroProperty($hero, $propertyname) {
        $val = 0;
        if ($hero) {
            $modle = GameConfig::hero_getItem($hero->typeId);
            if ($modle) {
                $extra = GameConfig::heroextra_level_getItem($hero->typeId, $hero->grade);
                if ($extra) {
                    $val = (int) ($modle->$propertyname * (1 + $extra->$propertyname));
                } else {
                    $val = $modle->$propertyname;
                }
            }
        }
        return $val;
    }

// </editor-fold>
//
}