server/Gameserver/Amfphp/process/StoreProc.php

<?php

namespace loyalsoft;

/**
 * Description of StoreProc
 * 仓库/背包 处理流程
 * ===========================
 * 尚待处理的流程：道具售出时貌似存在多种格式....
 * @author
 */
class StoreProc {

    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param type $req
     */
    static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::cmd_store_put:                                        # 6401 放入仓库
                return StoreProc::AddItemInStore($req);
            case CmdCode::cmd_store_singleSell:                                 # 6402 出售单个道具
                return StoreProc::sellItem($req);
            case CmdCode::cmd_store_mutliSell:                                  # 6403 批量出售 卖掉
                return StoreProc::sellMultiItemFromStore($req);
            case CmdCode::cmd_store_use:                                        # 6404 使用道具
                return StoreProc::useItem($req);
            case CmdCode::cmd_store_refresh:                                    # 6405 获取最新的仓库数据
                return StoreProc::refreshStore($req);
            case CmdCode::cmd_store_decomposeItem:                              # 6406 分解道具
                return StoreProc::decomposeItem($req);
            case CmdCode::cmd_store_ItemUpgrade:                                # 6408 装备升级
                return StoreProc::ItemUpgrade($req);
            case CmdCode::cmd_store_GemCompose:                                 # 6408 装备合成
                return StoreProc::composeItem($req);
//
            case CmdCode::cmd_store_WearEquip:                                  # 6410 给英雄穿装备
                return StoreProc::WearEquipToHero($req);
            case CmdCode::cmd_store_UnWieldEquip:                               # 6411 将该装备从指定英雄上脱下
                return StoreProc::UnWieldEquip($req);
            case CmdCode::cmd_store_WearYanling:                                # 6416 装备言灵
                return StoreProc::WearYanlingToHero($req);
            case CmdCode::cmd_store_UnWieldYanling:                             # 6417 卸下言灵
                return StoreProc::UnWieldYanling($req);
// 
            case CmdCode::cmd_store_AddMaxPacketNum:                            # 6412 扩展包裹格子数量
                return StoreProc::AddPacketNum($req);
            case CmdCode::cmd_store_MeltEquip:                                  # 6413 装备融合
                Err(ErrCode::err_method_obsoleted);
//                return StoreProc::MeltEquip($req);
            case CmdCode::cmd_store_PiecesCompose:                              # 6415 碎片合成
                return StoreProc::composePieces($req);

            case CmdCode::cmd_store_Testcmd:                                    # 6407 测试方法
                return StoreProc::Test($req);
            default:
                Err(ErrCode::cmd_err);
        }
    }

    /**
     * 测试方法
     * @param Req $req
     * @return type
     */
    static public function Test($req) {
//        return StoreProc::MeltEquip($req);
    }

    /**
     * [6404] 使用仓库道具
     * @param Req $req
     */
    static function useItem($req) {
//        return ResponseVo::ErrResponse($req, ErrCode::msg_method_obsoleted);
        $itemId = $req->paras[0];                                               # 道具id
        $num = 1;                                                               # 数量, 可选参数, 默认为1
        if (count($req->paras) > 1) {                                           # 如果传了,
            $num = $req->paras[1];                                              # 提取可选参数: 道具数量
        }                                                                       # end 提取参数
        $typeId = substr($itemId, 0, 3);                                        # 道具分类前缀
        switch ($typeId) {                                                      # 使用道具()
            case '701':                                                         # 宝箱
                $resp = Boxes::OpenBox($req);                                   # 调用开宝箱功能
                break;
            default :                                                           # 其他
                Err(ErrCode::store_itemcantuse);
                break;
        }
        return $resp;
    }

    /**
     * [6405] 刷新仓库列表
     * @param Req $req
     */
    static function refreshStore($req) {
        StoreProc::CheckItemNum($req);
        $result = array(
            'store' => $req->userInfo->game->store
        );
        return Resp::ok($result);
    }

