package handler

//func (this *PlayerHandler) RigComponentSet(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigComponentSetReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Type == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if req.Id == 0 {
//		player.SetupRigComponent(req.Type, nil)
//		return
//	}
//
//	var componentTable = this.tables.RigComponent.Get(int(req.Id))
//	if componentTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	var component = player.RigComponent[uint32(componentTable.ItemId)]
//	if component == nil {
//		_ = player.TipNotice(proto.ErrItemNotFound)
//		return
//	}
//
//	if component.Type != req.Type {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if component.Setup {
//		_ = player.TipNotice(proto.ErrItemIsSetup)
//		return
//	}
//
//	player.SetupRigComponent(req.Type, component)
//	return
//}
//
//func (this *PlayerHandler) RigComponentUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigComponentUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var component = player.RigComponent[req.ItemId]
//	if component == nil {
//		_ = player.TipNotice(proto.ErrComponentUnlocked)
//		return
//	}
//
//	var componentTable = this.tables.RigComponent.Get(int(component.Id))
//	if componentTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if componentTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextComponentTable = this.tables.RigComponent.Get(componentTable.NextId)
//	if nextComponentTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	err = player.CheckMoney(proto.MoneyType(componentTable.MoneyType), uint32(componentTable.MoneyNum))
//	if err != nil {
//		_ = player.TipNotice(err)
//		return
//	}
//
//	player.ReduceMoney(proto.MoneyType(componentTable.MoneyType), uint32(componentTable.MoneyNum), logic.LogTypeItemConsumeByComponentUpgrade)
//
//	component.Id = uint32(nextComponentTable.Id)
//
//	player.SaveModel(component)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigComponentChange, &proto.MsgRigComponentChangeListAck{
//		List: []*proto.RigComponentChange{{RigComponent: component.BuildMsgRigComponent(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	switch proto.EquipType(component.Type) {
//	case proto.EquipTypeHead:
//		player.CheckTask(proto.TaskSection1UpgradeHeadComponents, 0, 1)
//		player.CheckTask(proto.TaskSection1HeadComponentMaxLevel, 0, nextComponentTable.Level)
//	case proto.EquipTypeBody:
//		player.CheckTask(proto.TaskSection1UpgradeBodyComponents, 0, 1)
//		player.CheckTask(proto.TaskSection1BodyComponentMaxLevel, 0, nextComponentTable.Level)
//	case proto.EquipTypeTail:
//		player.CheckTask(proto.TaskSection1UpgradeTailComponents, 0, 1)
//		player.CheckTask(proto.TaskSection1TailComponentMaxLevel, 0, nextComponentTable.Level)
//	}
//
//	player.UpdateRigAttrs()
//
//	player.CheckRigTrammelsStatus(uint32(nextComponentTable.ItemId), uint32(nextComponentTable.Level), 0)
//
//	player.CheckTask(proto.TaskSection1UpgradeComponents, 0, 1)
//	player.CheckTask(proto.TaskSection1ComponentsAllLevels, 0, int(player.GetAllRigCompnentLevels()))
//	return
//}
//
//func (this *PlayerHandler) RigComponentStarUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigComponentStarUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var component = player.RigComponent[req.ItemId]
//	if component == nil {
//		_ = player.TipNotice(proto.ErrComponentUnlocked)
//		return
//	}
//
//	var componentStarTable = this.tables.RigComponentStar.Get(int(component.StarId))
//	if componentStarTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if componentStarTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextComponentStarTable = this.tables.RigComponentStar.Get(componentStarTable.NextId)
//	if nextComponentStarTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range componentStarTable.CostItemId {
//		err = player.CheckItem(uint32(componentStarTable.CostItemId[i]), uint32(componentStarTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range componentStarTable.CostItemId {
//		player.ReduceItem(uint32(componentStarTable.CostItemId[i]), uint32(componentStarTable.CostItemNum[i]), logic.LogTypeItemConsumeByComponentStarUpgrade)
//	}
//
//	component.StarId = uint32(nextComponentStarTable.Id)
//
//	player.SaveModel(component)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigComponentChange, &proto.MsgRigComponentChangeListAck{
//		List: []*proto.RigComponentChange{{RigComponent: component.BuildMsgRigComponent(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	if component.Setup {
//		//TODO if need recalculate rig attribute and send to client?
//	}
//
//	switch proto.EquipType(component.Type) {
//	case proto.EquipTypeHead:
//		player.CheckAchievement(proto.AchievementTypeHeadComponentStars, uint32(nextComponentStarTable.StarLevel), 1)
//	case proto.EquipTypeBody:
//		player.CheckAchievement(proto.AchievementTypeBodyComponentStars, uint32(nextComponentStarTable.StarLevel), 1)
//	case proto.EquipTypeTail:
//		player.CheckAchievement(proto.AchievementTypeTailComponentStars, uint32(nextComponentStarTable.StarLevel), 1)
//	}
//
//	player.CheckRigTrammelsStatus(uint32(nextComponentStarTable.ItemId), 0, uint32(nextComponentStarTable.StarLevel))
//
//	player.CheckTask(proto.TaskSection1UpgradeComponentStars, int(component.Type), 1)
//	return
//}
//
//func (this *PlayerHandler) RigEquipSet(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigEquipSetReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Index >= proto.EquipNum {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if req.Id == 0 {
//		player.SetupRigEquip(req.Index, nil)
//		return
//	}
//
//	err = player.CheckFunctionOpen1(1, req.Index)
//	if err != nil {
//		_ = player.TipNotice(err)
//		return
//	}
//
//	var equipTable = this.tables.RigEquip.Get(int(req.Id))
//	if equipTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	var equip = player.RigEquip[uint32(equipTable.ItemId)]
//	if equip == nil {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if equip.Setup {
//		_ = player.TipNotice(proto.ErrItemIsSetup)
//		return
//	}
//
//	player.SetupRigEquip(req.Index, equip)
//	return
//}
//
//func (this *PlayerHandler) RigEquipUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigEquipUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var equip = player.RigEquip[req.ItemId]
//	if equip == nil {
//		_ = player.TipNotice(proto.ErrItemNotFound)
//		return
//	}
//
//	var equipTable = this.tables.RigEquip.Get(int(equip.Id))
//	if equipTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if equipTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextEquipTable = this.tables.RigEquip.Get(equipTable.NextId)
//	if nextEquipTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range equipTable.CostItemId {
//		err = player.CheckItem(uint32(equipTable.CostItemId[i]), uint32(equipTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range equipTable.CostItemId {
//		player.ReduceItem(uint32(equipTable.CostItemId[i]), uint32(equipTable.CostItemNum[i]), logic.LogTypeItemConsumeByEquipUpgrade)
//	}
//
//	equip.Id = uint32(nextEquipTable.Id)
//	player.SaveModel(equip)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigEquipChange, &proto.MsgRigEquipChangeListAck{
//		List: []*proto.RigEquipChange{{RigEquip: equip.BuildMsgRigEquip(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	player.CheckAchievement(proto.AchievementTypeEquipLevel, uint32(nextEquipTable.Level), 1)
//	return
//}
//
//func (this *PlayerHandler) RigEquipUpgradeAll(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigEquipUpgradeAllReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if len(req.List) == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var consumes = map[uint32]uint32{}
//	var equips = make([]*logic.PlayerRigEquip, len(req.List))
//	var equipTables = make([]*data.RigEquip, len(req.List))
//	var nextEquipTables = make([]*data.RigEquip, len(req.List))
//
//idLoop:
//	for i, id := range req.List {
//		if id == 0 {
//			_ = player.TipNotice(proto.ErrParameterError)
//			return
//		}
//
//		var equipTable = this.tables.RigEquip.Get(int(id))
//		if equipTable == nil {
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		equipTables[i] = equipTable
//
//		equips[i] = player.RigEquip[uint32(equipTable.ItemId)]
//		if equips[i] == nil {
//			_ = player.TipNotice(proto.ErrItemNotFound)
//			return
//		}
//
//		if id != equips[i].Id {
//			_ = player.TipNotice(proto.ErrItemNotFound)
//			return
//		}
//
//		var finalEquipTable *data.RigEquip
//	nextLoop:
//		for {
//			if equipTable.NextId <= 0 {
//				break nextLoop
//			}
//
//			var nextEquipTable = this.tables.RigEquip.Get(equipTable.NextId)
//			if nextEquipTable == nil {
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			for j := range equipTable.CostItemId {
//				err = player.CheckItem(uint32(equipTable.CostItemId[j]), consumes[uint32(equipTable.CostItemId[j])]+uint32(equipTable.CostItemNum[j]))
//				if err != nil {
//					if err == proto.ErrItemNotEnough {
//						break nextLoop
//					}
//
//					if err == proto.ErrMoneyNotEnough {
//						break idLoop
//					}
//
//					_ = player.TipNotice(err)
//					return
//				}
//
//				consumes[uint32(equipTable.CostItemId[j])] += uint32(equipTable.CostItemNum[j])
//			}
//
//			equipTable = nextEquipTable
//			finalEquipTable = nextEquipTable
//		}
//
//		if finalEquipTable != nil {
//			nextEquipTables[i] = finalEquipTable
//		}
//	}
//
//	for itemId, itemNum := range consumes {
//		player.ReduceItem(itemId, itemNum, logic.LogTypeItemConsumeByEquipUpgrade)
//	}
//
//	var list []*proto.RigEquipChange
//	for i, nextEquipTable := range nextEquipTables {
//		if nextEquipTable == nil {
//			continue
//		}
//
//		equips[i].Id = uint32(nextEquipTable.Id)
//		player.SaveModel(equips[i])
//
//		list = append(list, &proto.RigEquipChange{RigEquip: equips[i].BuildMsgRigEquip(), ChangeType: uint32(proto.ChangeTypeChange)})
//
//		for level := equipTables[i].Level + 1; level <= nextEquipTable.Level; level++ {
//			player.CheckAchievement(proto.AchievementTypeEquipLevel, uint32(level), 1)
//		}
//	}
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigEquipChange, &proto.MsgRigEquipChangeListAck{
//		List: list,
//	})
//
//	player.UpdateRigAttrs()
//	return
//}
//
//func (this *PlayerHandler) RigPendantSet(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigPendantSetReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Index >= proto.PendantNum {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if req.Id == 0 {
//		player.SetupRigPendant(req.Index, nil)
//		return
//	}
//
//	err = player.CheckFunctionOpen1(2, req.Index)
//	if err != nil {
//		_ = player.TipNotice(err)
//		return
//	}
//
//	var pendantTable = this.tables.RigPendant.Get(int(req.Id))
//	if pendantTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	var pendant = player.RigPendant[uint32(pendantTable.ItemId)]
//	if pendant == nil {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if pendant.Setup {
//		_ = player.TipNotice(proto.ErrItemIsSetup)
//		return
//	}
//
//	player.SetupRigPendant(req.Index, pendant)
//	return
//}
//
//func (this *PlayerHandler) RigPendantUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigPendantUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var pendant = player.RigPendant[req.ItemId]
//	if pendant == nil {
//		_ = player.TipNotice(proto.ErrItemNotFound)
//		return
//	}
//
//	var pendantTable = this.tables.RigPendant.Get(int(pendant.Id))
//	if pendantTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if pendantTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextPendantTable = this.tables.RigPendant.Get(pendantTable.NextId)
//	if nextPendantTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range pendantTable.CostItemId {
//		err = player.CheckItem(uint32(pendantTable.CostItemId[i]), uint32(pendantTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range pendantTable.CostItemId {
//		player.ReduceItem(uint32(pendantTable.CostItemId[i]), uint32(pendantTable.CostItemNum[i]), logic.LogTypeItemConsumeByPendantUpgrade)
//	}
//
//	pendant.Id = uint32(nextPendantTable.Id)
//	player.SaveModel(pendant)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigPendantChange, &proto.MsgRigPendantChangeListAck{
//		List: []*proto.RigPendantChange{{RigPendant: pendant.BuildMsgRigPendant(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	player.CheckAchievement(proto.AchievementTypePendantLevel, uint32(nextPendantTable.Level), 1)
//	return
//}
//
//func (this *PlayerHandler) RigPendantUpgradeAll(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigPendantUpgradeAllReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if len(req.List) == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var consumes = map[uint32]uint32{}
//	var pendants = make([]*logic.PlayerRigPendant, len(req.List))
//	var pendantTables = make([]*data.RigPendant, len(req.List))
//	var nextPendantTables = make([]*data.RigPendant, len(req.List))
//
//idLoop:
//	for i, id := range req.List {
//		if id == 0 {
//			_ = player.TipNotice(proto.ErrParameterError)
//			return
//		}
//
//		var pendantTable = this.tables.RigPendant.Get(int(id))
//		if pendantTable == nil {
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		pendantTables[i] = pendantTable
//
//		pendants[i] = player.RigPendant[uint32(pendantTable.ItemId)]
//		if pendants[i] == nil {
//			_ = player.TipNotice(proto.ErrItemNotFound)
//			return
//		}
//
//		if id != pendants[i].Id {
//			_ = player.TipNotice(proto.ErrItemNotFound)
//			return
//		}
//
//		var finalPendantTable *data.RigPendant
//	nextLoop:
//		for {
//			if pendantTable.NextId <= 0 {
//				break nextLoop
//			}
//
//			var nextPendantTable = this.tables.RigPendant.Get(pendantTable.NextId)
//			if nextPendantTable == nil {
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			for j := range pendantTable.CostItemId {
//				err = player.CheckItem(uint32(pendantTable.CostItemId[j]), consumes[uint32(pendantTable.CostItemId[j])]+uint32(pendantTable.CostItemNum[j]))
//				if err != nil {
//					if err == proto.ErrItemNotEnough {
//						break nextLoop
//					}
//
//					if err == proto.ErrMoneyNotEnough {
//						break idLoop
//					}
//
//					_ = player.TipNotice(err)
//					return
//				}
//
//				consumes[uint32(pendantTable.CostItemId[j])] += uint32(pendantTable.CostItemNum[j])
//			}
//
//			pendantTable = nextPendantTable
//			finalPendantTable = nextPendantTable
//		}
//
//		if finalPendantTable != nil {
//			nextPendantTables[i] = finalPendantTable
//		}
//	}
//
//	for itemId, itemNum := range consumes {
//		player.ReduceItem(itemId, itemNum, logic.LogTypeItemConsumeByPendantUpgrade)
//	}
//
//	var list []*proto.RigPendantChange
//	for i, nextPendantTable := range nextPendantTables {
//		if nextPendantTables == nil {
//			continue
//		}
//
//		pendants[i].Id = uint32(nextPendantTable.Id)
//		player.SaveModel(pendants[i])
//
//		list = append(list, &proto.RigPendantChange{RigPendant: pendants[i].BuildMsgRigPendant(), ChangeType: uint32(proto.ChangeTypeChange)})
//
//		for level := pendantTables[i].Level + 1; level <= nextPendantTable.Level; level++ {
//			player.CheckAchievement(proto.AchievementTypePendantLevel, uint32(level), 1)
//		}
//	}
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigPendantChange, &proto.MsgRigPendantChangeListAck{
//		List: list,
//	})
//
//	player.UpdateRigAttrs()
//	return
//}
//
//func (this *PlayerHandler) RigRemainsUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigRemainsUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var remains = player.RigRemains[req.ItemId]
//	if remains == nil {
//		_ = player.TipNotice(proto.ErrItemNotFound)
//		return
//	}
//
//	var remainsTable = this.tables.RigRemains.Get(int(remains.Id))
//	if remainsTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if remainsTable.NextId == 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextRemainsTable = this.tables.RigRemains.Get(remainsTable.NextId)
//	if nextRemainsTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range remainsTable.CostItemId {
//		err = player.CheckItem(uint32(remainsTable.CostItemId[i]), uint32(remainsTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range remainsTable.CostItemId {
//		player.ReduceItem(uint32(remainsTable.CostItemId[i]), uint32(remainsTable.CostItemNum[i]), logic.LogTypeItemConsumeByRemainsUpgrade)
//	}
//
//	remains.Id = uint32(nextRemainsTable.Id)
//
//	player.SaveModel(remains)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigRemainsChange, &proto.MsgRigRemainsChangeListAck{
//		List: []*proto.RigRemainsChange{{RigRemains: remains.BuildMsgRigRemains(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	player.CheckTask(proto.TaskSection1UpgradeRemains, 0, 1)
//	player.CheckAchievement(proto.AchievementTypeRemainsLevel, uint32(nextRemainsTable.Level), 1)
//	return
//}
//
//func (this *PlayerHandler) RigSmelterSmelt(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigSmelterSmeltReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Type == 0 || req.Times == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var smelterTable *data.RigSmelter
//	var smelter = player.RigSmelter[req.Type]
//	if smelter == nil {
//		smelterTable = this.tables.RigSmelterExtend.Get(int(req.Type), 1)
//		if smelterTable == nil {
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		smelter = player.AddRigSmelter(smelterTable)
//	} else {
//		smelterTable = this.tables.RigSmelter.Get(int(smelter.Id))
//		if smelterTable == nil {
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//	}
//
//	var ti = -1
//	for i, times := range smelterTable.TimesList {
//		if uint32(times) == req.Times {
//			ti = i
//			break
//		}
//	}
//
//	if ti < 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	if !player.CheckAdFunction(proto.AdFunctionTypeSmelt, uint32(smelterTable.Type), 0, req.Times) {
//		err = player.CheckItem(uint32(smelterTable.CostItemId[ti]), uint32(smelterTable.CostItemNum[ti]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//
//		player.ReduceItem(uint32(smelterTable.CostItemId[ti]), uint32(smelterTable.CostItemNum[ti]), logic.LogTypeItemConsumeBySmelterSmelt)
//	}
//
//	var itemMap = map[uint32]uint32{}
//	var itemPairs = this.tables.DropExtend.Drop(smelterTable.DropId, int(req.Times))
//	var rewardList = make([]*proto.ItemPair, len(itemPairs))
//	for i, itemPair := range itemPairs {
//		itemMap[itemPair[0]] += itemPair[1]
//		rewardList[i] = &proto.ItemPair{ItemId: itemPair[0], ItemNum: itemPair[1]}
//	}
//
//	player.AddItems(itemMap, logic.LogTypeItemObtainBySmelt)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigSmelterSmelt, &proto.MsgRigSmelterSmeltAck{MsgRewardListAck: &proto.MsgRewardListAck{RewardList: rewardList}})
//
//	if smelterTable.SmeltExp > 0 {
//		if smelterTable.NextId <= 0 && smelter.Exp >= uint32(smelterTable.UpgradeExp) {
//			return
//		}
//
//	timesLoop:
//		for i := uint32(0); i < req.Times; i++ {
//			smelter.Exp += uint32(smelterTable.SmeltExp)
//			for {
//				if smelter.Exp >= uint32(smelterTable.UpgradeExp) {
//					if smelterTable.NextId > 0 {
//						var nextSmelterTable = this.tables.RigSmelter.Get(smelterTable.NextId)
//						if nextSmelterTable == nil {
//							this.logger.Error("熔炉升级查找下一级失败, nextId: ", smelterTable.NextId)
//							break
//						}
//
//						smelter.Id = uint32(nextSmelterTable.Id)
//						smelter.Exp -= uint32(smelterTable.UpgradeExp)
//
//						smelterTable = nextSmelterTable
//					} else {
//						smelter.Id = uint32(smelterTable.Id)
//						smelter.Exp = uint32(smelterTable.UpgradeExp)
//						break timesLoop
//					}
//				} else {
//					break
//				}
//			}
//		}
//
//		player.RigSmelter[smelter.Type] = smelter
//		player.SaveModel(smelter)
//
//		_ = player.Send(proto.ModIdRig, proto.MsgIdRigSmelterChange, &proto.MsgRigSmelterChangeAck{Smelter: smelter.BuildMsgSmelter()})
//	}
//
//	player.CheckTask(proto.TaskSection1SmelterSmeltTimes, smelterTable.Type, int(req.Times))
//	return
//}
//
//func (this *PlayerHandler) RigTeamSave(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigTeamSaveReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Team > uint32(len(req.List)) {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var teams []proto.Team
//	for _, team := range req.List {
//		teams = append(teams, team.Members)
//	}
//
//	player.Rig.Team = req.Team
//	player.Rig.Teams = teams
//
//	player.SaveField("rig.team", player.Rig.Team)
//	player.SaveField("rig.teams", player.Rig.Teams)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigTeamSave, &proto.MsgRigTeamSaveAck{Team: req.Team, List: req.List})
//
//	player.UpdateRigAttrs()
//	return
//}
//
//func (this *PlayerHandler) RigCharacterUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigCharacterUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var character = player.RigCharacter[req.ItemId]
//	if character == nil {
//		_ = player.TipNotice(proto.ErrCharacterUnlocked)
//		return
//	}
//
//	var charaterTable = this.tables.RigCharacter.Get(int(character.Id))
//	if charaterTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if charaterTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextCharacterTable = this.tables.RigCharacter.Get(charaterTable.NextId)
//	if nextCharacterTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range charaterTable.CostItemId {
//		err = player.CheckItem(uint32(charaterTable.CostItemId[i]), uint32(charaterTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range charaterTable.CostItemId {
//		player.ReduceItem(uint32(charaterTable.CostItemId[i]), uint32(charaterTable.CostItemNum[i]), logic.LogTypeItemConsumeByCharacterUpgrade)
//	}
//
//	character.Id = uint32(nextCharacterTable.Id)
//	player.SaveModel(character)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigCharacterChange, &proto.MsgRigCharacterChangeListAck{
//		List: []*proto.RigCharacterChange{{RigCharacter: character.BuildMsgRigCharacter(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	player.CheckRigTrammelsStatus(uint32(nextCharacterTable.ItemId), uint32(nextCharacterTable.Level), 0)
//
//	player.CheckTask(proto.TaskSection1UpgradeCharacters, 0, 1)
//	return
//}
//
//func (this *PlayerHandler) RigCharacterStarUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigCharacterUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		this.logger.Error("Parameter error, req.ItemId == 0")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var character = player.RigCharacter[req.ItemId]
//	if character == nil {
//		this.logger.Error("Player 'Character' was not found, itemId: ", req.ItemId)
//		_ = player.TipNotice(proto.ErrCharacterUnlocked)
//		return
//	}
//
//	var characterStarsTable = this.tables.RigCharacterStar.Get(int(character.StarId))
//	if characterStarsTable == nil {
//		this.logger.Error("Data tables error, Table 'RigCharacterStar' was not found, starId: ", character.StarId)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if characterStarsTable.NextId <= 0 {
//		this.logger.Error("The level of 'RigCharacterStar' already max, nextId: ", characterStarsTable.NextId)
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextCharacterStarsTable = this.tables.RigCharacterStar.Get(characterStarsTable.NextId)
//	if nextCharacterStarsTable == nil {
//		this.logger.Error("Data tables error, next level of Table 'RigCharacterStar' was not found, nextId: ", characterStarsTable.NextId)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range characterStarsTable.CostItemId {
//		err = player.CheckItem(uint32(characterStarsTable.CostItemId[i]), uint32(characterStarsTable.CostItemNum[i]))
//		if err != nil {
//			this.logger.Errorf("Item not enough, costTtemId: %d, costItemNum: %d", characterStarsTable.CostItemId[i], characterStarsTable.CostItemNum[i])
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range characterStarsTable.CostItemId {
//		player.ReduceItem(uint32(characterStarsTable.CostItemId[i]), uint32(characterStarsTable.CostItemNum[i]), logic.LogTypeItemConsumeByCharacterStarsUpgrade)
//	}
//
//	character.StarId = uint32(nextCharacterStarsTable.Id)
//	player.SaveModel(character)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigCharacterChange, &proto.MsgRigCharacterChangeListAck{
//		List: []*proto.RigCharacterChange{{RigCharacter: character.BuildMsgRigCharacter(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	player.CheckRigTrammelsStatus(uint32(nextCharacterStarsTable.ItemId), 0, uint32(nextCharacterStarsTable.StarLevel))
//
//	player.CheckTask(proto.TaskSection1UpgradeCharacterStars, 0, 1)
//	player.CheckAchievement(proto.AchievementTypeCharacterStars, uint32(nextCharacterStarsTable.StarLevel), 1)
//}
//
//func (this *PlayerHandler) RigCoreSet(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigCoreSetReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Id == 0 || req.Socket < 0 || req.Socket > proto.CoreNum {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	err = player.CheckFunctionOpen1(3, req.Socket)
//	if err != nil {
//		_ = player.TipNotice(err)
//		return
//	}
//
//	var coreTable = this.tables.RigCore.Get(int(req.Id))
//	if coreTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	var core = player.RigCore[uint32(coreTable.ItemId)]
//	if core == nil {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var ack = new(proto.MsgRigCoreChangeListAck)
//	if req.Socket == 0 {
//		if core.Socket == 0 {
//			return
//		}
//
//		core.Socket = 0
//		player.SaveModel(core)
//
//		ack.List = append(ack.List, &proto.RigCoreChange{RigCore: core.BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)})
//	} else {
//		if core.Socket > 0 {
//			_ = player.TipNotice(proto.ErrItemIsSetup)
//			return
//		}
//
//		var setup = player.CheckRigCoreSocket(req.Socket)
//		if setup != nil {
//			setup.Socket = 0
//			player.SaveModel(setup)
//
//			ack.List = append(ack.List, &proto.RigCoreChange{RigCore: setup.BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)})
//		}
//
//		core.Socket = req.Socket
//		player.SaveModel(core)
//
//		ack.List = append(ack.List, &proto.RigCoreChange{RigCore: core.BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)})
//	}
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigCoreChange, ack)
//	return
//}
//
//func (this *PlayerHandler) RigCoreSetAll(player *logic.Player, msg *net.Message) {
//	var maxNum = uint32(0)
//	for i := uint32(1); i <= proto.CoreNum; i++ {
//		if player.CheckFunctionOpen1(3, i) != nil {
//			break
//		}
//		maxNum = i
//	}
//
//	if maxNum == 0 {
//		return
//	}
//
//	var unsetCores []*logic.PlayerRigCore
//	var unsetItems []*data.Item
//	var unsetTables []*data.RigCore
//	var setupCores = map[uint32]*logic.PlayerRigCore{}
//	for _, core := range player.RigCore {
//		var item, table = this.tables.Item.Get(int(core.ItemId)), this.tables.RigCore.Get(int(core.Id))
//		if item == nil || table == nil {
//			continue
//		}
//
//		if core.Socket > 0 {
//			setupCores[core.Socket] = core
//		} else {
//			unsetCores = append(unsetCores, core)
//			unsetItems = append(unsetItems, item)
//			unsetTables = append(unsetTables, table)
//		}
//	}
//
//	sort.Slice(unsetCores, func(i, j int) bool {
//		var ii, ij = unsetItems[i], unsetItems[j]
//		var ti, tj = unsetTables[i], unsetTables[j]
//		if ii == nil && ij != nil {
//			return false
//		}
//
//		if ii != nil && ij == nil {
//			return true
//		}
//
//		if ii != nil && ij != nil {
//			if ii.Quality != ij.Quality {
//				return ii.Quality > ij.Quality
//			}
//		}
//
//		if ti.Level != tj.Level {
//			return ti.Level > tj.Level
//		}
//
//		return ti.Id < tj.Id
//	})
//
//	var unsetIndex = 0
//	var list []*proto.RigCoreChange
//	for i := uint32(1); i <= maxNum; i++ {
//		if _, ok := setupCores[i]; ok {
//			continue
//		}
//
//		if unsetIndex < len(unsetCores) {
//			unsetCores[unsetIndex].Socket = i
//			player.SaveModel(unsetCores[unsetIndex])
//
//			list = append(list, &proto.RigCoreChange{RigCore: unsetCores[unsetIndex].BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)})
//
//			unsetIndex += 1
//		}
//	}
//
//	if len(list) > 0 {
//		_ = player.Send(proto.ModIdRig, proto.MsgIdRigCoreChange, &proto.MsgRigCoreChangeListAck{
//			List: list,
//		})
//	}
//	return
//}
//
//func (this *PlayerHandler) RigCoreUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigCoreUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message failed, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.ItemId == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var core = player.RigCore[req.ItemId]
//	if core == nil {
//		_ = player.TipNotice(proto.ErrItemNotFound)
//		return
//	}
//
//	var coreTable = this.tables.RigCore.Get(int(core.Id))
//	if coreTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if coreTable.NextId <= 0 {
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var nextCoreTable = this.tables.RigCore.Get(coreTable.NextId)
//	if nextCoreTable == nil {
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	for i := range coreTable.CostItemId {
//		err = player.CheckItem(uint32(coreTable.CostItemId[i]), uint32(coreTable.CostItemNum[i]))
//		if err != nil {
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	for i := range coreTable.CostItemId {
//		player.ReduceItem(uint32(coreTable.CostItemId[i]), uint32(coreTable.CostItemNum[i]), logic.LogTypeItemConsumeByCoreUpgrade)
//	}
//
//	core.Id = uint32(nextCoreTable.Id)
//
//	player.SaveModel(core)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigCoreChange, &proto.MsgRigCoreChangeListAck{
//		List: []*proto.RigCoreChange{{RigCore: core.BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//
//	return
//}
//
//func (this *PlayerHandler) RigCoreUpgradeAll(player *logic.Player, msg *net.Message) {
//	var consumes = map[uint32]uint32{}
//	var cores []*logic.PlayerRigCore
//	var nextCoreTables []*data.RigCore
//
//coreLoop:
//	for _, core := range player.RigCore {
//		var coreTable = this.tables.RigCore.Get(int(core.Id))
//		if coreTable == nil {
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		var finalCoreTable *data.RigCore
//	nextLoop:
//		for {
//			if coreTable.NextId <= 0 {
//				break nextLoop
//			}
//
//			var nextCoreTable = this.tables.RigCore.Get(coreTable.NextId)
//			if nextCoreTable == nil {
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			for j := range coreTable.CostItemId {
//				var err = player.CheckItem(uint32(coreTable.CostItemId[j]), consumes[uint32(coreTable.CostItemId[j])]+uint32(coreTable.CostItemNum[j]))
//				if err != nil {
//					if errors.Is(err, proto.ErrItemNotEnough) {
//						break nextLoop
//					}
//
//					if errors.Is(err, proto.ErrMoneyNotEnough) {
//						break coreLoop
//					}
//
//					_ = player.TipNotice(err)
//					return
//				}
//
//				consumes[uint32(coreTable.CostItemId[j])] += uint32(coreTable.CostItemNum[j])
//			}
//
//			coreTable = nextCoreTable
//			finalCoreTable = nextCoreTable
//		}
//
//		if finalCoreTable != nil {
//			cores = append(cores, core)
//			nextCoreTables = append(nextCoreTables, finalCoreTable)
//		}
//	}
//
//	for itemId, itemNum := range consumes {
//		player.ReduceItem(itemId, itemNum, logic.LogTypeItemConsumeByEquipUpgrade)
//	}
//
//	var list []*proto.RigCoreChange
//	for i, nextCoreTable := range nextCoreTables {
//		if nextCoreTable == nil {
//			continue
//		}
//
//		cores[i].Id = uint32(nextCoreTable.Id)
//
//		player.SaveModel(cores[i])
//
//		list = append(list, &proto.RigCoreChange{RigCore: cores[i].BuildMsgRigCore(), ChangeType: uint32(proto.ChangeTypeChange)})
//	}
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigCoreChange, &proto.MsgRigCoreChangeListAck{
//		List: list,
//	})
//
//	player.UpdateRigAttrs()
//}
//
//func (this *PlayerHandler) RigTrammelsActivate(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigTrammelsActivateReq)
//	var err = msg.Read(req)
//	if err != nil {
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Group == 0 || req.Level == 0 {
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var rigTrammels = player.RigTrammels[req.Group]
//	if rigTrammels == nil || proto.TrammelsStatus(rigTrammels.Status[req.Level]) == proto.TrammelsStatusUnable {
//		_ = player.TipNotice(proto.ErrTrammelsUnable)
//		return
//	}
//
//	var status = rigTrammels.Status[req.Level]
//	if proto.TrammelsStatus(status) == proto.TrammelsStatusUnable {
//		_ = player.TipNotice(proto.ErrTrammelsUnable)
//		return
//	}
//
//	if proto.TrammelsStatus(status) == proto.TrammelsStatusActivated {
//		_ = player.TipNotice(proto.ErrTrammelsActivated)
//		return
//	}
//
//	rigTrammels.Status[req.Level] = uint32(proto.TrammelsStatusActivated)
//	player.SaveModel(rigTrammels)
//
//	player.UpdateRigAttrs()
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigTrammelsActivate, &proto.MsgRigTrammelsActivateAck{
//		RigTrammelsStatus: &proto.RigTrammelsStatus{Level: req.Level, Status: uint32(proto.TrammelsStatusActivated)},
//		Group:             rigTrammels.Group,
//	})
//	return
//}
//
//func (this *PlayerHandler) RigWarshipSet(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigWarshipSetReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message error, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Uid == 0 {
//		player.SetupWarship(nil)
//		return
//	}
//
//	var warship = player.RigWarship[req.Uid]
//	if warship == nil {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, uid: ", req.Uid)
//		_ = player.TipNotice(proto.ErrWarshipNotFound)
//		return
//	}
//
//	if warship.Setup {
//		return
//	}
//
//	player.SetupWarship(warship)
//}
//
//func (this *PlayerHandler) RigWarshipUpgrade(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigWarshipUpgradeReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message error, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Uid == 0 {
//		this.logger.Error("Parameter error, req.Uid == 0")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var warship = player.RigWarship[req.Uid]
//	if warship == nil {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, uid: ", req.Uid)
//		_ = player.TipNotice(proto.ErrWarshipNotFound)
//		return
//	}
//
//	var warshipTable = this.tables.Warship.Get(int(warship.Id))
//	if warshipTable == nil {
//		this.logger.Error("Parameter or data error, Table 'RigWarship' was not found, id: ", warship.Id)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	var warshipLevelTables = this.tables.WarshipLevelExtend.List(warshipTable.Type)
//
//	var lvi = sort.Search(len(warshipLevelTables), func(i int) bool {
//		return uint32(warshipLevelTables[i].Id) >= warship.LevelId
//	})
//
//	if lvi == len(warshipLevelTables) || uint32(warshipLevelTables[lvi].Id) != warship.LevelId {
//		this.logger.Error("Parameter or data error, Table 'WarshipLevel' was not found, id: ", warship.Id)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if lvi == len(warshipLevelTables)-1 {
//		this.logger.Error("Level already max, levelId: ", warship.LevelId)
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var warshipLevelTable = warshipLevelTables[lvi]
//
//	if len(warshipLevelTable.ConsumeItemId) > 0 {
//		for i := range warshipLevelTable.ConsumeItemId {
//			if player.CheckItem(uint32(warshipLevelTable.ConsumeItemId[i]), uint32(warshipLevelTable.ConsumeItemNum[i])) != nil {
//				this.logger.Errorf("Check item consume failed, itemId: %d, itemNum: %d, error: %v", warshipLevelTable.ConsumeItemId[i], warshipLevelTable.ConsumeItemNum[i], err)
//				_ = player.TipNotice(err)
//				return
//			}
//		}
//
//		for i := range warshipLevelTable.ConsumeItemId {
//			player.ReduceItem(uint32(warshipLevelTable.ConsumeItemId[i]), uint32(warshipLevelTable.ConsumeItemNum[i]), logic.LogTypeItemConsumeByWarshipUpgrade)
//		}
//	}
//
//	warship.LevelId = uint32(warshipLevelTables[lvi+1].Id)
//	player.SaveModel(warship)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigWarshipChange, &proto.MsgRigWarshipChangeAck{
//		List: []*proto.RigWarshipChange{{RigWarship: warship.BuildMsgRigWarship(), ChangeType: uint32(proto.ChangeTypeChange)}},
//	})
//
//	player.UpdateRigAttrs()
//}
//
//func (this *PlayerHandler) RigWarshipFuse(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigWarshipFuseReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message error, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Uid == 0 || req.TargetUid == 0 {
//		this.logger.Error("Parameter error, req.Uid == 0 || req.TargetUid == 0")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var warship = player.RigWarship[req.Uid]
//	if warship == nil {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, uid: ", req.Uid)
//		_ = player.TipNotice(proto.ErrWarshipNotFound)
//		return
//	}
//
//	var target = player.RigWarship[req.TargetUid]
//	if target == nil {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, targetUid: ", req.TargetUid)
//		_ = player.TipNotice(proto.ErrWarshipNotFound)
//		return
//	}
//
//	if target.Setup {
//		this.logger.Error("Parameter error, Can not fuse the target that is setup, targetUid: ", req.TargetUid)
//		_ = player.TipNotice(proto.ErrWarshipCanNotFuse)
//		return
//	}
//
//	var warshipStarTables = this.tables.WarshipStarExtend.List(int(warship.Id))
//
//	var lvi, tvi = -1, -1
//	for i := range warshipStarTables {
//		if uint32(warshipStarTables[i].Id) == warship.StarId {
//			lvi = i
//			if tvi != -1 {
//				break
//			}
//		}
//		if uint32(warshipStarTables[i].Id) == target.StarId {
//			tvi = i
//			if lvi != -1 {
//				break
//			}
//		}
//	}
//
//	if lvi == -1 {
//		this.logger.Error("Parameter or data error, Table 'WarshipStar' was not found, warship.StarId: ", warship.StarId)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if tvi == -1 {
//		this.logger.Error("Parameter or data error, Table 'WarshipStar' was not found, target.StarId: ", target.StarId)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if lvi == len(warshipStarTables)-1 {
//		this.logger.Error("Star level already max, warship.StarId: ", warship.StarId)
//		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
//		return
//	}
//
//	var warshipStarTable = warshipStarTables[lvi]
//
//	if len(warshipStarTable.ConsumeItemId) > 0 {
//		for i := range warshipStarTable.ConsumeItemId {
//			if player.CheckItem(uint32(warshipStarTable.ConsumeItemId[i]), uint32(warshipStarTable.ConsumeItemNum[i])) != nil {
//				this.logger.Errorf("Check item consume failed, itemId: %d, itemNum: %d, error: %v", warshipStarTable.ConsumeItemId[i], warshipStarTable.ConsumeItemNum[i], err)
//				_ = player.TipNotice(err)
//				return
//			}
//		}
//	}
//
//	var nvi = lvi + tvi + 1
//	if nvi >= len(warshipStarTables) {
//		nvi = len(warshipStarTables) - 1
//	}
//
//	var skills = slices.Clone(warship.Skills)
//	var exclude = map[int]struct{}{}
//	var skillTables = make([]*data.Skill, len(skills))
//	for i, skillId := range skills {
//		skillTables[i] = this.tables.Skill.Get(int(skillId))
//		if skillTables[i] == nil {
//			this.logger.Error("Parameter or data error, Table 'Skill' was not found, skillId: ", skillId)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//		exclude[skillTables[i].Id] = struct{}{}
//	}
//
//	for i := 0; i < (nvi - lvi); i++ {
//		if len(skills) < 4 {
//			var warshipSkillTable = this.tables.WarshipSkillExtend.Random(1, exclude)
//			if warshipSkillTable == nil {
//				this.logger.Error("Parameter or data error, Table 'WarshipSkill' random failed, exclude: ", skills)
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			var skillTable = this.tables.SkillExtend.Get(warshipSkillTable.SkillId, 1)
//			if skillTable == nil {
//				this.logger.Errorf("Parameter or data error, Table 'Skill' was not found, skillId: %d, skillLevel: 1", warshipSkillTable.SkillId)
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			skills = append(skills, uint32(skillTable.Id))
//			skillTables = append(skillTables, skillTable)
//			exclude[skillTable.SkillId] = struct{}{}
//		} else {
//			var stis []int
//			for sti := range skillTables {
//				if skillTables[sti].NextId > 0 {
//					stis = append(stis, sti)
//				}
//			}
//			if len(stis) == 0 {
//				break
//			}
//
//			var sti = util.RandomSelect(stis, 1)[0]
//			var nextSkillTable = this.tables.Skill.Get(skillTables[sti].NextId)
//			if nextSkillTable == nil {
//				this.logger.Error("Parameter or data error, Table 'Skill' was not found, nextId: ", skillTables[sti].NextId)
//				_ = player.TipNotice(proto.ErrDataTablesError)
//				return
//			}
//
//			skills[sti] = uint32(nextSkillTable.Id)
//			skillTables[sti] = nextSkillTable
//		}
//	}
//
//	if len(warshipStarTable.ConsumeItemId) > 0 {
//		for i := range warshipStarTable.ConsumeItemId {
//			player.ReduceItem(uint32(warshipStarTable.ConsumeItemId[i]), uint32(warshipStarTable.ConsumeItemNum[i]), logic.LogTypeItemConsumeByWarshipFuse)
//		}
//	}
//
//	warship.StarId = uint32(warshipStarTables[nvi].Id)
//	warship.Skills = skills
//	player.SaveModel(warship)
//
//	delete(player.RigWarship, target.Uid)
//	player.WipeModel(target)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigWarshipChange, &proto.MsgRigWarshipChangeAck{
//		List: []*proto.RigWarshipChange{
//			{RigWarship: warship.BuildMsgRigWarship(), ChangeType: uint32(proto.ChangeTypeChange)},
//			{RigWarship: target.BuildMsgRigWarship(), ChangeType: uint32(proto.ChangeTypeDelete)},
//		},
//	})
//
//	player.UpdateRigAttrs()
//}
//
//func (this *PlayerHandler) RigWarshipReform(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgRigWarshipReformReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message error, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Uid == 0 || len(req.LockedSkills) > 3 {
//		this.logger.Error("Parameter error, req.Uid == 0 || len(req.LockedSkills) > 3")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var warship = player.RigWarship[req.Uid]
//	if warship == nil {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, uid: ", req.Uid)
//		_ = player.TipNotice(proto.ErrWarshipNotFound)
//		return
//	}
//
//	var warshipTable = this.tables.Warship.Get(int(warship.Id))
//	if warshipTable == nil {
//		this.logger.Error("Parameter or data error, Table 'RigWarship' was not found, id: ", warship.Id)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if len(warship.Skills) != 4 {
//		this.logger.Error("Parameter error, Player 'RigWarship' was not found, uid: ", req.Uid)
//		_ = player.TipNotice(proto.ErrWarshipCanNotReform)
//		return
//	}
//
//	var consumeItems = map[uint32]uint32{}
//
//	if warshipTable.ConsumeItem > 0 {
//		consumeItems[uint32(warshipTable.ConsumeItem)] = uint32(warshipTable.ItemQuantities)
//	}
//
//	if warshipTable.LockItem > 0 {
//		switch len(req.LockedSkills) {
//		case 1:
//			consumeItems[uint32(warshipTable.LockItem)] = uint32(warshipTable.Lock1Quantities)
//		case 2:
//			consumeItems[uint32(warshipTable.LockItem)] = uint32(warshipTable.Lock2Quantities)
//		case 3:
//			consumeItems[uint32(warshipTable.LockItem)] = uint32(warshipTable.Lock3Quantities)
//		}
//	}
//
//	for itemId, itemNum := range consumeItems {
//		if player.CheckItem(itemId, itemNum) != nil {
//			this.logger.Errorf("Check item consume failed, itemId: %d, itemNum: %d, error: %v", itemId, itemNum, err)
//			_ = player.TipNotice(err)
//			return
//		}
//	}
//
//	var skills = slices.Clone(warship.Skills)
//	var exclude = map[int]struct{}{}
//	var skillTables = make([]*data.Skill, len(skills))
//	for i, skillId := range skills {
//		skillTables[i] = this.tables.Skill.Get(int(skillId))
//		if skillTables[i] == nil {
//			this.logger.Error("Parameter or data error, Table 'Skill' was not found, skillId: ", skillId)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//		exclude[skillTables[i].SkillId] = struct{}{}
//	}
//
//skillsLoop:
//	for si, skillId := range skills {
//		for _, lockedSkillId := range req.LockedSkills {
//			if skillId == lockedSkillId {
//				continue skillsLoop
//			}
//		}
//
//		delete(exclude, skillTables[si].SkillId)
//
//		var warshipSkillTable = this.tables.WarshipSkillExtend.Random(2, exclude)
//		if warshipSkillTable == nil {
//			this.logger.Error("Parameter or data error, Table 'WarshipSkill' random failed, exclude: ", skills)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		var newSkillTable = this.tables.SkillExtend.Get(warshipSkillTable.SkillId, skillTables[si].SkillLevel)
//		if newSkillTable == nil {
//			this.logger.Errorf("Parameter or data error, Table 'Skill' was not found, skillId: %d, skillLevel: %v", warshipSkillTable.SkillId, skillTables[si].SkillLevel)
//			_ = player.TipNotice(proto.ErrDataTablesError)
//			return
//		}
//
//		skills[si] = uint32(newSkillTable.Id)
//		exclude[newSkillTable.SkillId] = struct{}{}
//	}
//
//	for itemId, itemNum := range consumeItems {
//		player.ReduceItem(itemId, itemNum, logic.LogTypeItemConsumeByWarshipReform)
//	}
//
//	warship.Skills = skills
//	player.SaveModel(warship)
//
//	_ = player.Send(proto.ModIdRig, proto.MsgIdRigWarshipChange, &proto.MsgRigWarshipChangeAck{
//		List: []*proto.RigWarshipChange{
//			{RigWarship: warship.BuildMsgRigWarship(), ChangeType: uint32(proto.ChangeTypeChange)},
//		},
//	})
//}
//
//func (this *PlayerHandler) FunctionOpen1Unlock(player *logic.Player, msg *net.Message) {
//	var req = new(proto.MsgFunctionOpen1UnlockReq)
//	var err = msg.Read(req)
//	if err != nil {
//		this.logger.Error("Read message error, ", err)
//		_ = player.TipNotice(proto.ErrMessageError)
//		return
//	}
//
//	if req.Id == 0 {
//		this.logger.Error("Parameter error, req.Id == 0")
//		_ = player.TipNotice(proto.ErrParameterError)
//		return
//	}
//
//	var functionOpen1Table = this.tables.FunctionOpen1.Get(int(req.Id))
//	if functionOpen1Table == nil {
//		this.logger.Error("Parameter or data error, Table 'FunctionOpen1'was not found, id: ", req.Id)
//		_ = player.TipNotice(proto.ErrDataTablesError)
//		return
//	}
//
//	if functionOpen1Table.LockType != 4 {
//		this.logger.Error("Function can not unlock, functionOpen1Table.LockType != 4, id: ", req.Id)
//		_ = player.TipNotice(proto.ErrFunctionCanNotUnlock)
//		return
//	}
//
//	if player.GetCounterTotal(proto.CounterTypeFunctionOpen1, util.Compose2uint16(uint16(functionOpen1Table.GridType), uint16(functionOpen1Table.GridId))) > 0 {
//		this.logger.Errorf("Function has unlocked, id: %d, gridType: %d, gridId: %d", req.Id, functionOpen1Table.GridType, functionOpen1Table.GridId)
//		_ = player.TipNotice(proto.ErrFunctionHasUnlocked)
//		return
//	}
//
//	if functionOpen1Table.GridId > 0 {
//		if player.GetCounterTotal(proto.CounterTypeFunctionOpen1, util.Compose2uint16(uint16(functionOpen1Table.GridType), uint16(functionOpen1Table.GridId-1))) == 0 {
//			this.logger.Errorf("Function can not unlock, The previous one has not unlocked, id: %d, gridType: %d, gridId: %d", req.Id, functionOpen1Table.GridType, functionOpen1Table.GridId)
//			_ = player.TipNotice(proto.ErrFunctionCanNotUnlock)
//			return
//		}
//	}
//
//	err = player.CheckItem(uint32(functionOpen1Table.LockArg1), uint32(functionOpen1Table.LockArg2))
//	if err != nil {
//		this.logger.Errorf("Check item consume failed, itemId: %d, itemNum: %d, error: %v", functionOpen1Table.LockArg1, functionOpen1Table.LockArg2, err)
//		_ = player.TipNotice(err)
//		return
//	}
//
//	player.ReduceItem(uint32(functionOpen1Table.LockArg1), uint32(functionOpen1Table.LockArg2), logic.LogTypeItemConsumeByFunctionUnlock)
//
//	player.AddCounter(proto.CounterTypeFunctionOpen1, util.Compose2uint16(uint16(functionOpen1Table.GridType), uint16(functionOpen1Table.GridId)), 1)
//}