server/Gameserver/Amfphp/Process/HeroProc.php

<?php

namespace loyalsoft;

/**
 * 英雄处理逻辑
 * @author gwang
 */
class HeroProc {
//put your code here

    /**
     * 英雄处理逻辑分发
     * 所有的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);
//            case CmdCode::cmd_hero_upstar:                                    #  [6305] 英雄升星
//                return HeroProc::HeroUpStarByPieces($req);
//            case CmdCode::cmd_hero_changelockstate:                           #  [6306] 英雄-修改锁定状态
//                return HeroProc::HeroChangelockstate($req);
//            case CmdCode::cmd_hero_gethero:                                   #  [6308] 分解英雄
//                return HeroProc::GetHero($req);
//            case CmdCode::cmd_hero_strength:                                  #  [6309] 英雄升阶
//                return HeroProc::HeroStrength($req);
//            case CmdCode::cmd_hero_openFavor:                                 #  [6310] 英雄好感度解锁
//                return HeroProc::HeroOpenFavor($req);
//            case CmdCode::cmd_hero_separate:                                  #  [6311] 分解英雄
//                return HeroProc::HeroSeparate($req);
//            case CmdCode::cmd_hero_buyCollectHeroLimtCount:                   #  [6312] 扩展英雄数量上限
//                return HeroProc::BuyHeroMaxCountLimt($req);
//            case CmdCode::cmd_hero_changefriendsupport:                       #  [6313] 更换支援好友
//                return HeroProc::ChangeFriendSupport($req);
# --------- 英雄技能 -----------                
            case CmdCode::cmd_hero_upgradeSkillLevel:                           #  [6314] 英雄的技能升级
                return HeroProc::UpgradeSkillLevel($req);
            case CmdCode::cmd_hero_unlockSkill:                                 #  [6324] 英雄技能 - 解锁技能 
                return;
            case CmdCode::cmd_hero_skillLevel_onekeyupgrade:                    #  [6325] 英雄技能 - 一键升级
                return;
            case CmdCode::cmd_hero_saveHeroTeamConfig:                          #  [6315] 保存玩家战队数据
                return HeroProc::SaveHeroTeamConfig($req);
#  --------- 英雄评论 -----------
            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);
#----------------------------------------------
            case CmdCode::cmd_hero_buyHero:                                     #  [6321]购买英雄
                return HeroProc::BuyHeroByCostPieces($req);
            case CmdCode::cmd_hero_upGodBlood:                                  #  [6322] 神血升级
                return HeroProc::UpGodBloodHeroByPieces($req);
//            case CmdCode::cmd_hero_unlockByPieces:                            #  [6323] 解锁碎片
//                return HeroProc::UnLockHeroByPieces($req);                

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

    /**
     * 英雄技能升级
     * @param type $req
     */
    static function UpgradeSkillLevel($req) {
#         $resp = ResponseVo::ErrResponse($req, ErrCode::msg_methodnotimplement);
        $user = $req->userInfo->game; # user引用
        $huid = $req->paras[0];                                                 # 英雄的UID
        $skillId = $req->paras[1];                                              # 要升级的技能
        $skillType = $req->paras[2];                                            # 要升级的技能
        $costGold = $req->paras[3];                                             # 要升级的消耗金币
#                                                                               # 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 UserHeroModel();
        $strengthHero = $collectHeros->$huid;
#                                                                               # 取出这个英雄的技能数据
        $targteHeroSkills = ObjectInit();
        if (CommUtil::isPropertyExists($strengthHero, "skills")) {
            $targteHeroSkills = $strengthHero->skills;
        }
# 如果不存在这个类型的技能,则 初始化一个.
        if (!CommUtil::isPropertyExists($targteHeroSkills, $skillType)) {
            $targteHeroSkills->$skillType = JsonUtil::decode('{"level":1}');
        }
        $curSkillInfo = $targteHeroSkills->$skillType;
        $curSkillLevel = $curSkillInfo->level;
# 3.判断技能等级能否在继续升级了
        if ($curSkillLevel >= $strengthHero->level) {
            return Resp::err(ErrCode::hero_upgradeSkill_maxLevel);
        }
# 4.取出该技能升级消耗的常量数据
# 检查是否存在当前技能的消耗常量数据
//        $lvs = GameConfig::skill_shengji_getItem($skillId);
        $lvs = GameConfig::skill_upgrade_cost_getItem($skillId);
        if (!$lvs) {
            return Resp::err(ErrCode::hero_upgradeSkill_cost_const_no);
        }
        $realGold = $lvs->basic + ($curSkillLevel - 1) * $lvs->xishu;
        $arr_extracost = explode(";", $lvs->extra);
        foreach ($arr_extracost as $value) {
            $arr = explode(",", $value);
            if (count($arr) == 2) {
                $extraLevel = $arr[0];
                $extraGold = $arr[1];
                if ($extraLevel == $curSkillLevel + 1) {
                    $realGold += $extraGold;
                    break;
                }
            }
        }

# 判断金币是否充足
        $bDeal = false;  # 成交
        if ($realGold != $costGold) {
            return Resp::err(ErrCode::paras_err, "costGold error! server need:" . $realGold);
        } else {
            if ($costGold > 0) {
                if ($user->gold < $costGold) {
                    return Resp::err(ErrCode::notenough_gold_msg);
                } else {
                    $bDeal = UserGameModel::Consume_Gold($user, $costGold);
                }
            } else if ($costGold == 0) {
                $bDeal = true;
            } else {
                return Resp::err(ErrCode::paras_err);
            }
        }
# 4.消耗金币和英雄
        if ($bDeal) {
            $targteHeroSkills->$skillType->level += 1;
            $strengthHero->skills = $targteHeroSkills;
            ActiveProc::ChangeTaskCount($req);
# 回写数据
            UserProc::updateUserInfo($req);
            $resp = Resp::ok($strengthHero);
        }
        return $resp;
    }

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