//
// <editor-fold defaultstate="collapsed" desc="    物品升级    ">

    /**
     * [6408] 物品的升级
     * @param Req $req
     * @return type
     */
    static function ItemUpgrade($req) {
        $mem = $req->mem;
        $uid = $req->paras[0]; //获取物品uid
        $money = $req->paras[1]; //需要的手工费
        $resp = new Resp();
        $user = $req->userInfo->game; # user引用
        $ary = $req->paras[3]; //获取物品的结构数组
        foreach ($ary as $value) {
            $itemId = $value[1];
            $uid = $value[2];
            if ($uid < 1) {
                Err(ErrCode::paras_err);
            }

            $ok = StoreProc::removeEquipFromStore($uid, $itemId, $req); # 从背包移除
            if (!$ok) {//1.如果背包道具移出时出错，则直接返回错误
                Err(ErrCode::store_removefail);
            }
            $item = GameConfig::item_getItem($itemId);                        //ConstProc::getItemConst($itemId);
            if ($item == null) { //2.检测是否存在装备的原始数据
                Err(ErrCode::err_const_no);
            }

            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret); //返回必须是object
        }
        $bDeal = UserGameModel::Consume_Gold($user, $money);
        if ($bDeal) {

            ActiveProc::ChangeTaskCount($req);
            $result = array(
                'store' => $req->userInfo->game->store,
                'resp' => "succeed!"
            );
            $resp = Resp::ok($result);
        } else {
            Err(ErrCode::notenough_gold_msg);
        }


        if (0 == $resp->err) {
            StoreProc:: UpdateItem($req);
            $result = array(
                'store' => $req->userInfo->game->store,
                'resp' => "succeed!"
            );
            $resp = Resp::ok($result);
        }

        StoreProc::CheckItemNum($req);

        return $resp;
    }

    /**
     * 更新单个物品属性
     * @param Req $req
     */
    private static function UpdateItem($req) {
        $store = $req->userInfo->game->store;
        $uid = $req->paras[0]; //获取物品uid
        $obj = $req->paras[2]; //获取物品的结构数组
        $itemLevel = 0;
        $bUplevel = false;
        foreach ($obj as $key => $value) {
            if ($key === "level") {
                if (CommUtil::isPropertyExists($store->equipment->$uid, $key)) {
                    if ($store->equipment->$uid->$key < $value) {
                        $bUplevel = true;
                        $itemLevel = $value;
                    }
                } else {
                    if ($value > 1) {
                        $bUplevel = true;
                        $itemLevel = $value;
                    }
                }
            }
            if ($bUplevel) {
                $item = GameConfig::item_getItem($store->equipment->$uid->typeId);
                if ($item == null) { //2.检测是否存在装备的原始数据
                    Err(ErrCode::err_const_no);
                }
                // 推送系统消息
                SystemProc::insertWeapon_promoteUp($req->zoneid, $req->uid, $req->userInfo->game->name, $item->name, $itemLevel);
            }
            $store->equipment->$uid->$key = $value;
        }
        UserProc::updateUserInfo($req);
        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret); //返回必须是object
        return $resp;
    }

    /**
     * 
     * @param type $req
     * @return type
     * @deprecated since version 0
     */
    static function UpgradeMeltEquip($req) {
        $store = $req->userInfo->game->store;
        $uid = $req->paras[0]; //获取物品uid
        // echo var_export($uid);
        $itemId = $store->equipment->$uid->typeId;
        $item = GameConfig::item_getItem($itemId);
        if ($store->equipment->$uid->melt_level > $item->melt_level) {
            $meltLevel = $store->equipment->$uid->melt_level;
        } else {
            $meltLevel = $item->melt_level;
        }
        $meltLevel++;

        $melt = GameConfig::smelting_getItem($meltLevel);
        //  var_dump($melt);
        if ($melt == null) { ////在装备熔炼等级表里找不到该等级的熔炼规则
            Err(ErrCode::err_const_no);
        }

        $attrib = $melt->attribute; ////当前熔炼等级成功后属性加成


        foreach ($item as $key => $value) {
            if ($key === "melt_level") {
                $store->equipment->$uid->$key = $meltLevel;
            }
            if ($key === "gongji") {
                if ($store->equipment->$uid->$key > $value) {
                    $store->equipment->$uid->$key = (int) ($store->equipment->$uid->$key * $attrib);
                } else {
                    $store->equipment->$uid->$key = (int) ($value * $attrib);
                }
            }
            if ($key === "fangyu") {
                if ($store->equipment->$uid->$key > $value) {
                    $store->equipment->$uid->$key = (int) ($store->equipment->$uid->$key * $attrib);
                } else {
                    $store->equipment->$uid->$key = (int) ($value * $attrib);
                }
            }
            if ($key === "hp") {
                if ($store->equipment->$uid->$key > $value) {
                    $store->equipment->$uid->$key = (int) ($store->equipment->$uid->$key * $attrib);
                } else {
                    $store->equipment->$uid->$key = (int) ($value * $attrib);
                }
            }
            if ($key === "minjie") {
                if ($store->equipment->$uid->$key > $value) {
                    $store->equipment->$uid->$key = (int) ($store->equipment->$uid->$key * $attrib);
                } else {
                    $store->equipment->$uid->$key = (int) ($value * $attrib);
                }
            }
            if ($key === "baoji") {
                if ($store->equipment->$uid->$key > $value) {
                    $store->equipment->$uid->$key = (int) ($store->equipment->$uid->$key * $attrib);
                } else {
                    $store->equipment->$uid->$key = (int) ($value * $attrib);
                }
            }
        }

//
//       $EquipObj = $store->equipment->$uid;
//             ////检测装备的情况,装备升级时,基础属性要乘以系数. 如果之前升过级,那么它的"原始值"就不同了.
//        if ($EquipObj) {
//            foreach ($EquipObj as $key=> $value) {
//                    if ($key === "melt_level") {
//                        $key=$meltLevel;
//                    }
//                     if ($key === "melt_level") {
//                        $key=$meltLevel;
//                    }
//                }
//            }
        //   echo var_export($store);



        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret); //返回必须是object

        return $resp;
    }

    static function getItemProperty($req) {
        $store = $req->userInfo->game->store;
        $uid = $req->paras[0]; //获取物品uid
        // echo var_export($uid);
        $itemId = $store->equipment->$uid->typeId;
        $item = GameConfig::item_getItem($itemId);
    }

    /**
     * [6409] 合成道具
     * @param Req $req
     */
    static public function composeItem($req) {
        $resp = \Resp::err(ErrCode::err_method_notimplement);
        $store = $req->userInfo->game->store;
// 解析客户端参数
        $lowitemId = $req->paras[0]; // 道具id
        $usenum = $req->paras[1];    // 数量
        $highitemId = $req->paras[2]; // 道具id
        $addnum = $req->paras[3];    // 数量
        $gold = $req->paras[4];    // 需要的手续费
        echo var_export($gold);
        $user = $req->userInfo->game; # user引用
        if ($usenum < 3) {
            Err(ErrCode::paras_err, "数量非法!");
        }
//1.从仓库里移除这个道具
        $ok = StoreProc::removeItemFromStore($store, $lowitemId, $usenum); // 支持移除指定数量
//如果仓库道具移出时出错，则直接返回错误
        if ($ok != ErrCode::ok) {
            Err($ok);
        }

        $bDeal = UserGameModel::Consume_Gold($user, $gold);
        if ($bDeal) {
            ActiveProc::ChangeTaskCount($req);
            $store->items->$highitemId += $addnum;
            UserProc::updateUserInfo($req);
            # 准备返回值
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret); //返回必须是object
        } else {
            Err(ErrCode::notenough_gold_msg);
        }

        StoreProc::CheckItemNum($req);
        return $resp;
    }

    /**
     * [6409] 合成碎片（几个碎片合成获得同品质或者更高品质的新碎片）
     * @param Req $req
     */
    static public function composePieces($req) {
        $resp = Resp::err(ErrCode::err_method_notimplement);
        $store = $req->userInfo->game->store;
// 解析客户端参数
        $piecesid1 = $req->paras[0]; // 碎片id1
        $piecesid2 = $req->paras[1];  // 碎片id2
        $piecesid3 = $req->paras[2]; // 碎片id3
        $user = $req->userInfo->game; # user引用
        $pieceslist = array($piecesid1, $piecesid2, $piecesid3);
//1.从仓库里移除这个道具
        for ($i = 0; $i < count($pieceslist); $i++) {
            $ok = StoreProc::removeItemFromStore($store, $pieceslist[$i], 1); // 支持移除指定数量
            if ($ok != ErrCode::ok) {
                break;
            }
        }

//如果仓库道具移出时出错，则直接返回错误
        if ($ok != ErrCode::ok) {
            Err($ok);
        }
        $gold = glc()->Compose_Pieces_Gold; ////临时用这个来算，等刷过数据再说
        echoLine($gold);
        $bDeal = UserGameModel::Consume_Gold($user, $gold);
        if ($bDeal) {
            ActiveProc::ChangeTaskCount($req);
            $reward = StoreProc::composePiecesProbability($req);
            StoreProc::addSegmentIntoStore($store, $reward);
            UserProc::updateUserInfo($req);
            # 准备返回值
            $result = array(
                'reward' => $reward,
                'store' => $req->userInfo->game->store,
                'resp' => "succeed!"
            );
            $resp = Resp::ok($result);
        } else {
            Err(ErrCode::notenough_gold_msg);
        }
        StoreProc::CheckItemNum($req);
        return $resp;
    }

    ////合成碎片时的概率
    static public function composePiecesProbability($req) {
        $piecesid1 = $req->paras[0]; // 碎片id1
        $piecesid2 = $req->paras[1];  // 碎片id2
        $piecesid3 = $req->paras[2]; // 碎片id3
        $pieceslist = array($piecesid1, $piecesid2, $piecesid3);
        ///权重和值
        $weight = 0;
        for ($i = 0; $i < count($pieceslist); $i++) {
            $segmentid = $pieceslist[$i];
            $segItem = GameConfig::segment_getItem($segmentid); /////获取该碎片的信息
            $WeightItem = GameConfig::segment_ronghe_getItem($segItem->quailty); ///通过品质来获取权重
            $weight += $WeightItem->weight;
        }
        $reward = StoreProc::GetRewarByWeight($weight);
        //////根据最终三个碎片的权重值和来判断该品质的获取概率。
        ////用类似  3,80;5,60;10,20;  来表示 (在权重和达到3时获取率是80%，在权重和达到5时获取率是60%，在权重和达到10时获取率是10%)
        //
        //   ////为了数值设置表和填数据方便，将两个表合成为一个表
        //
        ////数值设置起来方便，但是用起来稍微麻烦一些，需要取出数据表里的所有碎片的值。

        return $reward;
    }

    static public function GetRewarByWeight($weight) {
        for ($i = 0; $i < 5; $i++) {
            $item = GameConfig::segment_ronghe_getItem($i + 1);
            //  $RewardList[]=$item;
            $ary = explode(";", $item->probability);
            foreach ($ary as $value) {
                $val = explode(",", $value);
                $weig = $val[0]; //达到的权重值
                $prob = $val[1]; //该权重下的获取概率
                if ($weight >= $weig) {
                    $probList[$i] = $prob;
                }
            }
        }
        $rnd = CommUtil::random(1, 10000);
        $start = 0;
        $rew = 0;
        for ($i = 0; $i < 5; $i++) {
            if ($start < $rnd && $rnd <= $start + $probList[$i]) { # 落入区间
                $rew = $i + 1;                               # 记录物品
                break;
            }
            $start += $probList[$i];                   # 继续判断是否落入下一物品的区间
        }

        //     $piecesDataBaseList= GameConfig::segment();////获取所有的碎片数据表
        $tmpPiecesList = GameConfig::segment_byPinzhi_getItem($rew, 1);
//             foreach ($piecesDataBaseList as $typeId => $value)
//             {
//                 // $value->
//             //   echo var_dump($value);
//                 if ($value->itemType==1) ////是英雄碎片
//                     {
//                        if( $value->quailty==$rew) ///碎片品质是指定品质
//                        {
//                              $tmpPiecesList[]=$typeId; ///保存到一个临时表里。
//                        }
//                 }
//             }

        $tmprnd = CommUtil::random(0, count($tmpPiecesList) - 1);

        return $tmpPiecesList[$tmprnd]->typeId;
    }

