mirrors2/hk4e
1
0
Fork 0
mirror of https://github.com/FlourishingWorld/hk4e.git synced 2026-02-16 23:22:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

武器突破以及精炼功能

Browse Source
This commit is contained in:
UnKownOwO
2023-02-05 16:01:48 +08:00
parent b2530509ab
commit 482a1f7af4
9 changed files with 356 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
gs/game/player_avatar.go
View File

@@ -93,7 +93,7 @@ func (g *GameManager) AvatarPromoteReq(player *model.Player, payloadMsg pb.Messa
g.CommonRetError(cmd.AvatarPromoteRsp, player, &proto.AvatarPromoteRsp{})
return
}
// 获取角色突破的配置表
// 获取角色突破等级的配置表
avatarPromoteConfig, ok := avatarPromoteDataMap[int32(avatar.Promote)]
if !ok {
logger.Error("avatar promote config error, promoteLevel: %v", avatar.Promote)
@@ -109,7 +109,7 @@ func (g *GameManager) AvatarPromoteReq(player *model.Player, payloadMsg pb.Messa
// 获取角色突破下一级的配置表
avatarPromoteConfig, ok = avatarPromoteDataMap[int32(avatar.Promote+1)]
if !ok {
logger.Error("avatar promote config error, promoteLevel: %v", avatar.Promote)
logger.Error("avatar promote config error, next promoteLevel: %v", avatar.Promote+1)
g.CommonRetError(cmd.AvatarPromoteRsp, player, &proto.AvatarPromoteRsp{}, proto.Retcode_RET_AVATAR_ON_MAX_BREAK_LEVEL)
return
}
@@ -146,7 +146,7 @@ func (g *GameManager) AvatarPromoteReq(player *model.Player, payloadMsg pb.Messa
return
}
// 消耗突破材料和摩拉
GAME_MANAGER.CostUserItem(player.PlayerID, costItemList)
g.CostUserItem(player.PlayerID, costItemList)
// 角色突破等级+1
avatar.Promote++
@@ -228,7 +228,7 @@ func (g *GameManager) AvatarUpgradeReq(player *model.Player, payloadMsg pb.Messa
return
}
// 消耗升级材料以及摩拉
GAME_MANAGER.CostUserItem(player.PlayerID, []*UserItem{
g.CostUserItem(player.PlayerID, []*UserItem{
{
ItemId: req.ItemId,
ChangeCount: req.Count,
@@ -487,7 +487,7 @@ func (g *GameManager) AvatarWearFlycloakReq(player *model.Player, payloadMsg pb.
func (g *GameManager) PacketAvatarEquipChangeNotify(avatar *model.Avatar, weapon *model.Weapon, entityId uint32) *proto.AvatarEquipChangeNotify {
itemDataConfig, ok := gdconf.CONF.ItemDataMap[int32(weapon.ItemId)]
if !ok {
logger.Error("item data config error, itemId: %v")
logger.Error("item data config error, itemId: %v", weapon.ItemId)
return new(proto.AvatarEquipChangeNotify)
}
avatarEquipChangeNotify := &proto.AvatarEquipChangeNotify{

276
gs/game/player_weapon.go
View File

@@ -60,6 +60,27 @@ func (g *GameManager) AddUserWeapon(userId uint32, itemId uint32) uint64 {
return weaponId
}
func (g *GameManager) CostUserWeapon(userId uint32, weaponIdList []uint64) {
player := USER_MANAGER.GetOnlineUser(userId)
if player == nil {
logger.Error("player is nil, uid: %v", userId)
return
}
storeItemDelNotify := &proto.StoreItemDelNotify{
GuidList: make([]uint64, 0, len(weaponIdList)),
StoreType: proto.StoreType_STORE_PACK,
}
for _, weaponId := range weaponIdList {
weaponGuid := player.CostWeapon(weaponId)
if weaponGuid == 0 {
logger.Error("weapon cost error, weaponId: %v", weaponId)
return
}
storeItemDelNotify.GuidList = append(storeItemDelNotify.GuidList, weaponGuid)
}
g.SendMsg(cmd.StoreItemDelNotify, userId, player.ClientSeq, storeItemDelNotify)
}
func (g *GameManager) PacketStoreItemChangeNotifyByWeapon(weapon *model.Weapon) *proto.StoreItemChangeNotify {
storeItemChangeNotify := &proto.StoreItemChangeNotify{
StoreType: proto.StoreType_STORE_PACK,
@@ -91,6 +112,241 @@ func (g *GameManager) PacketStoreItemChangeNotifyByWeapon(weapon *model.Weapon)
return storeItemChangeNotify
}
// WeaponAwakenReq 武器精炼请求
func (g *GameManager) WeaponAwakenReq(player *model.Player, payloadMsg pb.Message) {
logger.Debug("user weapon awaken, uid: %v", player.PlayerID)
req := payloadMsg.(*proto.WeaponAwakenReq)
// 确保精炼的武器与精炼材料不是同一个
if req.TargetWeaponGuid == req.ItemGuid {
logger.Error("weapon awaken guid equal, guid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_INVALID_TARGET)
return
}
// 是否拥有武器
weapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(req.TargetWeaponGuid)]
if !ok {
logger.Error("weapon error, weaponGuid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 获取武器物品配置表
weaponConfig, ok := gdconf.CONF.ItemDataMap[int32(weapon.ItemId)]
if !ok {
logger.Error("weapon config error, itemId: %v", weapon.ItemId)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 摩拉数量是否足够
if player.GetItemCount(constant.ItemConstantConst.SCOIN) < weaponConfig.AwakenCoinCostList[weapon.Refinement] {
logger.Error("item count not enough, itemId: %v", constant.ItemConstantConst.SCOIN)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_SCOIN_NOT_ENOUGH)
return
}
// 武器精炼等级是否不超过限制
// 暂时精炼等级是写死的 应该最大精炼等级就是5级
if weapon.Refinement >= 4 {
logger.Error("weapon refinement ge 4, refinement: %v", weapon.Refinement)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_AWAKEN_LEVEL_MAX)
return
}
// 获取精炼材料物品配置表
// 精炼的材料可能是武器也可能是物品
itemDataConfig, ok := gdconf.CONF.ItemDataMap[int32(player.GetItemIdByItemAndWeaponGuid(req.ItemGuid))]
if !ok {
logger.Error("item data config error, itemGuid: %v", req.ItemGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 根据精炼材料的类型做不同操作
switch itemDataConfig.Type {
case int32(constant.ItemTypeConst.ITEM_WEAPON):
// 精炼材料为武器
// 是否拥有将被用于精炼的武器
foodWeapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(req.ItemGuid)]
if !ok {
logger.Error("weapon error, weaponGuid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 确保被精炼武器没有被任何角色装备
if foodWeapon.AvatarId != 0 {
logger.Error("food weapon has been wear, weaponGuid: %v", req.ItemGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_EQUIP_HAS_BEEN_WEARED)
return
}
// 消耗作为精炼材料的武器
g.CostUserWeapon(player.PlayerID, []uint64{foodWeapon.WeaponId})
case int32(constant.ItemTypeConst.ITEM_MATERIAL):
// 精炼材料为道具
// 是否拥有将被用于精炼的道具
item, ok := player.ItemMap[player.GetItemIdByGuid(req.ItemGuid)]
if !ok {
logger.Error("item error, itemGuid: %v", req.ItemGuid)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 武器的精炼材料是否为这个
if item.ItemId != uint32(weaponConfig.AwakenMaterial) {
logger.Error("awaken material item error, itemId: %v", item.ItemId)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{}, proto.Retcode_RET_ITEM_INVALID_TARGET)
return
}
// 消耗作为精炼材料的道具
g.CostUserItem(player.PlayerID, []*UserItem{
{
ItemId: item.ItemId,
ChangeCount: 1,
},
})
default:
logger.Error("weapon awaken item type error, itemType: %v", itemDataConfig.Type)
g.CommonRetError(cmd.WeaponAwakenRsp, player, &proto.WeaponAwakenRsp{})
return
}
// 消耗摩拉
g.CostUserItem(player.PlayerID, []*UserItem{
{
ItemId: constant.ItemConstantConst.SCOIN,
ChangeCount: weaponConfig.AwakenCoinCostList[weapon.Refinement],
},
})
weaponAwakenRsp := &proto.WeaponAwakenRsp{
AvatarGuid: 0,
OldAffixLevelMap: make(map[uint32]uint32),
TargetWeaponAwakenLevel: 0,
TargetWeaponGuid: req.TargetWeaponGuid,
CurAffixLevelMap: make(map[uint32]uint32),
}
// 武器精炼前的信息
for _, affixId := range weapon.AffixIdList {
weaponAwakenRsp.OldAffixLevelMap[affixId] = uint32(weapon.Refinement)
}
// 武器精炼等级+1
weapon.Refinement++
// 更新武器的物品数据
g.SendMsg(cmd.StoreItemChangeNotify, player.PlayerID, player.ClientSeq, g.PacketStoreItemChangeNotifyByWeapon(weapon))
// 获取持有该武器的角色
avatar, ok := player.AvatarMap[weapon.AvatarId]
// 武器可能没被任何角色装备 仅在被装备时更新面板
if ok {
weaponAwakenRsp.AvatarGuid = avatar.Guid
// 角色更新面板
player.InitAvatarFightProp(avatar)
}
// 武器精炼后的信息
weaponAwakenRsp.TargetWeaponAwakenLevel = uint32(weapon.Refinement)
for _, affixId := range weapon.AffixIdList {
weaponAwakenRsp.CurAffixLevelMap[affixId] = uint32(weapon.Refinement)
}
g.SendMsg(cmd.WeaponAwakenRsp, player.PlayerID, player.ClientSeq, weaponAwakenRsp)
}
// WeaponPromoteReq 武器突破请求
func (g *GameManager) WeaponPromoteReq(player *model.Player, payloadMsg pb.Message) {
logger.Debug("user weapon promote, uid: %v", player.PlayerID)
req := payloadMsg.(*proto.WeaponPromoteReq)
// 是否拥有武器
weapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(req.TargetWeaponGuid)]
if !ok {
logger.Error("weapon error, weaponGuid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 获取武器配置表
weaponConfig, ok := gdconf.CONF.ItemDataMap[int32(weapon.ItemId)]
if !ok {
logger.Error("weapon config error, itemId: %v", weapon.ItemId)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{})
return
}
// 获取武器突破配置表
weaponPromoteDataMap, ok := gdconf.CONF.WeaponPromoteDataMap[weaponConfig.PromoteId]
if !ok {
logger.Error("weapon promote config error, promoteId: %v", weaponConfig.PromoteId)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{})
return
}
// 获取武器突破等级的配置表
weaponPromoteConfig, ok := weaponPromoteDataMap[int32(weapon.Promote)]
if !ok {
logger.Error("weapon promote config error, promoteLevel: %v", weapon.Promote)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{})
return
}
// 武器等级是否达到限制
if weapon.Level < uint8(weaponPromoteConfig.LevelLimit) {
logger.Error("weapon level le level limit, level: %v", weapon.Level)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_WEAPON_LEVEL_INVALID)
return
}
// 获取武器突破下一级的配置表
weaponPromoteConfig, ok = weaponPromoteDataMap[int32(weapon.Promote+1)]
if !ok {
logger.Error("weapon promote config error, next promoteLevel: %v", weapon.Promote+1)
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_WEAPON_PROMOTE_LEVEL_EXCEED_LIMIT)
return
}
// 将被消耗的物品列表
costItemList := make([]*UserItem, 0, len(weaponPromoteConfig.CostItemMap)+1)
// 突破材料是否足够并添加到消耗物品列表
for itemId, count := range weaponPromoteConfig.CostItemMap {
costItemList = append(costItemList, &UserItem{
ItemId: itemId,
ChangeCount: count,
})
}
// 消耗列表添加摩拉的消耗
costItemList = append(costItemList, &UserItem{
ItemId: constant.ItemConstantConst.SCOIN,
ChangeCount: uint32(weaponPromoteConfig.CostCoin),
})
// 突破材料以及摩拉是否足够
for _, item := range costItemList {
if player.GetItemCount(item.ItemId) < item.ChangeCount {
logger.Error("item count not enough, itemId: %v", item.ItemId)
// 摩拉的错误提示与材料不同
if item.ItemId == constant.ItemConstantConst.SCOIN {
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_SCOIN_NOT_ENOUGH)
}
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_ITEM_COUNT_NOT_ENOUGH)
return
}
}
// 冒险等级是否符合要求
if player.PropertiesMap[constant.PlayerPropertyConst.PROP_PLAYER_LEVEL] < uint32(weaponPromoteConfig.MinPlayerLevel) {
logger.Error("player level not enough, level: %v", player.PropertiesMap[constant.PlayerPropertyConst.PROP_PLAYER_LEVEL])
g.CommonRetError(cmd.WeaponPromoteRsp, player, &proto.WeaponPromoteRsp{}, proto.Retcode_RET_PLAYER_LEVEL_LESS_THAN)
return
}
// 消耗突破材料和摩拉
g.CostUserItem(player.PlayerID, costItemList)
// 突破前的信息
oldPromote := weapon.Promote
// 武器突破等级+1
weapon.Promote++
// 更新武器的物品数据
g.SendMsg(cmd.StoreItemChangeNotify, player.PlayerID, player.ClientSeq, g.PacketStoreItemChangeNotifyByWeapon(weapon))
// 获取持有该武器的角色
avatar, ok := player.AvatarMap[weapon.AvatarId]
// 武器可能没被任何角色装备 仅在被装备时更新面板
if ok {
// 角色更新面板
player.InitAvatarFightProp(avatar)
}
weaponPromoteRsp := &proto.WeaponPromoteRsp{
TargetWeaponGuid: req.TargetWeaponGuid,
OldPromoteLevel: uint32(oldPromote),
CurPromoteLevel: uint32(weapon.Promote),
}
g.SendMsg(cmd.WeaponPromoteRsp, player.PlayerID, player.ClientSeq, weaponPromoteRsp)
}
// GetWeaponUpgradeReturnMaterial 获取武器强化返回的材料
func (g *GameManager) GetWeaponUpgradeReturnMaterial(overflowExp uint32) (returnItemList []*proto.ItemParam) {
returnItemList = make([]*proto.ItemParam, 0, 0)
@@ -277,7 +533,7 @@ func (g *GameManager) WeaponUpgradeReq(player *model.Player, payloadMsg pb.Messa
weapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(req.TargetWeaponGuid)]
if !ok {
logger.Error("weapon error, weaponGuid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.WeaponUpgradeRsp, player, &proto.WeaponUpgradeRsp{})
g.CommonRetError(cmd.WeaponUpgradeRsp, player, &proto.WeaponUpgradeRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 获取武器配置表
@@ -340,8 +596,20 @@ func (g *GameManager) WeaponUpgradeReq(player *model.Player, payloadMsg pb.Messa
return
}
}
// 校验作为升级材料的武器是否存在
costWeaponIdList := make([]uint64, 0, len(req.FoodWeaponGuidList))
for _, weaponGuid := range req.FoodWeaponGuidList {
foodWeapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(weaponGuid)]
if !ok {
logger.Error("food weapon error, weaponGuid: %v", weaponGuid)
g.CommonRetError(cmd.WeaponUpgradeRsp, player, &proto.WeaponUpgradeRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
}
costWeaponIdList = append(costWeaponIdList, foodWeapon.WeaponId)
}
// 消耗升级材料和摩拉
GAME_MANAGER.CostUserItem(player.PlayerID, costItemList)
g.CostUserItem(player.PlayerID, costItemList)
// 消耗作为升级材料的武器
g.CostUserWeapon(player.PlayerID, costWeaponIdList)
// 武器升级前的信息
oldLevel := weapon.Level
@@ -376,7 +644,7 @@ func (g *GameManager) WeaponUpgradeReq(player *model.Player, payloadMsg pb.Messa
})
}
// 给予玩家返回的矿石
GAME_MANAGER.AddUserItem(player.PlayerID, addItemList, false, 0)
g.AddUserItem(player.PlayerID, addItemList, false, 0)
weaponUpgradeRsp := &proto.WeaponUpgradeRsp{
CurLevel: uint32(weapon.Level),
@@ -395,7 +663,7 @@ func (g *GameManager) CalcWeaponUpgradeReturnItemsReq(player *model.Player, payl
weapon, ok := player.WeaponMap[player.GetWeaponIdByGuid(req.TargetWeaponGuid)]
if !ok {
logger.Error("weapon error, weaponGuid: %v", req.TargetWeaponGuid)
g.CommonRetError(cmd.CalcWeaponUpgradeReturnItemsRsp, player, &proto.CalcWeaponUpgradeReturnItemsRsp{})
g.CommonRetError(cmd.CalcWeaponUpgradeReturnItemsRsp, player, &proto.CalcWeaponUpgradeReturnItemsRsp{}, proto.Retcode_RET_ITEM_NOT_EXIST)
return
}
// 计算使用材料强化武器后将会获得的经验数

2
gs/game/route_manager.go
View File

@@ -133,6 +133,8 @@ func (r *RouteManager) initRoute() {
r.registerRouter(cmd.AvatarPromoteReq, GAME_MANAGER.AvatarPromoteReq)
r.registerRouter(cmd.CalcWeaponUpgradeReturnItemsReq, GAME_MANAGER.CalcWeaponUpgradeReturnItemsReq)
r.registerRouter(cmd.WeaponUpgradeReq, GAME_MANAGER.WeaponUpgradeReq)
r.registerRouter(cmd.WeaponPromoteReq, GAME_MANAGER.WeaponPromoteReq)
r.registerRouter(cmd.WeaponAwakenReq, GAME_MANAGER.WeaponAwakenReq)
}
func (r *RouteManager) RouteHandle(netMsg *mq.NetMsg) {

2
gs/game/world_manager.go
View File

@@ -18,7 +18,7 @@ import (
const (
ENTITY_NUM_UNLIMIT = false // 是否不限制场景内实体数量
ENTITY_MAX_SEND_NUM = 300 // 场景内最大实体数量
ENTITY_MAX_SEND_NUM = 200 // 场景内最大实体数量
MAX_MULTIPLAYER_WORLD_NUM = 10 // 本服务器最大多人世界数量
)

28
gs/model/item.go
View File

@@ -23,6 +23,28 @@ func (p *Player) GetItemGuid(itemId uint32) uint64 {
return itemInfo.Guid
}
func (p *Player) GetItemIdByGuid(itemGuid uint64) uint32 {
for _, item := range p.ItemMap {
if item.Guid == itemGuid {
return item.ItemId
}
}
return 0
}
func (p *Player) GetItemIdByItemAndWeaponGuid(guid uint64) uint32 {
for _, item := range p.ItemMap {
if item.Guid == guid {
return item.ItemId
}
}
for _, weapon := range p.WeaponMap {
if weapon.Guid == guid {
return weapon.ItemId
}
}
return 0
}
func (p *Player) GetItemCount(itemId uint32) uint32 {
prop, ok := constant.ItemConstantConst.VIRTUAL_ITEM_PROP[itemId]
if ok {
@@ -60,5 +82,9 @@ func (p *Player) CostItem(itemId uint32, count uint32) {
} else {
itemInfo.Count -= count
}
p.ItemMap[itemId] = itemInfo
if itemInfo.Count == 0 {
delete(p.ItemMap, itemId)
} else {
p.ItemMap[itemId] = itemInfo
}
}

9
gs/model/weapon.go
View File

@@ -79,3 +79,12 @@ func (p *Player) AddWeapon(itemId uint32, weaponId uint64) {
p.InitWeapon(weapon)
p.WeaponMap[weaponId] = weapon
}
func (p *Player) CostWeapon(weaponId uint64) uint64 {
weapon := p.WeaponMap[weaponId]
if weapon == nil {
return 0
}
delete(p.WeaponMap, weaponId)
return weapon.Guid
}