    /**
     * 6304 英雄 升阶(消耗碎片)
     * @param Req $req
     */
    static function HeroStageUp($req) {
//        $g = glc();                                                             # 全局配置
        $user = $req->userInfo->game;                                           # user引用
        $huid = $req->paras[0];                                                 # 英雄的UID
        $nextGrade = $req->paras[1];                                            # 下一阶

        $collectHeros = $user->heros->collectHeros;                             # 角色容器
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $huid)) {                # 1.检查是否存在要升级的英雄
            return Resp::err(ErrCode::hero_no);
        }
//        isEditor() and $upHero = new UserHeroModel();
        $upHero = $collectHeros->$huid;
        if ($upHero->grade >= "S") {                                            # 已经达到S级
            return Resp::err(ErrCode::hero_strength_maxstrengthlevel);
        }
        $heroUpgradeCostCfg = GameConfig::heroextra_level_getItem($upHero->typeId, $nextGrade);
        if (!$heroUpgradeCostCfg) {                                             # 1.检查是否存在这个升阶数据的模板
            return Resp::err(ErrCode::hero_strength_cost_const_no);
        }
        $needSeg = $heroUpgradeCostCfg->segNum;                                 # 2 
        if ($user->Consume_HeroSegment($user, #                                 # 扣除碎片
                        $heroUpgradeCostCfg->segID, $heroUpgradeCostCfg->segNum)) {
//        if (true) {                                                             # 扣除碎片直接成功
            $upHero->grade = $nextGrade;                                        # 5.强化英雄进行成功升阶 
            UserProc::updateUserInfo($req);                                     # 6.数据回存
            $resp = Resp::ok($upHero);
            SystemProc::insertHero_StageUp($req->zoneid, $req->uid, $user->name, #
                    GameConfig::hero_getItem($upHero->typeId)->name, $upHero->grade);
        } else {                                                                # 碎片数量不足
            return Resp::err(ErrCode::hero_segment_not_enough);
        }
        return $resp;
    }

    /**
     * [6301] 英雄升级 - 消耗经验道具,获得经验(按照经验提升等级)
     * @param Req $req
     */
    static function HeroLevelUpCostExpItem($req) {
        $gcfg = glc();                                                          # 全局配置
        $user = $req->userInfo->game;                                           # user引用
        $heroUID = $req->paras[0];                                              # 玩家英雄实例编号
        $costItemId = $req->paras[1];                                           # 消耗的道具ID
        $costNumber = $req->paras[2];                                           # 消耗的道具数量 
        $collectHeros = $user->heros->collectHeros;                             # 1. 检查是否存在要升级的英雄
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $heroUID)) {
            return Resp::err(ErrCode::hero_no);
        }