// </editor-fold>
//  ---------------  以下为辅助方法  ------------------
//
// <editor-fold defaultstate="collapsed" desc="   移除物品   ">

    /**
     * 从仓库中移除指定数量的物品
     * @param UserGameModel $user
     * @param type $itemId
     * @param type $itemcount
     * @return type
     */
    static function removeItemFromStore($store, $itemId, $itemcount) {
        $typeId = substr($itemId, 0, 3);
        switch ($typeId) {
            case '307':                                     #经验书
            case '305':                                     #扫荡券
            case '304':                                         # 宝石
                if (CommUtil::isPropertyExists($store->items, $itemId)) { //
                    if ($store->items->$itemId >= $itemcount) {  // 数量足够
                        $store->items->$itemId -= $itemcount;
                        if ($store->items->$itemId == 0) {
                            unset($store->items->$itemId);
                        }
                        return ErrCode::ok;
                    } else {
                        return ErrCode::store_itemnotenough; // 道具数量不足
                    }
                } else {
                    return ErrCode::store_itemno_err;
                }
                break;
            case '310':                                         # 碎片
            case '311':                                         # 碎片
            case '312':                                         # 碎片
            case '313':                                         #装备 碎片
            case '314':                                         #装备 碎片
            case '315':                                         #装备 碎片
                if (CommUtil::isPropertyExists($store->segement, $itemId)) { //
                    if ($store->segement->$itemId >= $itemcount) {  // 数量足够
                        $store->segement->$itemId -= $itemcount;
                        if ($store->segement->$itemId == 0) {
                            unset($store->segement->$itemId);
                        }
                        return ErrCode::ok;
                    } else {
                        return ErrCode::store_itemnotenough; // 道具数量不足
                    }
                } else {
                    return ErrCode::store_itemno_err;
                }
                break;
            default :                                           # 其他
                Err(ErrCode::store_itemcantuse);
                break;
        }
    }

    /**
     * 从仓库移出
     * @param type $itemId
     * @param StoreModel $store
     * @return boolean
     */
    static function removeFromStore($itemId, &$store) {
//return ErrCode::succeed;
        $typid = substr("$itemId", 0, 3);  # 取道具分类
        $ok = false;
        switch ($typid) {
            case "101": # 英雄 错误了的路径
                break;
            case '102': # 英雄碎片
                if (CommUtil::isPropertyExists($store->segement, "$itemId") && $store->segement->$itemId > 0) {
                    $store->segement->$itemId -= 1;
                    $ok = true;
                }
                break;
            case "203": # 宝箱
                if (CommUtil::isPropertyExists($store->boxes, "$itemId") && $store->boxes->$itemId > 0) {
                    $store->boxes->$itemId -= 1;
                    $ok = true;
                }
                break;
            default:
                break;
        }
        return $ok;
    }

    /**
     * 从仓库移出装备
     * @param type $itemId  uid
     * @param StoreModel $store
     * @return boolean
     */
    static function removeEquipFromStore($uid, $typeId, &$req) {

        $ok = false;
        echo var_export($uid);
        if (CommUtil::isPropertyExists($req->userInfo->game->store->equipment, $uid)) {

            //  $con=  ConstProc::getItemConst($req->mem, $req->userInfo->game->store->equipment->$uid->typeId);


            echo var_export($req->userInfo->game->store->equipment->$uid->typeId);

            if ($typeId == $req->userInfo->game->store->equipment->$uid->typeId) {
                echo "typeid相同";
                unset($req->userInfo->game->store->equipment->$uid);
                $ok = true;
            } else {
                echo "typeid检验错误";
            }
        }


        return $ok;
    }

    /**
     * 从仓库移除碎片
     * @param StoreModel $store
     * @param int $segmentId
     * @param int $num
     * @return bool 成功/失败
     */
    static function removeSegmetFromStore($store, $segmentId, $num = 1) {
        if (CommUtil::isPropertyExists($store->segement, $segmentId)  #
                && $store->segement->$segmentId >= $num) {
            $store->segement->$segmentId -= $num;
            return TRUE;
        }
        return false;
    }

    /**
     * 向仓库添加碎片
     * @param StoreModel $store
     * @param int $segmentId
     * @param int $num
     */
    static function addSegmentIntoStore($store, $segmentId, $num = 1) {
        if (CommUtil::isPropertyExists($store->segement, $segmentId)) {
            $store->segement->$segmentId += $num;
        } else {
            $store->segement->$segmentId = $num;
        }
    }

    /**
     * 计算玩家仓库中某种符石/道具的数量
     * @param type $map
     * @param type $stoneid
     * @return type
     */
    static function GetStoneCount($map, $stoneid) {
        $ret = 0;
        if ($map->store->stones && CommUtil::isPropertyExists($map->store->stones, $stoneid)) {
            $ret = $map->store->stones->
                    $stoneid;
        }
        return $ret;
    }

    /**
     * 从仓库移除符石(道具)
     * @param MapModel $map
     * @param int $stoneid
     * @param int $num
     */
    static function RemoveStoneFromStore(&$map, $stoneid, $num = 1) {
        if ($num <= 0) {
            return $num;
        }
        $ret = 0;
        if ($map->store->stones && CommUtil::isPropertyExists($map->store->stones, $stoneid)) {
            $left = $map->store->stones->$stoneid - $num;
            if ($ret >= 0) {////这里有bug吗?应该是用$left啊,不过无所谓,反正这个函数暂时用不上,不考虑了.
                $map->store->stones->$stoneid -= $num;
                $ret = $num;
            }
        }
        return $ret;
    }

