武器突破以及精炼功能

gdconf/item_data.go

@@ -2,8 +2,10 @@ package gdconf
 
 import (
 	"fmt"
-
+	"hk4e/common/constant"
 	"hk4e/pkg/logger"
+	"strconv"
+	"strings"
 
 	"github.com/jszwec/csvutil"
 )
@@ -20,13 +22,16 @@ type ItemData struct {
 	MaterialType int32  `csv:"MaterialType,omitempty"` // 材料类型
 	Use1Param1   string `csv:"Use1Param1,omitempty"`   // [使用]1参数1
 	// 武器
-	EquipType    int32 `csv:"EquipType,omitempty"`    // 武器种类
+	EquipType          int32  `csv:"EquipType,omitempty"`         // 武器种类
-	EquipLevel   int32 `csv:"EquipLevel,omitempty"`   // 武器阶数
+	EquipLevel         int32  `csv:"EquipLevel,omitempty"`        // 武器阶数
-	SkillAffix1  int32 `csv:"SkillAffix1,omitempty"`  // 初始技能词缀1
+	SkillAffix1        int32  `csv:"SkillAffix1,omitempty"`       // 初始技能词缀1
-	SkillAffix2  int32 `csv:"SkillAffix2,omitempty"`  // 初始技能词缀2
+	SkillAffix2        int32  `csv:"SkillAffix2,omitempty"`       // 初始技能词缀2
-	PromoteId    int32 `csv:"PromoteId,omitempty"`    // 武器突破ID
+	PromoteId          int32  `csv:"PromoteId,omitempty"`         // 武器突破ID
-	EquipBaseExp int32 `csv:"EquipBaseExp,omitempty"` // 武器初始经验
+	EquipBaseExp       int32  `csv:"EquipBaseExp,omitempty"`      // 武器初始经验
-	SkillAffix   []int32
+	AwakenMaterial     int32  `csv:"AwakenMaterial,omitempty"`    // 武器精炼道具
+	AwakenCoinCostStr  string `csv:"AwakenCoinCostStr,omitempty"` // 精炼摩拉消耗
+	SkillAffix         []int32
+	AwakenCoinCostList []uint32
 	// 圣遗物
 	ReliquaryType int32 `csv:"ReliquaryType,omitempty"` // 圣遗物类别
 }
@@ -51,6 +56,19 @@ func (g *GameDataConfig) loadItemData() {
 			if itemData.SkillAffix2 != 0 {
 				itemData.SkillAffix = append(itemData.SkillAffix, itemData.SkillAffix2)
 			}
+			// 武器精炼摩拉消耗列表读取转换
+			if itemData.Type == int32(constant.ItemTypeConst.ITEM_WEAPON) && itemData.AwakenCoinCostStr != "" {
+				tempCostList := strings.Split(strings.ReplaceAll(itemData.AwakenCoinCostStr, " ", ""), "#")
+				itemData.AwakenCoinCostList = make([]uint32, 0, len(tempCostList))
+				for _, s := range tempCostList {
+					costCount, err := strconv.Atoi(s)
+					if err != nil {
+						logger.Error("cost count to i err, %v", err)
+						return
+					}
+					itemData.AwakenCoinCostList = append(itemData.AwakenCoinCostList, uint32(costCount))
+				}
+			}
 			g.ItemDataMap[itemData.ItemId] = itemData
 		}
 	}

gdconf/table_struct_mapping.json

@@ -531,6 +531,16 @@
         "field_name": "EquipBaseExp",
         "field_type": "int32",
         "origin_name": "武器初始经验"
+      },
+      {
+        "field_name": "AwakenMaterial",
+        "field_type": "int32",
+        "origin_name": "精炼道具"
+      },
+      {
+        "field_name": "AwakenCoinCostStr",
+        "field_type": "string",
+        "origin_name": "精炼摩拉消耗"
       }
     ]
   },

gs/game/player_avatar.go

@@ -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{

gs/game/player_weapon.go

@@ -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
 	}
 	// 计算使用材料强化武器后将会获得的经验数

gs/game/route_manager.go

@@ -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) {

gs/game/world_manager.go

@@ -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    // 本服务器最大多人世界数量
 )
 

gs/model/item.go

@@ -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
+	}
 }

gs/model/weapon.go

@@ -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
+}

protocol/cmd/cmd_id_proto_obj_map.go

@@ -242,6 +242,10 @@ func (c *CmdProtoMap) registerAllMessage() {
 	c.registerMessage(CalcWeaponUpgradeReturnItemsRsp, &proto.CalcWeaponUpgradeReturnItemsRsp{}) // 计算武器升级返回矿石响应
 	c.registerMessage(WeaponUpgradeReq, &proto.WeaponUpgradeReq{})                               // 武器升级请求
 	c.registerMessage(WeaponUpgradeRsp, &proto.WeaponUpgradeRsp{})                               // 武器升级响应
+	c.registerMessage(WeaponPromoteReq, &proto.WeaponPromoteReq{})                               // 武器突破请求
+	c.registerMessage(WeaponPromoteRsp, &proto.WeaponPromoteRsp{})                               // 武器突破响应
+	c.registerMessage(WeaponAwakenReq, &proto.WeaponAwakenReq{})                                 // 武器精炼请求
+	c.registerMessage(WeaponAwakenRsp, &proto.WeaponAwakenRsp{})                                 // 武器精炼响应
 
 	// 商店
 	c.registerMessage(GetShopmallDataReq, &proto.GetShopmallDataReq{})       // 商店信息请求