//        isEditor() and $targetHero = new UserHeroModel;                         # 智能感知辅助
        $targetHero = $collectHeros->$heroUID;

        $maxLevel = $gcfg->Hero_Upgrade_BasicMaxLevel;
        if ($targetHero->level >= $maxLevel) {                                  # 2. 检查玩家等级是否达到当前等级上限
            return Resp::err(ErrCode::hero_upgrade_maxupgradelevel);
        }
        $myPacketItems = $user->store->items;                                   # 检查道具的数量，在背包中是否充足
        if (!CommUtil::isPropertyExists($myPacketItems, $costItemId) #
                || $myPacketItems->$costItemId < $costNumber) {
            return Resp::err(ErrCode::store_itemnotenough);
        }
        $totalEXP = 0;                                                          # 4.计算消耗的道具一共给多少经验值以及 一共要消耗多少金币 
        $costItemConst = GameConfig::item_stones_getItem($costItemId);
        if (!$costItemConst) {
            return Resp::err(ErrCode::err_const_no);
        } else {
            $totalEXP += $costItemConst->baseExp;
        }
        $heroConst = GameConfig::hero_getItem($targetHero->typeId);             # 英雄模板数据
        if (null == $heroConst) {
            return \Resp::err(ErrCode::err_const_no, "英雄 模板数据");
        }
        if ($costItemConst->element != 0 #                                      # 相同元素加成
                && $costItemConst->element == $heroConst->element) {
            $totalEXP += $costItemConst->extraExp;
        }
        self:: HeroAddEXP($heroUID, $totalEXP, $req);                           # 获得经验 
        $myPacketItems->$costItemId -= $costNumber;                             # 消耗道具
        if ($myPacketItems->$costItemId < 0) {
            $myPacketItems->$costItemId = 0;
        }
        $req->userInfo->game->store->items = $myPacketItems;                    # 更新背包数据
        UserProc::updateUserInfo($req);                                         # 回写玩家数据
        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($req);                                         # 回写数据
#       # 添加到战斗力隐藏榜单中, 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($req);                                     # 回写数据
            return Resp::ok(array('result' => "OK"));                           //返回OK
        } else {
            return Resp::err(ErrCode::hero_godblood_notengoughitem);
        }
    }

    /**
     * 购买英雄
     * @param type $req
     */
    static function BuyHero($req) {
        $user = $req->userInfo->game; # user引用
        $heroModelId = $req->paras[0];
        $costType = $req->paras[1];
        $costMoneyNum = $req->paras[2];
#1 检查玩家是否已经拥有此类英雄
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        foreach ($collectHeros as $key => $value) {
            isEditor() and $value = new UserHeroModel();
            if ($value->typeId == $heroModelId) {
                return Resp::err(ErrCode::hero_existSameHero_err);
            }
        }
        $recordUnLockHeroDic = $user->heros->recordUnLockHeroDic;
        if (!$recordUnLockHeroDic) {
            $recordUnLockHeroDic = ObjectInit();
        }
        #检查是不是已经解锁过了
        $flag = 0;
        if (!CommUtil::isPropertyExists($recordUnLockHeroDic, $heroModelId)) {
            $recordUnLockHeroDic->$heroModelId = 0;
        }
        $flag = $recordUnLockHeroDic->$heroModelId;
        if ($flag == 0) {
            return Resp::err(ErrCode::hero_lockState);
        }

#2 检查账户余额是否充足
        $heroCfg = GameConfig::hero_getItem($heroModelId);
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }
        if ($heroCfg->isCanBuy == 0) {
            return Resp::err(ErrCode::paras_err);
        }

        $bDeal = false;  # 成交
        if ($costType == "cash") {
            $realPrice = $heroCfg->cashPrice;
            if ($realPrice != $costMoneyNum) {
                return Resp::err(ErrCode::paras_err, "costCASH error! server need:" . $realPrice);
            } else {
                if ($costMoneyNum > 0) {
                    if ($user->cash < $costMoneyNum) {
                        return Resp::err(ErrCode::notenough_cash_msg);
                    } else {
                        $bDeal = UserGameModel::Consume_Cash($user, $costMoneyNum);
                    }
                } else if ($costMoneyNum == 0) {
                    $bDeal = true;
                } else {
                    return Resp::err(ErrCode::paras_err);
                }
            }
        } else if ($costType == "gold") {
            $realPrice = $heroCfg->goldPrice;
            if ($realPrice != $costMoneyNum) {
                return Resp::err(ErrCode::paras_err, "costGold error! server need:" . $realPrice);
            } else {
                if ($costMoneyNum > 0) {
                    if ($user->gold < $costMoneyNum) {
                        return Resp::err(ErrCode::notenough_gold_msg);
                    } else {
                        $bDeal = UserGameModel::Consume_Gold($user, $costMoneyNum);
                    }
                } else if ($costMoneyNum == 0) {
                    $bDeal = true;
                } else {
                    return Resp::err(ErrCode::paras_err);
                }
            }
        }
