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_buyCollectHeroLimtCount: # [6312] 扩展英雄数量上限
// return HeroProc::BuyHeroMaxCountLimt($req);
//
# --------- 英雄技能 -----------
case CmdCode::cmd_hero_upgradeSkillLevel: # [6314] 英雄的技能升级
return HeroProc::UpgradeSkillLevel($req);
case CmdCode::cmd_hero_unlockSkill: # [6324] 英雄技能 - 解锁技能
return HeroProc::UnlockSkill($req);
case CmdCode::cmd_hero_skillLevel_onekeyupgrade: # [6325] 英雄技能 - 一键升级
return HeroProc::OnekeyUpgradeSkillLevel($req);
case CmdCode::cmd_hero_saveHeroTeamConfig: # [6315] 保存玩家战队数据
return HeroProc::SaveHeroTeamConfig($req);
//
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);
}
}
//
/**
* [6324] 英雄技能解锁
* @version 2020.1.13 至今未进行对接, 再次整理版
* 2019.12.10 加班弄完第一版
* @param req $req
*/
static function UnlockSkill($req) {
list($huid, $mainSkillId, $subSkillId) = $req->paras; # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能ID
$user = $req->userInfo->game; # user引用
$cHeros = $user->heros->collectHeros;
my_default_Obj($cHeros);
my_Assert(CommUtil::isPropertyExists($cHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要解锁的英雄
# # 2.判断英雄的该技能能否升级....
$targetHero = new Ins_UserHero($cHeros->$huid); # 直接类型识别
$targteHeroSkills = $targetHero->subSkills; # 取出这个英雄的技能数据
my_default_Arr($targteHeroSkills->$mainSkillId); # 保护子技能数组数据结构
my_Assert(!CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能已解锁"); # 子技能已经解锁
// if (!$targetHero->IsSkillUnlockAble($mainSkillId, $subSkillId)) { # 3.判断技能是否处于待解锁状态
// return Resp::err(ErrCode::hero_upgradeSkill_maxLevel);
// }
$sm = GameConfig::subSkill_getItem($subSkillId); # 4.取出该技能升级消耗的常量数据
my_Assert(null != $sm, ErrCode::err_const_no); # 找不到子技能配置数据
my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $sm->unlockCost), # # 5. 扣除金币消耗
ErrCode::notenough_gold_msg);
array_push($targteHeroSkills->$mainSkillId, $subSkillId); # 添加技能
$targetHero->subSkills = $targteHeroSkills;
$cHeros->$huid = $targetHero; # 回存Hero对象
UserProc::updateUserInfo(); # 回写数据
TaskProc::OnHeroUnlocSkill($targetHero->typeId, $subSkillId);
return Resp::ok($targetHero);
}
/**
* [6325] 英雄技能一键升级
* @param req $req
*/
static function OnekeyUpgradeSkillLevel($req) {
list($huid, $mainSkillId, $subSkillId, $targetSubSkillId, $costGold) = $req->paras; # 提取参数: 英雄的UID, 主技能ID, 要升级的子技能ID, 升级到的子技能ID, 升级要消耗的金币
$user = $req->userInfo->game; # user引用#
$collectHeros = $user->heros->collectHeros;
my_default_Obj($collectHeros); # 防御变量为空
my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要升级的英雄
# # 2.判断英雄的该技能能否升级....
$targetHero = new Ins_UserHero($cHeros->$huid); # 直接类型识别
$targteHeroSkills = $targetHero->subSkills; # 取出这个英雄的技能数据
my_default_Arr($targteHeroSkills->$mainSkillId); # 保护数据结构
my_Assert(CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能id错误"); # 子技能id
// if (!$targetHero->IsSkillUpdateAble($mainSkillId, $subSkillId)) { # 3.判断技能等级能否在继续升级了
// return Resp::err(ErrCode::hero_upgradeSkill_maxLevel);
// }
// $sm = GameConfig::subSkill_getItem($subSkillId); # 4.取出该技能升级消耗的常量数据
// if (null == $sm) {
// return \Resp::err(ErrCode::err_const_no, '找不到子技能配置数据');
// }
my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $costGold), ErrCode::notenough_gold_msg); # 5. 扣除金币消耗
unset($targteHeroSkills->$mainSkillId, $subSkillId); # 替换技能
array_push($targteHeroSkills->$mainSkillId, $targetSubSkillId);
$targetHero->subSkills = $targteHeroSkills;
$collectHeros->$huid = $targetHero; # 更新Hero数据
UserProc::updateUserInfo(); # 回写数据
return Resp::ok($targetHero);
}
/**
* [6314]英雄技能升级
* @param req $req
*/
static function UpgradeSkillLevel($req) {
list($huid, $mainSkillId, $subSkillId) = $req->paras; # 提取参数: 英雄的UID, 主技能Id, 要升级的子技能Id
$user = $req->userInfo->game; # user引用
$collectHeros = $user->heros->collectHeros;
my_default_Obj($collectHeros); # 防御变量为空
my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要升级的英雄
$targetHero = new Ins_UserHero($collectHeros->$huid);
$targteHeroSkills = $targetHero->subSkills; # 取出这个英雄的技能数据
my_Assert(CommUtil::isPropertyExists($targteHeroSkills, $mainSkillId), "玩家数据结构有问题."); # 主技能Id.
my_Assert(CommUtil::isInArray($targteHeroSkills->$mainSkillId, $subSkillId), "子技能id错误"); # 子技能id
my_Assert($targetHero->IsSkillUpdateAble($mainSkillId, $subSkillId), ErrCode::hero_upgradeSkill_maxLevel); # 3.判断技能等级能否在继续升级了
$sm = GameConfig::subSkill_getItem($subSkillId); # 4.取出该技能升级消耗的常量数据
my_Assert(null != $sm, ErrCode::err_const_no); # 找不到子技能配置数据
my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $sm->upgradeCost), ErrCode::notenough_gold_msg); # 5. 扣除金币消耗
unset($targteHeroSkills->$mainSkillId, $subSkillId); # 替换技能
array_push($targteHeroSkills->$mainSkillId, $sm->nextLevel_Id);
$targetHero->subSkills = $targteHeroSkills;
$collectHeros->$huid = $targetHero; # 更新hero数据
UserProc::updateUserInfo(); # 回写数据
return Resp::ok($targetHero);
}
//
//
//
/**
* 6304 英雄 升阶(消耗碎片)
* @param Req $req
*/
static function HeroStageUp($req) {
list($huid, $nextGrade) = $req->paras; # 提取参数: 英雄的UID,下一阶
$user = $req->userInfo->game; # user引用
$collectHeros = $user->heros->collectHeros; # 角色容器
my_default_Obj($collectHeros); # 保证不为null
my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no); # 1.检查是否存在要升级的英雄
$upHero = new Ins_UserHero($collectHeros->$huid); # 直接类型识别
my_Assert($upHero->grade < "S", ErrCode::hero_strength_maxstrengthlevel); # 已经达到S级
$heroUpgradeCostCfg = GameConfig::heroextra_level_getItem($upHero->typeId, $nextGrade);
my_Assert($heroUpgradeCostCfg, ErrCode::hero_strength_cost_const_no); # 1.检查是否存在这个升阶数据的模板
my_Assert(Data_UserGame::Consume_HeroSegment($user, # # 扣除碎片
$heroUpgradeCostCfg->segID, $heroUpgradeCostCfg->segNum), ErrCode::hero_segment_not_enough); # 碎片数量不足
# 扣除碎片成功
$upHero->grade = $nextGrade; # 5.强化英雄进行成功升阶
$collectHeros->$huid = $upHero; # 更新Hero数据
UserProc::updateUserInfo(); # 6.数据回存
$resp = Resp::ok($upHero);
SystemProc::insertHero_StageUp($req->zoneid, $req->uid, $user->baseInfo->name, # # 插入系统广播
GameConfig::hero_getItem($upHero->typeId)->name, $upHero->grade);
self::CalcUserFightPower($req->zoneid, $req->uid, $req->userInfo->game); # 跟新战力统计
TaskProc::OnHeroGradeUp($upHero->typeId, $upHero->grade);
var_dump($user->task->taskListDaily);
return $resp;
}
/**
* [6301] 英雄升级 - 消耗经验道具,获得经验(按照经验提升等级)
* @param Req $req
*/
static function HeroLevelUpCostExpItem($req) {
list($huid, $costItemId, $costNumber) = $req->paras; # 提取参数: 玩家英雄实例编号, 消耗的道具ID, 消耗的道具数量
$user = $req->userInfo->game; # user引用
$collectHeros = $user->heros->collectHeros; # 1. 检查是否存在要升级的英雄
my_default_Obj($collectHeros);
my_Assert(is_int($costNumber) && $costNumber >= 1, ErrCode::paras_err); # 参数合法性判断
my_Assert(CommUtil::isPropertyExists($collectHeros, $huid), ErrCode::hero_no); # 玩家拥有此英雄
$targetHero = new Ins_UserHero($collectHeros->$huid); # 智能感知辅助
my_Assert($targetHero->HeroCanLevelUp(), "英雄不可升级"); # 2. 检查玩家等级是否可以继续升级, Ps. 全局限制 + 指挥官等级限制
$myPacketItems = $user->store->items; # 检查道具的数量，在背包中是否充足
my_Assert(CommUtil::isPropertyExists($myPacketItems, $costItemId), ErrCode::store_itemnotenough); #
my_Assert($myPacketItems->$costItemId >= $costNumber, ErrCode::store_itemnotenough);
$totalEXP = 0; # 4.计算消耗的道具一共给多少经验值以及 一共要消耗多少金币
$costItemConst = GameConfig::item_stones_getItem($costItemId);
my_Assert(null != $costItemConst, ErrCode::err_const_no);
$totalEXP += $costItemConst->baseExp;
$heroConst = GameConfig::hero_getItem($targetHero->typeId); # 英雄模板数据
my_Assert(null != $heroConst, ErrCode::err_const_no, "英雄 模板数据");
if ($costItemConst->element != 0 # # 相同元素加成
&& $costItemConst->element == $heroConst->element) {
$totalEXP += $costItemConst->extraExp;
}
$totalEXP *= $costNumber; # 消耗N个道具
$targetHero = self:: HeroAddEXP($huid, $totalEXP); # 获得经验
$myPacketItems->$costItemId -= $costNumber; # 消耗道具
if ($myPacketItems->$costItemId < 0) {
$myPacketItems->$costItemId = 0;
}
$req->userInfo->game->store->items = $myPacketItems; # 更新背包数据
if ($targetHero->xp < 0) {
Err(ErrCode::err_innerfault, "英雄经验出错");
} else {
UserProc::updateUserInfo(); # 回写玩家数据
TaskProc::OnHeroImprove();
}
// var_dump($user->task->taskListDaily);
self::CalcUserFightPower($req->zoneid, $req->uid, $req->userInfo->game); # 跟新战力统计
return Resp::ok($targetHero);
}
//
//
//
/**
* [6315]保存队伍的战斗配置信息
* @param Req $req
*/
static function SaveHeroTeamConfig($req) {
$teamsetting = $req->paras[0]; # 配置信息json文件
$req->userInfo->game->heroTeamConfig = $teamsetting; # 更新配置
UserProc::updateUserInfo(); # 回写数据
# # 添加到战斗力隐藏榜单中, for pvp back matchers, -wg 2017.07.13
self::CalcTeamFightPower($req->zoneid, $req->uid, $req->userInfo->game);
return Resp::ok(array('result' => "succeed"));
}
//
//
//
/**
* 6323 解锁英雄
* @param type $req
*/
static function UnLockHeroByPieces($req) {
$user = $req->userInfo->game; # user引用
$heroModelId = $req->paras[0];
$piecesId = $req->paras[1]; # 英雄碎片的ID
$piecesNum = $req->paras[2];
if (!CommUtil::isPropertyExists($user->heros, "recordUnLockHeroDic")) {
$user->heros->recordUnLockHeroDic = ObjectInit();
}
$recordUnLockHeroDic = $user->heros->recordUnLockHeroDic;
#检查是不是已经解锁过了
$flag = 0;
if (!CommUtil::isPropertyExists($recordUnLockHeroDic, $heroModelId)) {
$recordUnLockHeroDic->$heroModelId = 0;
}
$flag = $recordUnLockHeroDic->$heroModelId;
if ($flag == 1) {
return Resp::err(ErrCode::hero_lockState);
}
#检查要解锁的英雄的常量配置是否存在
$heroCfg = GameConfig::hero_getItem($heroModelId);
if (!$heroCfg) {
return Resp::err(ErrCode::hero_const_no_err);
}
#检查需要消耗的碎片的常量配置是否存在
$piecesCfg = GameConfig::segment_getItem($piecesId);
if (!$piecesCfg) {
return Resp::err(ErrCode::err_const_no);
}
# 5.检查道具的数量是否充足
$myPacketItems = $user->store->segement;
$requirePiecesNum = $heroCfg->unlockConditionId;
# 检查道具数量是否充足
$enoughPieces = false;
if ($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum) {
if (!CommUtil::isPropertyExists($myPacketItems, $piecesId)) { # 检查碎片
$enoughPieces = false;
} else {
if ($myPacketItems->$piecesId < $requirePiecesNum) {
$enoughPieces = false;
} else {
$enoughPieces = true;
}
}
} else {
return Resp::err(ErrCode ::paras_err, "error pieces para" . "req" . $piecesId . "_" . $requirePiecesNum . "/" . $piecesId . "_" . $piecesNum);
}
if ($enoughPieces === true) {
# 6.进行 # # 消耗道具
$myPacketItems->$piecesId -= $requirePiecesNum;
if ($myPacketItems->$piecesId < 0) {
$myPacketItems->$piecesId = 0;
}
$recordUnLockHeroDic->$heroModelId = 1;
$req->user->heros->recordUnLockHeroDic = $recordUnLockHeroDic;
$req->userInfo->game->store->segement = $myPacketItems;
UserProc::updateUserInfo(); # 回写数据
return Resp::ok(array('result' => "OK")); //返回OK
} else {
return Resp::err(ErrCode::hero_godblood_notengoughitem);
}
}
/**
* [6322] 英雄神血
* @param Req $req
*/
static function UpGodBloodHeroByPieces($req) {
return Resp::err(ErrCode::err_method_obsoleted);
}
/**
* 英雄消耗碎片道具来升星
* @param req $req
*/
static function HeroUpStarByPieces($req) {
$resp = Resp::err(ErrCode::err_method_notimplement);
$g = glc();
$user = $req->userInfo->game; # user引用
$huid = $req->paras[0]; # 英雄的UID
$piecesId = $req->paras[1]; # 英雄碎片的ID
$piecesNum = $req->paras[2];
$diamondId = $req->paras[3]; # 升星石道具的ID
$diamondNum = $req->paras[4];
$moneyType = $req->paras[5]; # 升星消耗金钱的类型
$moneyNum = $req->paras[6];
# 1.检查是否存在要升级的英雄
$collectHeros = $user->heros->collectHeros;
if (!$collectHeros) {
$collectHeros = ObjectInit();
}
if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
return Resp::err(ErrCode::hero_no);
}
# 2.检查是否已经达到最大星级
isEditor() and $strengthHero = new Ins_UserHero();
$strengthHero = $collectHeros->$huid;
if ($strengthHero->curStar >= $g->Hero_Star_MaxStarLevel) {
return Resp::err(ErrCode::hero_star_maxstarlevel);
}
# 检查是否存在当前星级的升星消耗常量数据
$lvs = GameConfig::heroextra_star_getItem($strengthHero->curStar);
if (!$lvs) {
return Resp::err(ErrCode::hero_star_level_const_no_err);
}
# 3检查是否存在这个英雄的模板
$heroModelId = $strengthHero->typeId;
$heroCfg = GameConfig::hero_getItem($heroModelId);
if (!$heroCfg) {
return Resp::err(ErrCode::hero_const_no_err);
}
# 4.检查道具的数量是否充足以及消耗数量是否一致
$requireDiamondId = $lvs->itemid;
$requireDiamondNum = 0;
$arr_costDiamond = explode(";", $lvs->itemNum);
foreach ($arr_costDiamond as $value) {
$strArr = explode(",", $value);
if (count($strArr) == 2) {
$zhenxidu = $strArr[0];
$num = $strArr[1];
if ((int) $zhenxidu == $heroCfg->zhenxidu) {
$requireDiamondNum = (int) $num;
break;
}
}
}
#检查碎片是否正确
$requirePieceId = $piecesId;
$requirePiecesNum = 0;
$arr_costPieces = explode(";", $lvs->pieces);
foreach ($arr_costPieces as $value) {
$strArr = explode(",", $value);
if (count($strArr) == 2) {
$zhenxidu = $strArr[0];
$num = $strArr[1];
if ((int) $zhenxidu == $heroCfg->zhenxidu) {
$requirePiecesNum = (int) $num;
break;
}
}
}
$piecesCfg = GameConfig::item_getItem($piecesId);
if (!$piecesCfg) {
return Resp::err(ErrCode::err_const_no);
}
$pos = strpos($piecesCfg->icon, strval($heroModelId));
if ($pos === false) {
return Resp::err(ErrCode::paras_err, $piecesCfg->icon . "?" . $heroModelId);
}
# 4.检查道具的数量是否充足
$myPacketItems = $user->store->items;
#检查道具数量是否充足
$enoughDiamond = false;
$enoughPieces = false;
if ($requirePieceId == $piecesId && $requirePiecesNum == $piecesNum) {
#检查碎片
if (!CommUtil::isPropertyExists($myPacketItems, $requirePieceId)) {
$enoughPieces = false;
} else {
if ($myPacketItems->$requirePieceId < $requirePiecesNum) {
$enoughPieces = false;
} else {
$enoughPieces = true;
}
}
} else {
return Resp::err(ErrCode ::paras_err, #
"error pieces para" . "req" . $requirePieceId . "_" . $requirePiecesNum . "/" . $piecesId . "_" . $piecesNum);
}
if ($requireDiamondId == $diamondId && $requireDiamondNum == $diamondNum) {
#检查升星石
if (!CommUtil::isPropertyExists($myPacketItems, $requireDiamondId)) {
$enoughDiamond = false;
} else {
if ($myPacketItems->$requireDiamondId < $requireDiamondNum) {
$enoughDiamond = false;
} else {
$enoughDiamond = true;
}
}
} else {
return Resp::err(ErrCode ::paras_err, #
"error diamond para" . "req" . $requireDiamondId . "_" . $requireDiamondNum . "/" . $diamondId . "_" . $diamondNum);
}
if ($enoughDiamond === true && $enoughPieces === true) {
} else {
return Resp::err(ErrCode::hero_star_notengoughitem);
}
# 5.检查账户余额是否充足
#检查消耗是否正确
$enoughMoney = false;
$requireMoneyType = "";
$requireMoneyNum = 0;
$arr_costMoney = explode(";", $lvs->cost);
foreach ($arr_costMoney as $value) {
$strArr = explode(",", $value);
if (count($strArr) == 3) {
$zhenxidu = $strArr[0];
$type = $strArr[1];
$num = $strArr[2];
if ((int) $zhenxidu == $heroCfg->zhenxidu) {
$requireMoneyType = $type;
$requireMoneyNum = (int) $num;
break;
}
}
}
if ($requireMoneyType == $moneyType && $requireMoneyNum == $moneyNum) {
if ($requireMoneyType === "gold") {
if ($user->baseInfo->gold >= $requireMoneyNum) {
$enoughMoney = true;
} else {
return Resp::err(ErrCode::notenough_gold_msg);
}
} else if ($requireMoneyType === "cash") {
if ($user->baseInfo->cash >= $requireMoneyNum) {
$enoughMoney = true;
} else {
return Resp::err(ErrCode::notenough_cash_msg);
}
} else {
return Resp::err(ErrCode ::paras_err, $moneyType);
}
} else {
return Resp::err(ErrCode ::paras_err, "error money para");
}
$bDeal = false;
if ($enoughMoney === true) {
if ($requireMoneyType === "gold") {
$bDeal = Data_UserGame:: Consume_Gold($user->baseInfo, $requireMoneyNum);
} else if ($requireMoneyType === "cash") {
$bDeal = Data_UserGame:: Consume_Cash($user->baseInfo, $requireMoneyNum);
}
}
# 6.进行消耗升星
if ($bDeal) {
$strengthHero->curStar += 1;
# # 消耗道具
$myPacketItems->$requireDiamondId -= $requireDiamondNum;
if ($myPacketItems->$requireDiamondId < 0) {
$myPacketItems->$requireDiamondId = 0;
}
$myPacketItems->$requirePieceId -= $requirePiecesNum;
if ($myPacketItems->$requirePieceId < 0) {
$myPacketItems->$requirePieceId = 0;
}
$req->userInfo->game->store->items = $myPacketItems;
# 回写数据
UserProc::updateUserInfo();
$resp = Resp::ok($strengthHero);
# 推送系统消息
// SystemProc::insertHero_Star($req->zoneid, $req->uid, $user->name, $heroCfg->name, $strengthHero->curStar);
}
ActiveProc::ChangeTaskCount($req);
return $resp;
}
/**
* 英雄升星
* @param Req $req
*/
static function HeroUpStar($req) {
$resp = Resp::err(ErrCode::err_method_notimplement);
$g = glc();
$user = $req->userInfo->game; # user引用
$huid = $req->paras[0]; # 英雄的UID
$costHeroUids = $req->paras[1]; # 消耗掉的英雄UID
$costGold = $req->paras[2];
# 1.检查是否存在要升级的英雄
$collectHeros = $user->heros->collectHeros;
if (!$collectHeros) {
$collectHeros = ObjectInit();
}
if (!CommUtil::isPropertyExists($collectHeros, $huid)) {
return Resp::err(ErrCode::hero_no);
}
# 2.检查是否已经达到最大星级
isEditor() and $strengthHero = new Ins_UserHero();
$strengthHero = $collectHeros->$huid;
if ($strengthHero->curStar >= $g->Hero_Star_MaxStarLevel) {
return Resp::err(ErrCode::hero_star_maxstarlevel);
}
# 检查是否存在当前星级的升星消耗常量数据
$lvs = GameConfig::heroextra_star_getItem($strengthHero->curStar);
if (!$lvs) {
return Resp::err(ErrCode::hero_star_level_const_no_err);
}
# 3.检查消耗的英雄数量,以及玩家是否都存在这些英雄UID.
$arr_costUID = explode(",", $costHeroUids);
$checkCostHeroAllRight = true;
if (count($arr_costUID) != $g->Hero_Star_MaxCostHeroCardNum) {
$checkCostHeroAllRight = false;
} else {
foreach ($arr_costUID as $value) {
if ($value == "" || !CommUtil::isPropertyExists($collectHeros, $value)) {
$checkCostHeroAllRight = false;
break;
}
}
}
if (!$checkCostHeroAllRight) {
return Resp::err(ErrCode::hero_star_costhero);
}
# 获得升星英雄的模板数据,取得它的元素类型
# 检查是否存在这个英雄的模板
$heroModelId = $strengthHero->typeId;
$heroCfg = GameConfig::hero_getItem($heroModelId);
if (!$heroCfg) {
return Resp::err(ErrCode::hero_const_no_err);
}
$queryCostGold = $lvs->costGold;
$costItemNum = $lvs->costItemNum;
# 4.检查道具的数量是否充足
$myPacketItems = $user->store->items;
$checkHasEnoughItem = true;
$costItemId = "";
$record = ObjectInit();
$keyxxx = "Hero_Star_CostItem_" . $heroCfg->yuansu;
if (!CommUtil::isPropertyExists($g, $keyxxx)) {
return Resp::err(ErrCode::hero_star_noglobal_costitem);
} else {
$costItemId = $g->$keyxxx;
}
# 检查道具种类与消耗数量是否匹配
$arr_costitemids = explode(",", $costItemId);
$arr_costnums = explode(",", $costItemNum);
if (count($arr_costitemids) != count($arr_costnums)) {
return Resp::err(ErrCode::hero_star_conststr_itemnotmathnum);
}
$index = 0;
foreach ($arr_costitemids as $requireiItemId) {
$requireCount = 0;
if ($index < count($arr_costnums)) {
$requireCount = $arr_costnums[$index];
}
$index += 1;
# --判断对应的item是否存在相应的常量
# 检查是否存在当前星级的升星消耗常量数据
$itemcfg = GameConfig::item_getItem($requireiItemId);
if (!$itemcfg) {
return Resp::err(ErrCode::err_const_no);
} else {
if (!CommUtil::isPropertyExists($record, $requireiItemId)) {
$record->$requireiItemId = intval($requireCount);
} else {
$count = intval($record->$requireiItemId) + intval($requireCount);
$record->$requireiItemId = $count;
}
}
} foreach ($record as $key => $value) {
if ($value > 0) {
if (!CommUtil::isPropertyExists($myPacketItems, $key)) {
$checkHasEnoughItem = false;
break;
} else {
if ($myPacketItems->$key < $value) {
$checkHasEnoughItem = false;
break;
}
}
}
}
if (!$checkHasEnoughItem) {
return Resp::err(ErrCode::hero_star_notengoughitem);
}
# 5.检查金币是否充足
$bDeal = false; # 成交
if ($queryCostGold != $costGold) {
return Resp::err(ErrCode::paras_err);
} else {
if ($costGold > 0) {
if ($user->baseInfo->gold < $costGold) {
return Resp::err(ErrCode::notenough_gold_msg);
} else {
$bDeal = Data_UserGame:: Consume_Gold($user->baseInfo, $costGold);
}
} else if ($costGold == 0) {
$bDeal = true;
} else {
return Resp::err(ErrCode::paras_err);
}
}
# 6.进行消耗升星
if ($bDeal) {
$strengthHero->curStar += 1;
# 消耗卡牌
foreach ($arr_costUID as $value) {
if ($value == "") {
continue;
}
unset($collectHeros->$value);
}
# # 消耗道具
foreach ($record as $key => $value) {
$myPacketItems->$key -= $value;
if ($myPacketItems->$key < 0) {
$myPacketItems->$key = 0;
}
}
$req->userInfo->game->store->items = $myPacketItems;
# 回写数据
UserProc::updateUserInfo();
$resp = Resp::ok($strengthHero);
# 推送系统消息
// SystemProc::insertHero_Star($req->zoneid, $req->uid, $user->name, $heroCfg->name, $strengthHero->curStar);
}
ActiveProc::ChangeTaskCount($req);
return $resp;
}
//
/**
* 6321 购买英雄 消耗碎片
* @param req $req
*/
static function BuyHeroByCostPieces($req) {
list($heroModelId, $costType, $costMoneyNum, $piecesId, $piecesNum) = $req->paras; # 提取参数
$user = $req->userInfo->game; # user引用
$collectHeros = $user->heros->collectHeros;
my_default_Obj($collectHeros);
foreach ($collectHeros as $key => $value) { # 检查玩家是否已经拥有此类英雄
my_Assert($value->typeId != $heroModelId, ErrCode::hero_existSameHero_err);
}
$heroCfg = GameConfig::hero_getItem($heroModelId); # 英雄模板数据
my_Assert(null != $heroCfg, ErrCode::hero_const_no_err);
my_Assert($heroCfg->isCanBuy != 0, ErrCode::paras_err); # 是否可以直接购买
$piecesCfg = GameConfig::segment_getItem($piecesId); # 检查需要消耗的碎片的常量配置是否存在
my_Assert(null != $piecesCfg, ErrCode::err_store_itemnoconst);
$myPacketItems = $user->store->items;
$requirePiecesNum = $piecesCfg->mergePrototypeNeedNum;
my_Assert($heroModelId == $piecesCfg->prototypeData && $requirePiecesNum == $piecesNum, ErrCode::paras_err);
my_Assert(CommUtil::isPropertyExists($myPacketItems, $piecesId), ErrCode::hero_godblood_notengoughitem);
my_Assert($myPacketItems->$piecesId > $requirePiecesNum, ErrCode::hero_godblood_notengoughitem); # 检查碎片道具数量是否充足
switch ($costType) {
case "cash":
$realPrice = $heroCfg->cashPrice;
my_Assert($realPrice == $costMoneyNum, ErrCode::paras_err);
my_Assert($costMoneyNum >= 0, ErrCode::paras_err);
my_Assert(Data_UserGame::Consume_Cash($user->baseInfo, $costMoneyNum), ErrCode::err_msg_cashnotenough);
break;
case "gold":
$realPrice = $heroCfg->goldPrice;
my_Assert($realPrice == $costMoneyNum, ErrCode::paras_err);
my_Assert($costMoneyNum >= 0, ErrCode::paras_err);
my_Assert(Data_UserGame::Consume_Gold($user->baseInfo, $costMoneyNum), ErrCode::err_msg_goldnotenough);
break;
default :
Err(ErrCode::paras_err, "参数错误: [costType] " . $costType);
}
# 4.消耗来获得英雄
$myPacketItems->$piecesId -= $requirePiecesNum; # 消耗道具
$req->userInfo->game->store->items = $myPacketItems; # 回存背包
UserProc::updateUserInfo(); # 回写数据
$resp = HeroProc::GetHero($req);
SystemProc::GetHero($req->zoneid, $user->baseInfo, $heroModelId); # 插入系统广播消息
return $resp;
}
/**
* 购买玩家可以收集的英雄的数量上限
* @param req $req
* @return type
*/
static function BuyHeroMaxCountLimt($req) {
list($buyNum, $costCash) = $req->paras; # 提取参数: 数量, 花费钻石
$g = glc();
$user = $req->userInfo->game; # user引用
if (!CommUtil::isPropertyExists($user->heros, "maxCollectCount")) {
$user->heros->maxCollectCount = $g->Game_CollectHero_BasicMaxCount;
}
$index = ceil(($user->heros->maxCollectCount - $g->Game_CollectHero_BasicMaxCount) #
/ $g->Game_CollectHero_OneBuyLimtNum);
$arr = explode(",", $g->Game_CollectHero_BasicMaxPrice);
my_Assert($index < count($arr), "已达上限");
$realCost = $arr[$index];
my_Assert($realCost == $costCash, ErrCode::paras_err); # 参数错误
my_Assert($costCash >= 0, ErrCode::paras_err);
my_Assert(Data_UserGame::Consume_Cash($user, $costCash), ErrCode::err_msg_goldnotenough); # 扣除宝石
$user->heros->maxCollectCount += $buyNum; # 修改上限
UserProc::updateUserInfo();
return Resp::ok(array(
'maxCollectCount' => $user->heros->maxCollectCount
));
}
/**
* 获得英雄(测试已经OK)
* @param req $req
*/
static function GetHero($req) {
$heroModelId = $req->paras[0]; # 英雄的模板ID
$heroCfg = GameConfig::hero_getItem($heroModelId); # 1.检查是否存在这个英雄的模板
my_Assert(null != $heroCfg, ErrCode::hero_const_no_err);
$hero = self::AddHeroTFromStore($req, $heroModelId); # 创建英雄
UserProc::updateUserInfo();
$result = array('result' => "succeed", 'heros' => $hero); # 4. 设置返回值
return Resp::ok($result);
}
//
/**
* 获得一个英雄, 并且给他指定星级
* @param Req $req
* @param int $heromodelId 原型数据id
* @param int $star 星级
* @return Ins_UserHero
*/
static function AddHeroWithStar(&$req, $heromodelId, $star) {
$user = $req->userInfo->game;
my_Assert(null != $user, ErrCode::err_innerfault);
$collectHeros = $user->heros->collectHeros;
$uid = self::CreateNewGameHeroUID($collectHeros, $user->heros->recordMaxUID); # 先生成一个hero的UID
$user->heros->recordMaxUID = $uid;
$hero = self::getGameHeroModelInstance($heromodelId, $uid);
if ($star > 0) {
$hero->curStar = $star; # 设定star
}
$collectHeros->$uid = $hero; # 回写
$user->heros->collectHeros = $collectHeros; # 回写
return $hero; # 返回
}
/**
* 获得一个英雄(实例)
* @param req $req
* @param int $heromodelId
* @return type
*/
static function AddHeroTFromStore(&$req, $heromodelId) {
$user = $req->userInfo->game; # 玩家数据
$collectHeros = $user->heros->collectHeros; #
my_default_Obj($collectHeros);
$uid = self::CreateNewGameHeroUID($collectHeros, $user->heros->recordMaxUID); # 先生成一个UID
$user->heros->recordMaxUID = $uid; # 更新最大编号记录
$hero = self::getGameHeroModelInstance($heromodelId, $uid); # 3.创建英雄实例
$collectHeros->$uid = $hero;
$user->heros->collectHeros = $collectHeros;
return $hero;
}
/**
* 根据一个英雄的模板id,来获得一个英雄的实例数据
* @param string $heroModelId 模板数据ID
* @param string $uid 唯一ID
* @return Ins_UserHero
*/
static function getGameHeroModelInstance($heroModelId, $uid) {
$heroCfg = GameConfig::hero_getItem($heroModelId);
my_Assert(null != $heroCfg, ErrCode::err_const_no); # 检查是否存在这个英雄的模板
$hero = new Ins_UserHero();
// $hero->strengthLevel = $heroCfg->dengjie;
$hero->curStar = $heroCfg->xingji;
$hero->typeId = $heroCfg->heroId;
$hero->uid = $uid;
$hero->xp = 0;
$lvs = GameConfig::hero_levelexp_getItem($hero->level + 1);
$hero->maxXp = $lvs->requiredExp;
// 取可用武器中第一个初始化 -- 策划要求初始英雄要带有武器 -- 王刚 2020年1月
$wp = null;
$arr = (array) GameConfig::item_weapon();
krsort($arr); // todo: 排序不正常
foreach ($arr as $id => $mo) {
// isEditor() and $mo = new \sm_item_weapon();
if ($mo->hero_id == $hero->typeId) {
$wp = $mo;
break;
}
}
if (null != $wp) {
$req = req();
$wuid = StoreProc::PutEquipInStore($wp->typeId, $req);
$req->userInfo->game->store->equipment->$wuid->herouid = $uid;
$hero->equip->weapon = array("itemuid" => $wuid);
}
return $hero;
}
/**
* 查找下一个玩家获得英雄的UID
* @param type $req
* @return int
*/
static function CreateNewGameHeroUID($collectHeros, $oldMaxUID) {
$maxID = 10000;
my_default_Obj($collectHeros);
foreach ($collectHeros as $itemId => $hero) {
if ($itemId > $maxID) {
$maxID = $itemId;
}
}
$max = max($maxID, $oldMaxUID);
return $max + 1;
}
/**
* 英雄卡牌增加经验值
* @param string $heroUID
* @param int $totalEXP
*/
static function HeroAddEXP($heroUID, $totalEXP) {
$req = req();
$collectHeros = $req->userInfo->game->heros->collectHeros;
my_default_Obj($collectHeros);
my_Assert(CommUtil::isPropertyExists($collectHeros, $heroUID), ErrCode::hero_no); # 要升级的英雄不存在
$targetHero = new Ins_UserHero($collectHeros->$heroUID); # 英雄对象
$playerLimit = GameConfig::playerlevel_getItem($req->userInfo->game->baseInfo->level)->hero_max_level;
$maxLevel = min(glc()->Hero_Upgrade_BasicMaxLevel, $playerLimit); # 最大等级= max(英雄最高等级上限,玩家等级限制的上限)
if ($targetHero->level >= $maxLevel) {
return; # 已达顶级
}
$lvs = GameConfig::hero_levelexp_getItem($targetHero->level + 1);
$targetHero->xp += $totalEXP;
my_Assert($targetHero->xp >= 0, "[" . $req->uid . "] : HeroLevelUpgrade Exp is negative!");
$initLevel = $targetHero->level;
while ($targetHero->xp >= $lvs->needExp) {
if ($targetHero->level < $maxLevel) { # 如果未到达最大等级
$targetHero->level += 1;
if ($targetHero->level >= $maxLevel) {
$targetHero->xp = $lvs->needExp;
} else {
$targetHero->xp -= $lvs->needExp;
}
$lvs = GameConfig::hero_levelexp_getItem($targetHero->level + 1);
} else { # 如果已到达最大等级则仅补齐缺失的经验即可
$targetHero->xp = $targetHero->maxXp; # 经验不能超过最大值
break;
}
} // end while
my_Assert($targetHero->xp >= 0, "[" . $req->uid . "] : HeroLevelUpgrade Exp is negative!");
$collectHeros->$heroUID = $targetHero; # 更新英雄的数据
// if ($targetHero->level != $initLevel) {
TaskProc::OnHeroLevelUp($targetHero->typeId, $targetHero->level);
// }
return $targetHero; # 将英雄对象返回
}
//
/**
* [6306] 英雄-更改英雄的锁定状态
* (测试已经OK)
* @param type $req
*/
static function HeroChangelockstate($req) {
$gamedata = $req->userInfo->game;
$heroUID = $req->paras[0]; # 玩家英雄实例编号
$lockstate = $req->paras[1]; # 玩家英雄锁定状态
$collectHeros = $gamedata->heros->collectHeros;
my_default_Obj($collectHeros); # 默认值
my_Assert(CommUtil::isPropertyExists($collectHeros, $heroUID), ErrCode::hero_no);
// isEditor() and $hero = new UserHeroModel;
$hero = $collectHeros->$heroUID; # 1. 获取这个英雄的实例数据是
$hero->isLocked = $lockstate; # 2. 修改英雄状态
UserProc::updateUserInfo(); # 3. 保存玩家数据
return Resp::ok(ObjectInit()); # 4. 设置返回值
}
//
//
/**
* 计算队伍战斗力, 添加到战斗力隐藏榜单中, for pvp back matchers, -wg 2017.07.13
* @param type $zoneid
* @param type $uid
* @param Data_UserGame $user
* @return type
*/
static function CalcTeamFightPower($zoneid, $uid, $user) {
$teamsetting = $user->heroTeamConfig; # 战队配置
// var_dump($user);
$heros = $user->heros;
$teamCfg = JsonUtil::decode($teamsetting);
$tid = $teamCfg->curUseTeamID;
$team = $teamCfg->teamDic->$tid;
$fp = 0; # 返回值
if ($team) {
foreach ($team->heros as $hid) {
if ($hid) {
$hero = $heros->collectHeros->$hid;
if ($hero) {
// $fp += self::calcHeroFightPower($hero);
$h = new Ins_UserHero($hero);
$fp += $h->GetPower();
}
}
}
//todo: 这里的战斗力榜被总战力榜征用了key, 重启PVP机制时再
// gMem()->zadd(MemKey_GameRun::Game_FightPowerRank_zset($zoneid), array($uid => $fp));
}
return $fp;
}
/**
* 计算玩家总战斗力, 添加到战斗力榜单中
* @version 1.0.0 改造自原来的队伍战斗力统计方法 --gwang 2020.4.23
* @param type $zoneid
* @param type $uid
* @param Data_UserGame $user
* @return type
*/
static function CalcUserFightPower($zoneid, $uid, $user) {
$fp = 0; # 总战力:返回值
foreach ($user->heros->collectHeros as $hid => $hero) {
$h = new Ins_UserHero($hero);
$fp += $h->GetPower();
}
$key_fp = MemKey_GameRun::Game_FightPowerRank_zset($zoneid); # 战力榜
$key_log = MemKey_GameRun::Game_Rank_FPowerBreakLog_hash($zoneid); # 突破记录
gMem()->zadd($key_fp, array($uid => $fp)); # 更新战力记录
foreach (GameConfig::rankreward_fpower() as $condition => $reward) { # 遍历突破奖励数据
if ($fp >= $condition && !gMem()->hexists($key_log, $condition)) { # 判断是否达成突破奖励标准
gMem()->hset($key_log, $condition, $uid); # 添加突破记录
CornerSignEventProc::OnRanking_PowerReward_new(req());
}
}
TaskProc::OnUserFightPowerN($fp);
return $fp;
}
/**
* 计算hero战斗力, for pvp back matchers, -wg 2017.07.13
* @param Ins_UserHero $hero
* @return int
*/
static private function calcHeroFightPower($hero) {
$arr = explode(';', glc()->Battle_PowerFactor);
$factor = ArrayInit();
foreach ($arr as $s) {
$kv = explode(',', $s);
$k = $kv[0];
$v = $kv[1];
$factor[$k] = $v;
}
// todo: 哈哈, 奇葩的命名方案, 多处使用的命名不一致, 坑!
$a = (int) (self::calcHeroProperty($hero, 'hp') * $factor ["hp"] //
+ $hero->level * 10);
return $a;
}
/**
* 计算hero的属性,, for pvp back matchers, -wg 2017.07.13
* @param Ins_UserHero $hero
* @param type $propertyname
*/
private static function calcHeroProperty($hero, $propertyname) {
$val = 0;
if ($hero) {
$modle = GameConfig::hero_getItem($hero->typeId);
if ($modle) {
$extra = GameConfig::heroextra_level_getItem($hero->typeId, $hero->grade);
if ($extra) {
$val = (int) ($modle->$propertyname * (1 + $extra->$propertyname));
} else {
$val = $modle->$propertyname;
}
}
}
return $val;
}
//
//
}