// </editor-fold>
//
// <editor-fold defaultstate="collapsed" desc="   放入物品   ">

    /**
     * 将其他物品放入仓库
     * @param type $itemId
     * @param UserGameModel $game
     */
    static function PutItemInStore($itemId, &$game) {
        if (CommUtil::isPropertyExists($game->store->items, $itemId)) {// 如果仓库中已经有这种元素，则其数目+1
            $game->store->items->$itemId += 1;
        } else {// 如果仓库中没有这种元素，则其数目置1
            $game->store->items->$itemId = 1;
        }
    }

    /**
     * 检测是否允许放入仓库
     * @param BuildModel $build
     * @return type
     */
    static function canPutInStore($build) {
        if ($build->categoryId == INIT_HABITID) {
            return ErrCode::ok;
        }
        return ErrCode::store_putinto;
    }

    /**
     * 解包多种物品到玩家身上 【警告】此函数的异常处理功能残废，不安全
     * 检测如果当前物品格子大于物品总数,则可以获取战利品,否则不可以 
     * @param Req $req
     * @param string $goodsStr itemid,num;itemid,num;...
     * @param int $src 1:战斗奖励, 2: 任务奖励, 3: 抽奖奖品, 4: 邮件领取, 5: 现金充值
     * @deprecated since version 0
     * @return type
     */
    public static function AddMultiItemInStore($req, $goodsStr, $src = 1) {
        $user = $req->userInfo->game;
        $ary = explode(";", $goodsStr);
        foreach ($ary as $value) {
            $val = explode(",", $value);
            $itemId = $val[0];
            $num = $val[1]; //数量
            $str1 = substr($itemId, 0, 3);  # prefix
            switch ($str1) {
                // 10x 怪物卡或者英雄卡牌获取
                case "101":
                case "202":
                case "201":
//                    if (1 == $src && $user->heros->maxCollectCount <= StoreProc::CheckHeroNum($req)) {
//                        # 战斗模块获得的英雄,超过上限丢弃
//                        echo "英雄满了."; # 满了如何处理? 直接丢弃吗? 是的, ok. gwang 2017年4月22日 16:49:58 问过
//                    } else {
//                        HeroProc::AddHeroTFromStore($req, $itemId);
//                    }
                    break;
                // 30x 装备物品的获取.
                case "301":
                case "302":
                case "303":
                    if (StoreProc::GetItemMaxNum($req) > StoreProc::CheckItemNum($req)) {
                        StoreProc::PutEquipInStore($itemId, $req);
                    }
                    break;
                //宝石的获取 +  抽奖券+经验书
                case "304":
                case "305":
                case "307":
                    if (StoreProc::GetItemMaxNum($req) > StoreProc::CheckItemNum($req)) {
                        StoreProc:: PutOverlyingItemInStore($itemId, $num, $req);
                    }
                    break;
//              // 31x 碎片
                case "310":                              # 英雄碎片
                case "311":                              # 小怪碎片
                case "312":                              # boss碎片
                case "313":                              # 装备碎片
                case "314":                              # 装备碎片
                case "315":                              # 装备碎片\
                    if (StoreProc::GetItemMaxNum($req) > StoreProc::CheckItemNum($req)) {
                        StoreProc::addSegmentIntoStore($req->userInfo->game->store, $itemId, $num);
                    }
                    break;
                case "701":                              # 宝箱
                case "702":
                case "703":
                case "704":

                    StoreProc::putBoxexInStore($req->userInfo->game->store, $itemId, $num);

                    break;
                // 游戏内货币的获取
                case "399":
                    switch ($itemId) {
                        case META_CASH_ITEMID:            # 钻石
                            UserGameModel::Add_Cash($req->userInfo->game, $num);
                            break;
                        case META_GOLD_ITEMID:            # 金币
                            UserGameModel::Add_Gold($req->mem, $req->userInfo->game, $num);
                            break;
                        case META_tili_ITEMID:            # 体力
                            UserGameModel::Add_tili($req, $num);
                            break;
                        case META_FriendShipPoit_ItemId:  # 友情
                            UserGameModel::Add_FriendPoint($req->userInfo->game, $num);
                            break;
                        default :
                    }
                    break;
                ////熔炼元素的获取
                case "388":
//                    StoreProc::PutElementInStore($itemId, $num, $req);
                    break;
                default:
                    break;
            }
        }

//        //  更新数据库数据
        UserProc::updateUserInfo($req); ////这行不要注释掉,除非在邮件和任务领奖那里加入更新(在调用addmultiInstore函数的后面加入updateuserinfo的话,就可以注销到这行代码)
        return ErrCode::ok;     // 返回
    }

    /// 物品类型，物品typeid，物品数量
    public static function AddItemInStore($req) {
        $itemType = $req->paras[0];
        $itemId = $req->paras[1];
        $num = $req->paras[2]; //数量

        if ($itemType < 4) {
            StoreProc::PutEquipInStore($itemId, $req);
        } else if ($itemType == 4) {
            StoreProc:: PutOverlyingItemInStore($itemId, $num, $req);
        } else if ($itemType == 10) {
            StoreProc:: PutOverlyingItemInStore($itemId, $num, $req); ///准备添加其他
        }



        //  更新数据库数据
        UserProc::updateUserInfo($req);
        // 返回

        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret); //返回必须是object
        return $resp;
    }

    /**
     * 将装备放入背包
     * @param type $itemId
     * @param Req $req
     */
    static function PutEquipInStore($itemId, &$req) {
        $privateState = $req->userInfo->game->privateState;
        if (!CommUtil::isPropertyExists($privateState, "currentId")) {          // 如果仓库中已经有这种元素，则其数目+1
            $req->userInfo->game->privateState->currentId = 1;
        }
        $cid = $req->userInfo->game->privateState->currentId++;
        $equip = ObjectInit();
        $equip->typeId = $itemId;
        $req->userInfo->game->store->equipment->$cid = $equip;
        return $cid;
//        SystemProc::GetEquip($req->zoneid, $req->userInfo->game, $itemId);      # 添加获得装备的消息
    }

    /**
     * 将可叠加物品放入背包
     * @param type $itemId
     * @param UserGameModel $game
     */
    static function PutOverlyingItemInStore($itemId, $num, &$req) {
        //  $game->userInfo->game;
        if (CommUtil::isPropertyExists($req->userInfo->game->store->items, $itemId)) {// 如果仓库中已经有这种元素，则其数目+1
            $req->userInfo->game->store->items->$itemId += $num;
        } else {// 如果仓库中没有这种元素，则其数目置1
            $req->userInfo->game->store->items->$itemId = $num;
        }
    }

    /**
     * 物品包裹打散成独立道具到仓库
     * @param GoodsItemModel $itemModel
     * @param Req $req
     * @return type
     */
    static function addSeprateItem($itemModel, $req) {
//        var_dump($itemModel);
        $user = $req->userInfo->game;
        $store = $req->userInfo->game->store;
        $itemContent = JsonUtil::decode($itemModel->content);

        foreach ($itemContent as $itemId => $itemNum) {
            if ($itemId == META_GOLDITEMID) {                        # 如果是金币 1
                UserModel::Add_Gold($user, $itemNum);
            } else if ($itemId == META_CASHITEMID) {                 # 如果是宝石 2
                UserModel::present_cash($req, $itemNum, "<" . $req->cmd . ">道具解包-" . $itemModel->name);
            } else if ($itemId == META_SPAEITEMID) {                 # 如果是能量块 3
                $user->spar += $itemNum;
            } else if ($itemId == META_YUANBAOITEMID) { # 元宝，后加的只能采用字段补偿机制 7
                PayProc::m_AddUserYuanbao($req, $itemNum, "<" . $req->cmd . ">道具解包-" . $itemModel->name);
            } else {                                                // 否则就是道具
                $typid = substr("$itemId", 0, 3);
                switch ($typid) {
                    case "101": # 英雄
                        if (property_exists($user->heros, $itemId)) {
                            DebugHelper::var_dump(" 已经有了xxx英雄了.");
                        } else {  # 给玩家创建一个英雄
                            $hero = new HeroModel();
                            $instanceID = now();
                            $heroID = $itemId;
                            $hero->reInit($heroID, $instanceID);
                            $user->heros->$heroID = $hero;
                        }
                        break;
                    case '102': # 碎片
                        if (CommUtil::isPropertyExists($store->segement, $itemId)) {
                            $store->segement->$itemId += $itemNum;
                        } else {
                            $store->segement->$itemId = $itemNum;
                        }
                        break;
                    case '203': # 宝箱
                        if (CommUtil::isPropertyExists($store->boxes, $itemId)) {
                            $store->boxes->$itemId += $itemNum;
                        } else {
                            $store->boxes->$itemId = $itemNum;
                        }
                        break;
                    default :
                        break;
                }
//                for ($i = 0; $i < $itemNum; $i++) {
//                    $store->items[] = $itemId;
//                }
            }
//            break;  # 不会循环的,一个物品中只有第一个道具配置生效,否则
        }
        UserProc::updateUserInfo($req);

        # 添加活动记录
//        self::checkActiveItem($req, $itemModel);
    }

    /**
     * [6417] 给英雄装上言灵
     * @param req $req
     * @return type
     */
    static function WearYanlingToHero($req) {
        $user = $req->userInfo->game;                                           # user引用
        list($itemtype, $yanling_uid, $herouid) = $req->paras;                  # 提取参数: 装备类型, 装备的UID, 英雄的UID 

        if (!CommUtil::isPropertyExists($user->store->yanling, $yanling_uid)) { # 检测是否存在该言灵
            Err(ErrCode::store_itemno_err);
        }
        $yanlingVo = $user->store->yanling->$yanling_uid;                       # 取言灵对象
        if ($yanlingVo->herouid > 0 && $yanlingVo->herouid != $herouid) {       # 检测该言灵是否装备到其他英雄身上 
            Err(ErrCode::store_equipWeared_err);
        }
        $collectHeros = $user->heros->collectHeros;                             # 英雄集合
        if (!$collectHeros) {                                                   # 防御对象为空
            Err(ErrCode::err_innerfault);
        }
        if (!CommUtil::isPropertyExists($collectHeros, $herouid)) {             # 检查英雄是否存在
            Err(ErrCode::hero_no);
        }
        $user->store->yanling->$yanling_uid->herouid = $herouid;                # 言灵上添加反向引用, 避免查询时的循环
        $oldYLid = $collectHeros->$herouid->yanling->$itemtype->itemuid;        # 旧言灵id
        if ($oldYLid > 0) {                                                     # 代表替换操作
            $user->store->yanling->$oldYLid->herouid = 0;                       # 清理旧言灵的
        }
        $collectHeros->$herouid->yanling->$itemtype->itemuid = $yanling_uid;    # 英雄身上添加言灵记录

        UserProc::updateUserInfo($req);                                         # 5.回写数据
        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret);                                                 // 返回 