# 4.消耗来获得英雄
        if ($bDeal) {
            $resp = HeroProc::GetHero($req);
        }
        return $resp;
    }

    /**
     * 更改好友支援
     * @param type $req
     */
    static function ChangeFriendSupport($req) {
        $user = $req->userInfo->game;            # user引用
        if (!CommUtil::isPropertyExists($user->heros, "firendSupportHeroUID")) {
            $user->heros->firendSupportHeroUID = "";
        }
        $friendSupportHeroUids = $req->paras[0]; # 设置支援好友的英雄UID
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }                                        # 1.检查玩家存在指定的英雄
        if (!CommUtil::isPropertyExists($collectHeros, $friendSupportHeroUids)) {
            return Resp::err(ErrCode::hero_separate_cost_hero);
        }
        $user->heros->firendSupportHeroUID = $friendSupportHeroUids;
        UserProc::updateUserInfo($req);          # 回存数据
        return Resp::ok(array('firendSupportHeroUID' => $friendSupportHeroUids));
    }

    /**
     * 英雄的分解获得晶石
     * @param type $req
     * @return type
     */
    static function HeroSeparate($req) {
        $g = glc();
        $user = $req->userInfo->game; # user引用
        $costHeroUids = $req->paras[0]; # 消耗掉的英雄UID
# 1.检查是玩家的英雄数据
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
# 3.检查消耗的英雄数量,以及玩家是否都存在这些英雄UID.
        $arr_costUID = explode(",", $costHeroUids);
        $isAllExist = true;
        foreach ($arr_costUID as $value) {
            if ($value == "") {
                continue;
            }
            if (!CommUtil::isPropertyExists($collectHeros, $value)) {
                $isAllExist = false;
                break;
            }
        }
        if (!$isAllExist) {
            return Resp::err(ErrCode::hero_separate_cost_hero);
        }
# 4.统计下这些个英雄都能获得多少晶石
# 消耗卡牌
        $spar = 0;
        $starToSparCfgArr = explode(",", $g->Hero_Star_SeparateToSpar);
        foreach ($arr_costUID as $huid) {
            if ($huid == "") {
                continue;
            }
            isEditor() and $strengthHero = new UserHeroModel();
            $strengthHero = $collectHeros->$huid;
            $index = $strengthHero->curStar - 1;
            if ($index >= 0 && $index < count($starToSparCfgArr)) {
                $spar += $starToSparCfgArr[$index];
            }
            unset($collectHeros->$huid);
        }
#  发物品到玩家包裹
        $req->userInfo->game->spar += $spar; # 入账能量块
#  回存数据
        UserProc::updateUserInfo($req);
        return Resp::ok(array('num' => $spar));
    }

    /**
     * 英雄好感度解锁
     * @param type $req
     */
    static function HeroOpenFavor($req) {
        $user = $req->userInfo->game;     # user引用
        $huid = $req->paras[0];           # 英雄的UID
        $targetFavorId = $req->paras[1];  # 目标好感度 索引id
# 1.检查是否存在要升级的英雄
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
            return Resp::err(ErrCode::hero_no);
        }
# 2.检查目标好感度的常量数据是否存在
        $favorCfg = GameConfig::heroextra_favor_getItem($targetFavorId);
        if (!$favorCfg) {
            return Resp::err(ErrCode::hero_favor_cost_const_no);
        }
# 3.检查英雄是否已经解锁了目标好感度
        $strengthHero = $collectHeros->$huid;
        if (!$strengthHero->curMainFavor) {
            $strengthHero->curMainFavor = 'E';
        }
        if (!$strengthHero->favors) {
            $strengthHero->favors = ArrayInit();
            $strengthHero->favors[] = 'E';
        }
        if (CommUtil::isInArray($strengthHero->favors, $favorCfg->name)) {
            return Resp::err(ErrCode::hero_favor_targetfavor_para);
        }
#  4.检查消耗道具是否充足
        $costSpar = $favorCfg->cost;
        $bDeal = false;  # 成交
        if ($costSpar > 0) {
            if ($user->spar < $costSpar) {
                return Resp::err(ErrCode::notenough_spar);
            } else {
                $bDeal = UserGameModel::Consume_Spar($user, $costSpar);
            }
        } else {
            return Resp::err(ErrCode::paras_err);
        }