//        StoreProc::CheckItemNum($req);
        return $resp;
    }

    /**
     * [6416] 给英雄卸下言灵
     * @param req $req
     * @return type
     */
    static function UnWieldYanling($req) {
        $user = $req->userInfo->game;                                           # user引用
        list($itemtype, $yanling_uid, $herouid) = $req->paras;                  # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 

        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            Err(ErrCode::err_innerfault);
        }
        if (!CommUtil::isPropertyExists($collectHeros, $herouid)) {             # 检测是否存在拥有该装备的英雄
            Err(ErrCode::hero_no);
        }
        if (!CommUtil::isPropertyExists($user->store->yanling, $yanling_uid)) { # 检测是否存在该装备
            Err(ErrCode::store_itemno_err);
        }
        if ($user->store->yanling->$yanling_uid->herouid == $herouid) {         # 取装备对象
            $user->store->yanling->$yanling_uid->herouid = 0;
        }
        if ($collectHeros->$herouid->yanling->$itemtype->itemuid != $yanling_uid) {
            Err(ErrCode::store_noequip_err);
        }
        $collectHeros->$herouid->equip->weapon->itemuid = 0;                    # 卸下

        UserProc::updateUserInfo($req);                                         # 回写数据
        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret);                                                 // 返回 
//        StoreProc::CheckItemNum($req);
        return $resp;
    }

    /**
     * [6410] 给英雄穿装备
     * @param req $req
     * @return type
     */
    static function WearEquipToHero($req) {
        $user = $req->userInfo->game;                                           # user引用
        list($itemtype, $equipuid, $herouid) = $req->paras;                     # 提取参数: 装备类型, 装备的UID, 英雄的UID 


        if (!CommUtil::isPropertyExists($user->store->equipment, $equipuid)) {  # 检测是否存在该装备
            Err(ErrCode::store_itemno_err);
        }
        $equipVo = $user->store->equipment->$equipuid;                          # 取装备对象
        if ($equipVo->herouid > 0) {                                            # 检测该装备是否装备到其他英雄身上 
            if ($equipVo->herouid != $herouid) {
                Err(ErrCode::store_equipWeared_err);
            }
            $user->store->equipment->$equipuid->herouid = 0;                    # 清理原来已经装备的言灵的反指向
        }
        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {                                                   # 防御对象为空
            Err(ErrCode::err_innerfault);
        }
        if (!CommUtil::isPropertyExists($collectHeros, $herouid)) {             # 检查是否存在需要装备的英雄
            Err(ErrCode::hero_no);
        }

        $user->store->equipment->$equipuid->herouid = $herouid;                 # 装备上添加反向引用, 避免查询时的循环
        $oldEquipId = 0;
        switch ($itemtype) {                                                    # 添加或替换英雄该部位的装备
            case 1:                                                             # 武器   
                $oldEquipId = $collectHeros->$herouid->equip->weapon->itemuid;
                $collectHeros->$herouid->equip->weapon->itemuid = $equipuid;
                break;
            case 2:                                                             # 防具 
                $oldEquipId = $collectHeros->$herouid->equip->armor->itemuid;
                $collectHeros->$herouid->equip->armor->itemuid = $equipuid;
                break;
            case 3:                                                             # 饰品   
                $oldEquipId = $collectHeros->$herouid->equip->ring->itemuid;
                $collectHeros->$herouid->equip->ring->itemuid = $equipuid;
                break;
            default :
                Err(ErrCode::store_equip_type);
                break;
        }
        if ($oldEquipId > 0) {
            $user->store->equipment->$oldEquipId->herouid = 0;
        }

        UserProc::updateUserInfo($req);                                         // 5.回写数据
        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret);                                                 // 返回 
//        StoreProc::CheckItemNum($req);
        return $resp;
    }

    /**
     * [6411] 给英雄脱装备
     * @param req $req
     * @return type
     */
    static function UnWieldEquip($req) {
        $user = $req->userInfo->game;                                           # user引用
        list($itemtype, $equipuid, $herouid) = $req->paras;                     # 提取参数: 装备类型, 装备的UID, 拥有该装备的英雄的UID 

        $collectHeros = $user->heros->collectHeros;
        if (!$collectHeros) {
            Err(ErrCode::err_innerfault);
        }
        if (!CommUtil::isPropertyExists($collectHeros, $herouid)) {             # 检测是否存在拥有该装备的英雄
            Err(ErrCode::hero_no);
        }
        if (!CommUtil::isPropertyExists($user->store->equipment, $equipuid)) {  # 检测是否存在该装备
            Err(ErrCode::store_itemno_err);
        }
        if ($user->store->equipment->$equipuid->herouid == $herouid) {          # 取装备对象
            $user->store->equipment->$equipuid->herouid = 0;
        }
        switch ($itemtype) {                                                    # 检测该装备是否装备在该英雄身上
            case 1:                                                             # 武器 
                if ($collectHeros->$herouid->equip->weapon->itemuid != $equipuid) {
                    Err(ErrCode::store_noequip_err);
                }
                $collectHeros->$herouid->equip->weapon->itemuid = 0;            # 卸下
                break;
            case 2:                                                             # 防具
                if ($collectHeros->$herouid->equip->armor->itemuid != $equipuid) {
                    Err(ErrCode::store_noequip_err);
                }
                $collectHeros->$herouid->equip->armor->itemuid = 0;
                break;
            case 3:                                                             # 饰品
                if ($collectHeros->$herouid->equip->ring->itemuid != $equipuid) {
                    Err(ErrCode::store_noequip_err);
                }
                $collectHeros->$herouid->equip->ring->itemuid = 0;
                break;
            default :
                Err(ErrCode::store_equip_type);
        }
        UserProc::updateUserInfo($req);                                         # 回写数据
        $ret = array('resp' => "succeed!");
        $resp = Resp::ok($ret);                                                 // 返回 
//        StoreProc::CheckItemNum($req);
        return $resp;
    }

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

    /**
     * 将宝箱放入仓库
     * @param StoreModel $store
     * @param int $boxId 宝箱类型编号
     * @param int $num 数量
     */
    static function putBoxexInStore($store, $boxId, $num) {
        if (CommUtil::isPropertyExists($store->boxes, $boxId)) {
            $store->boxes->$boxId += $num;
        } else {
            $store->boxes->$boxId = $num;
        }
    }

    public static function CheckHeroNum($req) {
        $heroNum = 0;
        $gamedata = $req->userInfo->game;

        $HeroObj = $gamedata->heros->collectHeros;
        if ($HeroObj) {
            foreach ($HeroObj as $value) {
                $heroNum++;
            }
        }
        return $heroNum;
    }

    /**
     * 检查背包中物品的个数
     * @param type $req
     * @return int
     */
    public static function CheckItemNum($req) {
        $ItemObj = $req->userInfo->game->store->items;
        $EquipObj = $req->userInfo->game->store->equipment;
        $SegementObj = $req->userInfo->game->store->segement;
        $HeroObj = $req->userInfo->game->heros->collectHeros;
        $ItemNum = 0;
        ////检查宝石类可叠加物品的格子占用
        if ($ItemObj) {
            foreach ($ItemObj as $value) {
                $ItemNum++;
            }
        }
        if ($SegementObj) {
            foreach ($SegementObj as $value) {
                $ItemNum++;
            }
        }
        ////检测装备类物品格子占用
        if ($EquipObj) {
            foreach ($EquipObj as $value) {
                $ItemNum++;
            }
        }
        ////检测英雄装备到身上的情况,装备到英雄身上不占格子,要减去.
        if ($HeroObj) {
            foreach ($HeroObj as $value) {
                //  echo var_dump($HeroObj);

                $HeroEquipId = $value->equip->weapon->itemuid;
                if ($HeroEquipId > 0) {
                    $ItemNum--;
                }
                $HeroEquipId = $value->equip->armor->itemuid;
                if ($HeroEquipId > 0) {
                    $ItemNum--;
                }
                $HeroEquipId = $value->equip->ring->itemuid;
                if ($HeroEquipId > 0) {
                    $ItemNum--;
                }
            }
        }
        $req->userInfo->game->privateState->ItemNum = $ItemNum;
        return $ItemNum;
    }

    /**
     * 获取物品格子的上限值
     * @param type $req
     * @return int 上限数值
     */
    public static function GetItemMaxNum($req) {
        $g = glc();
        if (!CommUtil::isPropertyExists($req->userInfo->game->privateState, "maxItemNum")) {
            $req->userInfo->game->privateState->maxItemNum = $g->Item_Packet_MaxNum;
        }
        return $req->userInfo->game->privateState->maxItemNum;
    }

    public static function AddPacketNum($req) {
        $g = glc();
        //    $user = $req->userInfo->game; # user引用
        if (!CommUtil::isPropertyExists($req->userInfo->game->privateState, "maxItemNum")) {
            $req->userInfo->game->privateState->maxItemNum = $g->Item_Packet_MaxNum;
        }
        $costCash = $g->Item_Packet_NumCostCash;

        $bDeal = false;
        if ($costCash > 0) {
            if ($req->userInfo->game->cash < $costCash) {
                Err(ErrCode::notenough_spar);
            }
            $bDeal = UserGameModel::Consume_Cash($req->userInfo->game, $costCash);
        } else {
            Err(ErrCode::paras_err);
        }

        //6.进行消耗
        if ($bDeal) {
            $req->userInfo->game->privateState->maxItemNum += 10;
            UserProc::updateUserInfo($req);
            $result = ObjectInit();
            $result->maxItemNum = $req->userInfo->game->privateState->maxItemNum;
            $resp = Resp::ok($result);
        }
        StoreProc::CheckItemNum($req);
        return $resp;
    }