# 6.进行消耗升星
        if ($bDeal) {
            if ($favorCfg->isMain) {
                $strengthHero->curMainFavor = $favorCfg->name;
            }
            $strengthHero->favors[] = $favorCfg->name;
            UserProc::updateUserInfo($req);
            $resp = Resp::ok($strengthHero);
        }
        return $resp;
    }

    /**
     * 英雄神血
     * @param Req $req
     */
    static function UpGodBloodHeroByPieces($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];
        $moneyType = $req->paras[3]; # 升星消耗金钱的类型
        $moneyNum = $req->paras[4];
        # 1.检查是否存在要升级的英雄
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
            return Resp::err(ErrCode::hero_no);
        }
        # 2.检查是否存在要升级的英雄的神血的血脉值 是否达到100%
        isEditor() and $strengthHero = new UserHeroModel();
        $strengthHero = $collectHeros->$huid;

        # 检查是否存在当前 神血的的消耗常量数据 以及血脉值 是否达到100%
        if (!CommUtil::isPropertyExists($strengthHero, "curBloodId")) {
            $strengthHero->curBloodId = 0;
        }
        $lvs = GameConfig::heroextra_godblood_getItem($strengthHero->curBloodId);
        if (!$lvs) {
            return Resp::err(ErrCode::hero_godblood_level_const_no);
        } else {
            if ($lvs->targetGodPercent >= 100) {
                return Resp::err(ErrCode::hero_godblood_maxlevel);
            }
        }
        # 3. 检查是否存在这个英雄的模板
        $heroModelId = $strengthHero->typeId;

        $heroCfg = GameConfig::hero_getItem($heroModelId);
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }

        # 4 .检查碎片是否正确
        $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::segment_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);
        }

        # 5.检查道具的数量是否充足
        $myPacketItems = $user->store->segement;
        # 检查道具数量是否充足
        $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 ($enoughPieces === true) {
            
        } else {
            return Resp::err(ErrCode::hero_godblood_notengoughitem);
        }

        # 6.检查账户余额是否充足
        #检查消耗是否正确
        $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;
                }
            }
        }
        echoline($requireMoneyNum + "   " + $moneyNum + "   " + $requireMoneyType + "   " + $moneyType);
        if ($requireMoneyType == $moneyType && $requireMoneyNum == $moneyNum) {
            if ($requireMoneyType === "gold") {
                if ($user->gold >= $requireMoneyNum) {
                    $enoughMoney = true;
                } else {
                    return Resp::err(ErrCode::notenough_gold_msg);
                }
            } else if ($requireMoneyType === "cash") {
                if ($user->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 = UserGameModel:: Consume_Gold($user, $requireMoneyNum);
            } else if ($requireMoneyType === "cash") {
                $bDeal = UserGameModel:: Consume_Cash($user, $requireMoneyNum);
            }
        }

        # 6.进行消耗升星
        if ($bDeal) {
            $strengthHero->curBloodId += 1;
            # # 消耗道具
            $myPacketItems->$requirePieceId -= $requirePiecesNum;
            if ($myPacketItems->$requirePieceId < 0) {
                $myPacketItems->$requirePieceId = 0;
            }

            $req->userInfo->game->store->segement = $myPacketItems;
            # 回写数据
            UserProc::updateUserInfo($req);
            $resp = Resp::ok($strengthHero);
            #  推送系统消息
            SystemProc::Hero_purification($req->zoneid, $user, $heroModelId);
        }
        ActiveProc::ChangeTaskCount($req);

        return $resp;
    }

    /**
     * 英雄消耗碎片道具来升星
     * @param type $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 UserHeroModel();
        $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->gold >= $requireMoneyNum) {
                    $enoughMoney = true;
                } else {
                    return Resp::err(ErrCode::notenough_gold_msg);
                }
            } else if ($requireMoneyType === "cash") {
                if ($user->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 = UserGameModel:: Consume_Gold($user, $requireMoneyNum);
            } else if ($requireMoneyType === "cash") {
                $bDeal = UserGameModel:: Consume_Cash($user, $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($req);
            $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 UserHeroModel();
        $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->gold < $costGold) {
                    return Resp::err(ErrCode::notenough_gold_msg);
                } else {
                    $bDeal = UserGameModel:: Consume_Gold($user, $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($req);
            $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 type $req
     */
    static function BuyHeroByCostPieces($req) {
        $user = $req->userInfo->game;                                           # user引用
        $heroModelId = $req->paras[0];
        $costType = $req->paras[1];
        $costMoneyNum = $req->paras[2];
        $piecesId = $req->paras[3];
        $piecesNum = $req->paras[4];

        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        foreach ($collectHeros as $key => $value) {
            isEditor() and $value = new UserHeroModel();
            if ($value->typeId == $heroModelId) {                               # 检查玩家是否已经拥有此类英雄
                return Resp::err(ErrCode::hero_existSameHero_err);
            }
        }
        $heroCfg = GameConfig::hero_getItem($heroModelId);                      # 检查账户余额是否充足
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }
        if ($heroCfg->isCanBuy == 0) {
            return Resp::err(ErrCode::paras_err);
        }
        $piecesCfg = GameConfig::segment_getItem($piecesId);                    # 检查需要消耗的碎片的常量配置是否存在
        if (!$piecesCfg) {
            return Resp::err(ErrCode::err_store_itemnoconst);
        }
        $myPacketItems = $user->store->segement;
        $requirePiecesNum = $piecesCfg->mergePrototypeNeedNum;
        if ($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum) {
            if (!CommUtil::isPropertyExists($myPacketItems, $piecesId)#
                    || $myPacketItems->$piecesId < $requirePiecesNum) {         # 检查碎片道具数量是否充足
                return Resp::err(ErrCode::hero_godblood_notengoughitem);
            }
        } else {
            return Resp::err(ErrCode ::paras_err, #
                            "error pieces para" . "req" . $piecesId . "_" .
                            $requirePiecesNum . "/" . $piecesId . "_" . $piecesNum);
        }
        $bDeal = false;                                                         # 成交
        if ($costType == "cash") {
            $realPrice = $heroCfg->cashPrice;
            if ($realPrice != $costMoneyNum) {
                return Resp::err(ErrCode::paras_err, "costCASH error! server need:" . $realPrice);
            } else {
                if ($costMoneyNum > 0) {
                    if ($user->cash < $costMoneyNum) {
                        return Resp::err(ErrCode::err_msg_cashnotenough);
                    } else {
                        $bDeal = UserGameModel::Consume_Cash($user, $costMoneyNum);
                    }
                } else if ($costMoneyNum == 0) {
                    $bDeal = true;
                } else {
                    return Resp::err(ErrCode::paras_err);
                }
            }
        } else if ($costType == "gold") {
            $realPrice = $heroCfg->goldPrice;
            if ($realPrice != $costMoneyNum) {
                return Resp::err(ErrCode::paras_err, "costGold error! server need:" . $realPrice);
            } else {
                if ($costMoneyNum > 0) {
                    if ($user->gold < $costMoneyNum) {
                        return Resp::err(ErrCode::err_msg_goldnotenough);
                    } else {
                        $bDeal = UserGameModel::Consume_Gold($user, $costMoneyNum);
                    }
                } else if ($costMoneyNum == 0) {
                    $bDeal = true;
                } else {
                    return Resp::err(ErrCode::paras_err);
                }
            }
        }
        # 4.消耗来获得英雄
        if ($bDeal) {
            # 6.进行
            # # 消耗道具
            $myPacketItems->$piecesId -= $requirePiecesNum;
            if ($myPacketItems->$piecesId < 0) {
                $myPacketItems->$piecesId = 0;
            }

            $req->userInfo->game->store->segement = $myPacketItems;
            # 回写数据
            UserProc::updateUserInfo($req);
            $resp = HeroProc::GetHero($req);
            SystemProc::GetHero($req->zoneid, $user, $heroModelId);
        }
        return $resp;
    }

    /**
     * 购买玩家可以收集的英雄的数量上限
     * @param type $req
     * @return type
     */
    static function BuyHeroMaxCountLimt($req) {
        $g = glc();
        $user = $req->userInfo->game;                                           # user引用
        if (!CommUtil::isPropertyExists($user->heros, "maxCollectCount")) {
            $user->heros->maxCollectCount = $g->Game_CollectHero_BasicMaxCount;
        }
        $buyNum = $req->paras[0];
        $costCash = $req->paras[1];

        $index = ceil(($user->heros->maxCollectCount - $g->Game_CollectHero_BasicMaxCount) #
                / $g->Game_CollectHero_OneBuyLimtNum);
        $arr = explode(",", $g->Game_CollectHero_BasicMaxPrice);
        if ($index >= count($arr)) {
            return Resp::err(ErrCode::paras_err, "yi da shang xian");
        }
        $realCost = $arr[$index];

        if ($realCost != $costCash) {
            return Resp::err(ErrCode::paras_err, "costCash error! server need:" . $realCost);
        }
        if ($costCash <= 0) {
            return Resp::err(ErrCode::paras_err);
        }
        if ($user->cash < $costCash) {
            return Resp::err(ErrCode::notenough_spar);
        }
        UserGameModel::Consume_Cash($user, $costCash);                          # 扣除宝石
        $user->heros->maxCollectCount += $buyNum;                               # 修改上限
        UserProc::updateUserInfo($req);
        return Resp::ok(array(
                    'maxCollectCount' => $user->heros->maxCollectCount
        ));
    }

    /**
     * 获得英雄(测试已经OK)
     * @param type $req
     */
    static function GetHero($req) {
        $heroModelId = $req->paras[0]; //英雄的模板ID
//1.检查是否存在这个英雄的模板
        $heroCfg = GameConfig::hero_getItem($heroModelId);
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }
        $hero = self::AddHeroTFromStore($req, $heroModelId);
        UserProc::updateUserInfo($req);