// </editor-fold>
//
// -------------- 已废弃的代码 -------------------------------
//
// <editor-fold defaultstate="collapsed" desc="  --- 已废弃的代码 ---  ">
//

    /**
     * 符石放入仓库
     * @param type $itemId
     * @param MapModel $map
     */
    static function putStoneInStore($itemId, $itemNum, &$map) {
        if (!CommUtil::isPropertyExists($map->store, "stones")) {
            $map->store->stones = ObjectInit();
        }
        if (CommUtil::isPropertyExists($map->store->stones, $itemId)) {
            $map->store->stones->$itemId += $itemNum;
        } else {// 如果仓库中没有这种元素，则其数目置1
            $map->store->stones->$itemId = $itemNum;
        }
    }

// </editor-fold>
//
// <editor-fold defaultstate="collapsed" desc="   出售   ">
//
//       /**
//     * 从仓库出售可叠加物品
//     * @param RequestVo $req
//     * @return type
//     */
//    static function sellGemFromStore($req)
//    {
//        $resp = new ResponseVo();
//        $mem = $req->mem;
//      //  $user = $req->userInfo->user;
//        $store = $req->userInfo->game->store; //$req->userInfo->game->store->items
////客户端参数解析
//        $type = $req->paras[0]; //1=神兽 2=建筑   //需要判断是否叠加
//        $itemId = $req->paras[1]; // 注意：这里不是单体的id，而是物种的id
//        $count = intval($req->paras[2]);  // 数量
//
//       ////0是type 1是itemid,2是uid,3是数量
//
//        if (4 == $type) {  // 从仓库出售宝石 出售可叠加的物品
//
//            $ok = StoreProc::removeItemFromStore($store, $itemId, $count); // 支持移除指定数量
//
////1.如果仓库道具移出时出错，则直接返回错误
//            if ($ok != ErrCode::succeed) {
//                $resp = ResponseVo::ErrResponse($req, $ok);
//
//            } else {
//             //   echo "弄弄";
//                $gem = ConstProc::getItemConst ($mem, $itemId);
//                echo var_export($gem);
////2.检测是否存在该物品的原始物种
//                if ($gem == null) {
//                    $resp = ResponseVo::ErrResponse($req, ErrCode::err_godpet_noconst);
//                } else {
//                      // 发金币
//
//                     UserGameModel::Add_Gold($mem, $req->userInfo->game,$gem->maijia *$count );
//
//                   $resp = ResponseVo::RetResponse($req, "succeed!");
//
//                    UserProc::updateUserInfo($req);
//
//                }
//            }
//        } else if (1 == $type) { # 建筑  // 其它
//            if ($count > 1) {
//                $resp = ResponseVo::ErrResponse($req, ErrCode::err_msg_paras);
//            } else {
//                $ok = StoreProc::removeFromStore($itemId, $map); # 从仓库移除
//                if ($ok) {//1.如果仓库道具移出时出错，则直接返回错误
//                    $resp = ResponseVo::ErrResponse($req, ErrCode::err_store_removefail);
//                } else {
//                    $build = ConstProc::getBuildConst($mem, $itemId);
//                    if (build == null) { //2.检测是否存在建筑的原始数据
//                        $resp = ResponseVo::errResponse($req->oid, $req->msgid, ErrCode::err_build_noconst);
//                    } else {
//                        UserModel::Add_Gold($user, JsonUtil::decode($build->sellPrice)->g); # 加金币
//                        $resp = ResponseVo::myRetResponse($req, "succeed!"); # 返回值
//                        //成就触发--获取金币
//                       /// AchievementProc::dealAchievementState($req, $resp, AchievementProc::Gold);
//                        UserProc::updateUserInfo($req);
//                    }
//                }
//            }
//        }
//    }
//
//
//
//
//
//
//

    /**
     * 出售单一的物品
     * @param Req $req
     * @return type
     */
    static function sellItem($req) {
        $resp = new Resp();
        $mem = $req->mem;
        //  $user = $req->userInfo->user;
        $store = $req->userInfo->game->store; //$req->userInfo->game->store->items
//客户端参数解析
        $type = $req->paras[0]; //1=神兽 2=建筑   //需要判断是否叠加
        $itemId = $req->paras[1]; // 注意：这里不是单体的id，而是物种的id
        if ($type > 3) {
            $count = intval($req->paras[2]);  // 数量
            $uid = 0;
        } else {
            $count = 1;
            $uid = $req->paras[2];
        }//物品的uid
        ////0是type 1是itemid,2是uid或者是数量

        if ($type > 3 && $type < 8) {  // 从仓库出售宝石 出售可叠加的物品
            $ok = StoreProc::removeItemFromStore($store, $itemId, $count); // 支持移除指定数量
//1.如果仓库道具移出时出错，则直接返回错误
            if ($ok != ErrCode::ok) {
                Err($ok);
            }
            //   echo "弄弄";
            $gem = GameConfig::item_getItem($itemId); //  ConstProc::getItemConst($itemId);
            echo var_export($gem);
//2.检测是否存在该物品的原始物种
            if ($gem == null) {
                Err(ErrCode::err_godpet_noconst);
            }
            // 发金币

            UserGameModel::Add_Gold($mem, $req->userInfo->game, $gem->maijia * $count);
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret);
            UserProc::updateUserInfo($req);
        } else if ($type == 8) {  // 从仓库出售碎片 出售可叠加的物品
            $ok = StoreProc::removeItemFromStore($store, $itemId, $count); // 支持移除指定数量
//1.如果仓库道具移出时出错，则直接返回错误
            if ($ok != ErrCode::ok) {
                Err($ok);
            }
            //      echo "弄弄";
            $gem = GameConfig::segment_getItem($itemId); // ConstProc::getItemConst($itemId);
            //   echo var_export($gem);
//2.检测是否存在该物品的原始物种
            if ($gem == null) {
                Err(ErrCode::err_godpet_noconst);
            }
            // 发金币

            UserGameModel::Add_Gold($mem, $req->userInfo->game, $gem->saleGoldPrice * $count);
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret);
            UserProc::updateUserInfo($req);
        } else if ($type < 4 && $type > 0) { # 这里是装备
            if ($count > 1) {
                Err(ErrCode::paras_err);
            }
            if ($uid < 1) {
                Err(ErrCode::paras_err);
            }
            $ok = StoreProc::removeEquipFromStore($uid, $itemId, $req); # 从背包移除
            if (!$ok) {//1.如果背包道具移出时出错，则直接返回错误
                Err(ErrCode::store_removefail);
            }
            $item = GameConfig::item_getItem($itemId); //  ConstProc::getItemConst($itemId);
            if ($item == null) { //2.检测是否存在装备的原始数据
                Err(ErrCode::err_const_no);
            }
            UserGameModel::Add_Gold($mem, $req->userInfo->game, $item->maijia);

            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret); //返回必须是object 
            UserProc::updateUserInfo($req);
        } else {
            Err(ErrCode::paras_err);
        }
        StoreProc::CheckItemNum($req);
        return $resp;
    }

    /**
     * 卖出一堆物品时候，检测每个单个物品是否符合卖的条件
     * @param Req $req
     * @return type
     */
    static function preSellSingleFromStore(&$req, $type, $itemId, $count, $uid) {
        $resp = new Resp();
        $mem = $req->mem;
        //  $user = $req->userInfo->user;
        $store = $req->userInfo->game->store; //$req->userInfo->game->store->items
//客户端参数解析
        ////0是type 1是itemid,2是uid或者是数量

        if ($type > 3 && $type < 8) {  // 从仓库出售宝石 出售可叠加的物品
            echoLine(":fs::");
            $ok = StoreProc::removeItemFromStore($store, $itemId, $count); // 支持移除指定数量
//1.如果仓库道具移出时出错，则直接返回错误
            if ($ok != ErrCode::ok) {
                Err($ok);
            }
            echo "弄弄";

            $gem = GameConfig::item_getItem($itemId); // ConstProc::getItemConst($itemId);
            echo var_export($gem);
//2.检测是否存在该物品的原始物种
            if ($gem == null) {
                Err(ErrCode::err_godpet_noconst);
            }
            // 发金币

            UserGameModel::Add_Gold($mem, $req->userInfo->game, $gem->maijia * $count);
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret);
        } else if ($type == 8) {  // 从仓库出售碎片 出售可叠加的物品
            $ok = StoreProc::removeItemFromStore($store, $itemId, $count); // 支持移除指定数量
//1.如果仓库道具移出时出错，则直接返回错误
            if ($ok != ErrCode::ok) {
                Err($ok);
            }
            //      echo "弄弄";
            $gem = GameConfig::segment_getItem($itemId); // ConstProc::getItemConst($itemId);
            //   echo var_export($gem);
//2.检测是否存在该物品的原始物种
            if ($gem == null) {
                Err(ErrCode::err_godpet_noconst);
            }
            // 发金币

            UserGameModel::Add_Gold($mem, $req->userInfo->game, $gem->saleGoldPrice * $count);
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret);
        } else if ($type < 4 && $type > 0) { # 这里是装备
            if ($count > 1) {
                Err(ErrCode::paras_err);
            }
            if ($uid < 1) {
                Err(ErrCode::paras_err);
            }

            $ok = StoreProc::removeEquipFromStore($uid, $itemId, $req); # 从背包移除
            if (!$ok) {//1.如果背包道具移出时出错，则直接返回错误
                Err(ErrCode::store_removefail);
            }
            $item = GameConfig::item_getItem($itemId); // ConstProc::getItemConst($itemId);
            if ($item == null) { //2.检测是否存在装备的原始数据
                Err(ErrCode::err_const_no);
            }
            UserGameModel::Add_Gold($mem, $req->userInfo->game, $item->maijia);
            $ret = array('resp' => "succeed!");
            $resp = Resp::ok($ret); //返回必须是object
        } else {
            Err(ErrCode::paras_err);
        }

        return $resp;
    }

    /**
     * 从背包出售多个物品
     * @param Req $req
     * @return type
     */
    static function sellMultiItemFromStore($req) {
        $resp = new Resp();




        $obj = $req->paras[0]; //获取物品的结构数组

        echo var_export($obj);

        foreach ($obj as $value) {

            $type = $value[0];
            $itemId = $value[1];
            ////先判断一下物品类型，如果是可叠加的，就按数量取值，如果是不可叠加的就按uid取值
            if ($type > 3) {
                $count = intval($value[2]);  // 数量
                $uid = 0;
            } else {
                $count = 1;
                $uid = $value[2];
            }//物品的uid
            $resp = StoreProc:: preSellSingleFromStore($req, $type, $itemId, $count, $uid);
            echo var_export($resp);

            #sellitem();
        }

        if (0 == $resp->err) {
            UserProc::updateUserInfo($req);
        }

        // echo var_export($resp);
        StoreProc::CheckItemNum($req);
        return $resp;
    }

// </editor-fold>
//
}