#  4. 设置返回值
        $result = array('result' => "succeed",
            'heros' => $hero);
        return Resp::ok($result);
#         return $resp;
    }

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

    /**
     * 尝试图鉴整合
     * @param CredisUtil $mem
     * @param HeroManualModel $manual
     * @param type $hero
     */
    static function tryNewManual($mem, &$manual, $hero) {
        $godpetId = $hero->typeId;
        $level = 0;

        self:: changeManual($manual, $godpetId, $level);
    }

    /**
     * 更改图鉴数据
     * @global int $AchievementIsManualExpAddedGlobal

     * @param type $manual
     * @param type $heroModelId
     * @param type $level
     */
    static function changeManual(&$manual, $heroModelId, $level) {
        if (!property_exists($manual, "godpetDic")) {
            $manual->godpetDic = ObjectInit();
        }
        $godpetDic = $manual->godpetDic;

        if (!CommUtil::isPropertyExists($godpetDic, $heroModelId)) {
            $godpetDic->$heroModelId = array(0);
        } else {
            
        }
    }

    /**
     * 获得一个英雄, 并且给他指定星级
     * @param Req $req
     * @param int $heromodelId 原型数据id
     * @param int $star        星级
     * @return UserHeroModel
     */
    static function AddHeroWithStar(&$req, $heromodelId, $star) {
        $user = $req->userInfo->game;
        if (!$user) {
            return null;
        }
        $heroCfg = GameConfig::hero_getItem($heromodelId);                      # 检查是否存在这个英雄的模板
        if (!$heroCfg) {                                                        # 这里能不能附加错误信息给外面
            return null;
        }
        $collectHeros = $user->heros->collectHeros;
        $uid = self::CreateNewGameHeroUID($collectHeros, $user->heros->recordMaxUID); # 先生成一个hero的UID
        $user->heros->recordMaxUID = $uid;
        $hero = self::getGameHeroModelInstance($heroCfg, $heromodelId, $uid);
        $hero->curStar = $star;                                                 # 设定star
        $collectHeros->$uid = $hero;                                            # 回写
        $user->heros->collectHeros = $collectHeros;                             # 回写 
        if (!CommUtil::isPropertyExists($user, "heroManual")) {
            $user->heroManual = new HeroManualModel();
            $user->heroManual->initInstance();
        }
        $manual = $user->heroManual;
        self::tryNewManual($req->mem, $manual, $hero);                          # 更新 图鉴
        return $hero;                                                           # 返回
    }

    /**
     * 获得一个英雄
     * @param type $req
     * @param type $heromodelId
     * @return type
     */
    static function AddHeroTFromStore(&$req, $heromodelId) {
        $gamedata = $req->userInfo->game;
        if (!CommUtil::isPropertyExists($gamedata, "heroManual")) {
            $gamedata->heroManual = new HeroManualModel();
            $gamedata->heroManual->initInstance();
        }
        $manual = $gamedata->heroManual;

        $heroCfg = GameConfig::hero_getItem($heromodelId);                      //1.检查是否存在这个英雄的模板
        if (!$heroCfg) {
            return Resp::err(ErrCode::hero_const_no_err);
        }
        $collectHeros = $gamedata->heros->collectHeros;                          //2.存在的话,先生成一个UID
        $uid = self::CreateNewGameHeroUID($collectHeros, $gamedata->heros->recordMaxUID);
        $gamedata->heros->recordMaxUID = $uid;
        $hero = self::getGameHeroModelInstance($heroCfg, $heromodelId, $uid);
        $collectHeros->$uid = $hero;
        $gamedata->heros->collectHeros = $collectHeros;
        self:: tryNewManual($req->mem, $manual, $hero);
        return $hero;
    }

    /**
     * 根据一个英雄的模板id,来获得一个英雄的实例数据
     * @param HeroModel $heroCfg 模板数据
     * @param string $heroModelId 模板数据ID
     * @param string $uid 唯一ID
     * @return UserHeroModel
     */
    static function getGameHeroModelInstance($heroCfg, $heroModelId, $uid) {
        $hero = new UserHeroModel();
////取常量数据理的默认的等阶和星级
        $sour = $heroCfg; //GameConfig::hero_getItem($heroModelId);
        $hero->strengthLevel = $sour->dengjie;
        $hero->curStar = $sour->xingji;

//查找mem中此英雄的模板数据
        $hero->typeId = $heroModelId;
        $hero->uid = $uid;
        $hero->xp = 0;
        $lvs = GameConfig::hero_levelexp_getItem($hero->level + 1);
        $hero->maxXp = $lvs->requiredExp;

        return $hero;
    }

    /**
     * 查找下一个玩家获得英雄的UID
     * @param type $req
     * @return int
     */
    static function CreateNewGameHeroUID($collectHeros, $oldMaxUID) {
        $maxID = 10000;
        if ($collectHeros == null) {
            $collectHeros = ObjectInit();
        }

        foreach ($collectHeros as $itemId => $hero) {
            if ($itemId > $maxID) {
                $maxID = $itemId;
            }
        }
        $max = $maxID;
        if ($oldMaxUID < $maxID) {
            $max = $maxID;
        } else {
            $max = $oldMaxUID;
        }
        return $max + 1;
    }

    /**
     * 一个英雄卡牌获得一点经验值
     * @param string $heroUID
     * @param int $totalEXP
     * @param Req $req
     */
    static function HeroAddEXP($heroUID, $totalEXP, $req) {
        $g = glc();
        $collectHeros = $req->userInfo->game->heros->collectHeros;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $heroUID)) {
            return;                                                             # 要升级的英雄不存在
        }
//        isEditor() and $targetHero = new UserHeroModel;
        $targetHero = $collectHeros->$heroUID;
        $maxLevel = $g->Hero_Upgrade_BasicMaxLevel;                             # 等级上限 
        if ($targetHero->level >= $maxLevel) {
            return;                                                             # 已达顶级
        }
        $lvs = GameConfig::hero_levelexp_getItem($targetHero->level);
        $targetHero->xp += $totalEXP;
        CLog:: Assert("HeroProc", $targetHero->xp >= 0, #
                "[" . $req->uid . "] : HeroLevelUpgrade Exp is negative!");

        while ($targetHero->xp >= $lvs->needExp) {
            if ($targetHero->level < $maxLevel) {                               # 如果未到达最大等级
                $targetHero->level += 1;
                $lvs = GameConfig::hero_levelexp_getItem($targetHero->level);
                if ($targetHero->level >= $maxLevel) {
                    $targetHero->xp = $lvs->needExp;
                } else {
                    $targetHero->xp -= $lvs->needExp;
                }
                $targetHero->maxXp = $lvs->needExp;
            } else {                                                            # 如果已到达最大等级则仅补齐缺失的经验即可
                $targetHero->xp = $targetHero->maxXp;                           # 经验不能超过最大值
                break;
            }
        } // end while
    }

// </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;
        if (!$collectHeros) {
            $collectHeros = ObjectInit();
        }
        if (!CommUtil::isPropertyExists($collectHeros, $heroUID)) {
            return Resp::err(ErrCode::hero_no);
        }
        isEditor() and $hero = new UserHeroModel;
        $hero = $collectHeros->$heroUID;                                        # 1. 获取这个英雄的实例数据是
        $hero->isLocked = $lockstate;                                           # 2. 修改英雄状态
        UserProc::updateUserInfo($req);                                         # 3. 保存玩家数据
        return Resp::ok(ObjectInit()); # 4. 设置返回值
    }

//
// <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 UserGameModel $user
     * @return type
     */
    static function CalcTeamFightPower($zoneid, $uid, $user) {
        $mem = gMem();
        $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) {
//                isEditor() and $hero = new GameHeroModel();
                if ($hid) {
                    $hero = $heros->collectHeros->$hid;
                    if ($hero) {
                        $fp += self::calcHeroFightPower($hero);
                    }
                }
            }
            $mem->zadd(MemKey_GameRun::Game_FightPowerRank_zset($zoneid), array($uid => $fp));
        }
        return $fp;
    }

    /**
     * 计算hero战斗力, for pvp back matchers, -wg 2017.07.13
     * @param UserHeroModel $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 UserHeroModel $hero
     * @param type $propertyname
     */
    private static function calcHeroProperty($hero, $propertyname) {
        $level = $hero->level;
        $modle = GameConfig::hero_getItem($hero->typeId);
        $extra = GameConfig::heroextra_level_getItem(1);
        return (int) ($modle->$propertyname * (1 + $extra->$propertyname));
    }

// </editor-fold>
//
}