697 lines
20 KiB
Go
697 lines
20 KiB
Go
package main
|
|
|
|
import (
|
|
"time"
|
|
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/model"
|
|
"mongo.games.com/game/protocol/pets"
|
|
"mongo.games.com/game/protocol/server"
|
|
"mongo.games.com/game/srvdata"
|
|
)
|
|
|
|
type CSRoleInfoPacketFactory struct {
|
|
}
|
|
|
|
type CSRoleInfoHandler struct {
|
|
}
|
|
|
|
func (this *CSRoleInfoPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSRoleInfo{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSRoleInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSRoleInfoHandler Process recv ", data)
|
|
if _, ok := data.(*pets.CSRoleInfo); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSRoleInfoHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
roleInfos := PetMgrSington.GetRoleInfos(p)
|
|
pack := &pets.SCRoleInfo{
|
|
Infos: roleInfos,
|
|
}
|
|
logger.Logger.Trace("SCRoleInfo:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLE_INFO), pack)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type CSPetInfoPacketFactory struct {
|
|
}
|
|
|
|
type CSPetInfoHandler struct {
|
|
}
|
|
|
|
func (this *CSPetInfoPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSPetInfo{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSPetInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSPetInfoHandler Process recv ", data)
|
|
if _, ok := data.(*pets.CSPetInfo); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSPetInfoHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
|
|
petInfos := PetMgrSington.GetPetInfos(p)
|
|
pack := &pets.SCPetInfo{
|
|
Infos: petInfos,
|
|
}
|
|
logger.Logger.Trace("SCPetInfo:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PET_INFO), pack)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CSRisingStarPacketFactory struct {
|
|
}
|
|
|
|
type CSRisingStarHandler struct {
|
|
}
|
|
|
|
func (this *CSRisingStarPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSRisingStar{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSRisingStarHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSRisingStarHandler Process recv ", data)
|
|
if msg, ok := data.(*pets.CSRisingStar); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSRisingStarHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
SendInfoRole := func(retCode pets.OpResultCode, roleInfo *pets.RoleInfo) {
|
|
pack := &pets.SCRoleRisingStar{
|
|
RetCode: retCode,
|
|
RoleInfo: roleInfo,
|
|
}
|
|
logger.Logger.Trace("SCPetRisingStar:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLE_RISINGSTAR), pack)
|
|
}
|
|
SendInfoPet := func(retCode pets.OpResultCode, petInfo *pets.PetInfo) {
|
|
pack := &pets.SCPetRisingStar{
|
|
RetCode: retCode,
|
|
PetInfo: petInfo,
|
|
}
|
|
logger.Logger.Trace("SCPetRisingStar:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PET_RISINGSTAR), pack)
|
|
}
|
|
if msg.RisingModId == 0 {
|
|
logger.Logger.Warn("CSRisingStarHandler UseModId:", msg.RisingModId)
|
|
SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
|
|
return nil
|
|
}
|
|
if msg.RisingType == 0 {
|
|
roleInfo := PetMgrSington.GetIntroductionByModId(msg.RisingModId)
|
|
if roleInfo == nil {
|
|
SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
|
|
return nil
|
|
}
|
|
if roleInfo.MaxLevel == p.Roles.ModUnlock[msg.RisingModId] {
|
|
logger.Logger.Trace("人物已经达到最大等级")
|
|
SendInfoRole(pets.OpResultCode_OPRC_Error, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
|
|
return nil
|
|
}
|
|
role := PetMgrSington.GetRoleInfo(p, msg.RisingModId)
|
|
if role != nil {
|
|
if role.HaveAmount < role.Amount {
|
|
logger.Logger.Trace("人物碎片道具数量不够", role.HaveAmount, role.Amount)
|
|
return nil
|
|
}
|
|
}
|
|
//背包数据处理
|
|
item := BagMgrSingleton.GetItem(p.SnId, role.Fragment)
|
|
if item != nil {
|
|
// item.ItemNum -= role.Amount
|
|
role.HaveAmount -= role.Amount
|
|
remark := role.Name + "升星"
|
|
BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-role.Amount), 0, common.GainWay_RoleUpgrade,
|
|
"player", remark, 0, 0, false)
|
|
//人物模型状态处理
|
|
p.Roles.ModUnlock[msg.RisingModId]++
|
|
FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
|
|
p.dirty = true
|
|
//人物
|
|
SendInfoRole(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetRoleInfo(p, msg.RisingModId))
|
|
}
|
|
} else if msg.RisingType == 1 {
|
|
petInfo := PetMgrSington.GetIntroductionByModId(msg.RisingModId)
|
|
if petInfo == nil {
|
|
SendInfoPet(pets.OpResultCode_OPRC_Error, PetMgrSington.GetPetInfo(p, msg.RisingModId))
|
|
return nil
|
|
}
|
|
if petInfo.MaxLevel == p.Pets.ModUnlock[msg.RisingModId] {
|
|
logger.Logger.Trace("宠物已经达到最大等级")
|
|
SendInfoPet(pets.OpResultCode_OPRC_Error, PetMgrSington.GetPetInfo(p, msg.RisingModId))
|
|
return nil
|
|
}
|
|
|
|
pet := PetMgrSington.GetPetInfo(p, msg.RisingModId)
|
|
if pet != nil {
|
|
if pet.HaveAmount < pet.Amount {
|
|
logger.Logger.Trace("宠物碎片道具数量不够", pet.HaveAmount, pet.Amount)
|
|
return nil
|
|
}
|
|
}
|
|
//背包数据处理
|
|
item := BagMgrSingleton.GetItem(p.SnId, pet.Fragment)
|
|
if item != nil {
|
|
// item.ItemNum -= pet.Amount
|
|
pet.HaveAmount -= pet.Amount
|
|
remark := pet.Name + "升星"
|
|
BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-pet.Amount), 0, common.GainWay_PetUpgrade,
|
|
"player", remark, 0, 0, false)
|
|
|
|
p.Pets.ModUnlock[msg.RisingModId]++
|
|
FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
|
|
p.dirty = true
|
|
//宠物
|
|
SendInfoPet(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetPetInfo(p, msg.RisingModId))
|
|
}
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CSRolePetUseOpPacketFactory struct {
|
|
}
|
|
|
|
type CSRolePetUseOpHandler struct {
|
|
}
|
|
|
|
func (this *CSRolePetUseOpPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSRolePetUseOp{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSRolePetUseOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSRolePetUseOpHandler Process recv ", data)
|
|
if msg, ok := data.(*pets.CSRolePetUseOp); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSRolePetUseOpHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
if msg.UseModId == 0 {
|
|
logger.Logger.Warn("CSRolePetUseOpHandler UseModId:", msg.UseModId)
|
|
return nil
|
|
}
|
|
if msg.UseModType == 0 {
|
|
if p.Roles.ModId == msg.UseModId {
|
|
logger.Logger.Trace("人物使用中 不能直接取消人物使用")
|
|
return nil
|
|
}
|
|
p.Roles.ModId = msg.UseModId
|
|
p.dirty = true
|
|
logger.Logger.Trace("使用人物:", msg.UseModId)
|
|
} else {
|
|
if p.Pets.ModId == msg.UseModId {
|
|
p.Pets.ModId = 0
|
|
logger.Logger.Trace("取消宠物跟随:", msg.UseModId)
|
|
p.dirty = true
|
|
} else {
|
|
logger.Logger.Trace("设置宠物跟随:", msg.UseModId)
|
|
p.Pets.ModId = msg.UseModId
|
|
p.dirty = true
|
|
}
|
|
}
|
|
pack := &pets.SCRolePetUseOp{
|
|
RetCode: pets.OpResultCode_OPRC_Sucess,
|
|
UseModType: msg.UseModType,
|
|
UseModId: msg.UseModId,
|
|
}
|
|
logger.Logger.Trace("SCRolePetUseOp:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLEPETUSEOP), pack)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CSRolePetUnlockPacketFactory struct {
|
|
}
|
|
|
|
type CSRolePetUnlockHandler struct {
|
|
}
|
|
|
|
func (this *CSRolePetUnlockPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSRolePetUnlock{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSRolePetUnlockHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Trace("CSRolePetUnlockHandler Process recv ", data)
|
|
if msg, ok := data.(*pets.CSRolePetUnlock); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSRolePetUnlockHandler p == nil")
|
|
return nil
|
|
}
|
|
platform := p.GetPlatform()
|
|
if platform == nil {
|
|
return nil
|
|
}
|
|
SendMsg := func(retCode pets.OpResultCode, roleInfo *pets.RoleInfo, petInfo *pets.PetInfo) {
|
|
pack := &pets.SCRolePetUnlock{
|
|
RetCode: retCode,
|
|
UseModType: msg.UseModType,
|
|
UseModId: msg.UseModId,
|
|
RoleInfo: roleInfo,
|
|
PetInfo: petInfo,
|
|
}
|
|
logger.Logger.Trace("SCRolePetUnlock:", pack)
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_ROLEPETUNLOCK), pack)
|
|
}
|
|
if msg.UseModId == 0 {
|
|
logger.Logger.Warn("CSRolePetUnlockHandler UseModId:", msg.UseModId)
|
|
SendMsg(pets.OpResultCode_OPRC_Error, nil, nil)
|
|
return nil
|
|
}
|
|
if msg.UseModType == 0 {
|
|
if _, ok1 := p.Roles.ModUnlock[msg.UseModId]; !ok1 {
|
|
roleInfo := PetMgrSington.GetRoleInfo(p, msg.UseModId)
|
|
if roleInfo != nil {
|
|
item := BagMgrSingleton.GetItem(p.SnId, roleInfo.Fragment)
|
|
if item != nil && item.ItemNum >= int64(roleInfo.Amount) {
|
|
remark := roleInfo.Name + "解锁"
|
|
BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-roleInfo.Amount), 0, common.GainWay_RoleUpgrade,
|
|
"player", remark, 0, 0, false)
|
|
|
|
p.Roles.ModUnlock[msg.UseModId] = 1
|
|
if p.Roles.Mod[msg.UseModId] == nil {
|
|
p.Roles.Mod[msg.UseModId] = &model.ModEx{}
|
|
}
|
|
if p.Roles.Mod[msg.UseModId].Ts == 0 {
|
|
p.Roles.Mod[msg.UseModId].Ts = time.Now().Unix()
|
|
}
|
|
FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
|
|
p.dirty = true
|
|
logger.Logger.Trace("解锁人物", msg.UseModId)
|
|
SendMsg(pets.OpResultCode_OPRC_Sucess, PetMgrSington.GetRoleInfo(p, msg.UseModId), nil)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
} else if msg.UseModType == 1 {
|
|
if _, ok1 := p.Pets.ModUnlock[msg.UseModId]; !ok1 {
|
|
petInfo := PetMgrSington.GetPetInfo(p, msg.UseModId)
|
|
if petInfo != nil {
|
|
item := BagMgrSingleton.GetItem(p.SnId, petInfo.Fragment)
|
|
if item != nil && item.ItemNum >= int64(petInfo.Amount) {
|
|
remark := petInfo.Name + "解锁"
|
|
BagMgrSingleton.AddItem(p, int64(item.ItemId), int64(-petInfo.Amount), 0, common.GainWay_PetUpgrade,
|
|
"player", remark, 0, 0, false)
|
|
|
|
p.Pets.ModUnlock[msg.UseModId] = 1
|
|
if p.Pets.Mod[msg.UseModId] == nil {
|
|
p.Pets.Mod[msg.UseModId] = &model.ModEx{}
|
|
}
|
|
if p.Pets.Mod[msg.UseModId].Ts == 0 {
|
|
p.Pets.Mod[msg.UseModId].Ts = time.Now().Unix()
|
|
}
|
|
FriendMgrSington.UpdateInfo(p.Platform, p.SnId)
|
|
p.dirty = true
|
|
logger.Logger.Trace("解锁宠物", msg.UseModId)
|
|
SendMsg(pets.OpResultCode_OPRC_Sucess, nil, PetMgrSington.GetPetInfo(p, msg.UseModId))
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SendMsg(pets.OpResultCode_OPRC_Error, nil, nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 宠物技能升级
|
|
type CSPetSkillLevelUpPacketFactory struct {
|
|
}
|
|
|
|
type CSPetSkillLevelUpHandler struct {
|
|
}
|
|
|
|
func (this *CSPetSkillLevelUpPacketFactory) CreatePacket() interface{} {
|
|
pack := &pets.CSPetSkillLevelUp{}
|
|
return pack
|
|
}
|
|
|
|
func (this *CSPetSkillLevelUpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
if msg, ok := data.(*pets.CSPetSkillLevelUp); ok {
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSPetSkillLevelUp p == nil")
|
|
return nil
|
|
}
|
|
skillId := msg.SkillId
|
|
petId := msg.PetId
|
|
if p.Pets.SkillInfo == nil {
|
|
p.Pets.SkillInfo = make(map[int32]map[int32]int32)
|
|
}
|
|
level := int32(0)
|
|
if p.Pets.SkillInfo[petId] != nil {
|
|
level = p.Pets.SkillInfo[petId][skillId]
|
|
}
|
|
logger.Logger.Tracef("玩家升级宠物技能%d %d %d", petId, skillId, level)
|
|
data := srvdata.PBDB_PetSkillMgr.Datas.GetArr()
|
|
var SkillInfo *server.DB_PetSkill = nil
|
|
for _, info := range data {
|
|
if info.PetId == petId && info.SkillId == skillId && info.SkillLevel == level+1 {
|
|
SkillInfo = info
|
|
break
|
|
}
|
|
}
|
|
if SkillInfo == nil {
|
|
return nil
|
|
}
|
|
if p.Pets.SkillInfo[petId] == nil {
|
|
p.Pets.SkillInfo[petId] = make(map[int32]int32)
|
|
}
|
|
//消耗道具
|
|
itemCon := SkillInfo.ItemConsum
|
|
var items []*Item
|
|
for itemId, itemNum := range itemCon {
|
|
if itemNum == 0 {
|
|
return nil
|
|
}
|
|
items = append(items, &Item{
|
|
ItemId: int32(itemId),
|
|
ItemNum: -itemNum,
|
|
})
|
|
}
|
|
_, _, isF := BagMgrSingleton.AddItems(p, items, 0, common.GainWayPetSkillLevelUp, "system", "宠物技能升级消耗", 0, 0, false)
|
|
if isF {
|
|
p.Pets.SkillInfo[petId][skillId] = level + 1
|
|
if level == 0 {
|
|
if p.Pets.Skill[petId] == nil {
|
|
p.Pets.Skill[petId] = make(map[int32]*model.SkillEx)
|
|
}
|
|
if p.Pets.Skill[petId][skillId] == nil {
|
|
p.Pets.Skill[petId][skillId] = &model.SkillEx{}
|
|
}
|
|
if p.Pets.Skill[petId][skillId].Ts == 0 {
|
|
p.Pets.Skill[petId][skillId].Ts = time.Now().Unix()
|
|
}
|
|
}
|
|
pack := &pets.SCPetSkillLevelUp{}
|
|
pack.PetId = petId
|
|
pack.SkillId = skillId
|
|
pack.SkillLevel = p.Pets.SkillInfo[petId][skillId]
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_PETSKILLLEVELUP), pack)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func CSSkinInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSSkinInfo %v", data)
|
|
_, ok := data.(*pets.CSSkinInfo)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSSkinInfo p == nil")
|
|
return nil
|
|
}
|
|
pack := &pets.SCSkinInfo{
|
|
Infos: PetMgrSington.GetSkinInfos(p),
|
|
}
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_INFO), pack)
|
|
logger.Logger.Tracef("SCSkinInfo: %v", pack)
|
|
return nil
|
|
}
|
|
|
|
func CSSkinUse(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSSkinUse %v", data)
|
|
msg, ok := data.(*pets.CSSkinUse)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSSkinUse p == nil")
|
|
return nil
|
|
}
|
|
|
|
pack := &pets.SCSkinUse{
|
|
Id: msg.GetId(),
|
|
SnId: p.SnId,
|
|
RetCode: pets.OpResultCode_OPRC_Error,
|
|
}
|
|
send := func() {
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_USE), pack)
|
|
logger.Logger.Tracef("SCSkinUse: %v", pack)
|
|
|
|
// 在游戏中广播
|
|
if pack.RetCode == pets.OpResultCode_OPRC_Sucess {
|
|
if p.scene != nil && p.scene.dbGameFree.GetGameType() == common.GameType_PVP {
|
|
p.scene.Broadcast(int(pets.PetsPacketID_PACKET_SC_SKIN_USE), pack, sid)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 已解锁的
|
|
info := PetMgrSington.GetSkinInfo(p, msg.GetId())
|
|
if !info.GetIsUnlock() {
|
|
logger.Logger.Errorf("CSSkinUse unlock")
|
|
pack.RetCode = pets.OpResultCode_OPRC_Unlock
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
p.Skin.ModId = msg.GetId()
|
|
pack.RetCode = pets.OpResultCode_OPRC_Sucess
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
func CSSkinUpgrade(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSSkinUpgrade %v", data)
|
|
msg, ok := data.(*pets.CSSkinUpgrade)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Warn("CSSkinUpgrade p == nil")
|
|
return nil
|
|
}
|
|
|
|
cfg := PlatformMgrSingleton.GetSkinInfo(p.Platform, msg.GetId())
|
|
|
|
pack := &pets.SCSkinUpgrade{
|
|
RetCode: pets.OpResultCode_OPRC_Error,
|
|
}
|
|
send := func() {
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UPGRADE), pack)
|
|
logger.Logger.Tracef("SCSkinUpgrade: %v", pack)
|
|
}
|
|
|
|
// 是否已经解锁
|
|
info := PetMgrSington.GetSkinInfo(p, msg.GetId())
|
|
if !info.GetIsUnlock() {
|
|
logger.Logger.Errorf("CSSkinUpgrade not unlock")
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
if info.GetLevel() >= PlatformMgrSingleton.GetSkinMaxLevel(p.Platform, msg.GetId()) || cfg.GetIsUpgrade() == 2 {
|
|
logger.Logger.Errorf("CSSkinUpgrade max level")
|
|
pack.RetCode = pets.OpResultCode_OPRC_MaxLevel
|
|
send()
|
|
return nil
|
|
}
|
|
|
|
var change []*model.Item
|
|
for _, v := range info.GetCost() {
|
|
e := BagMgrSingleton.GetItem(p.SnId, v.GetId())
|
|
if e == nil || e.ItemNum < v.GetN() {
|
|
logger.Logger.Errorf("CSSkinUpgrade not enough")
|
|
pack.RetCode = pets.OpResultCode_OPRC_NotEnough
|
|
send()
|
|
return nil
|
|
}
|
|
change = append(change, &model.Item{
|
|
ItemId: v.GetId(),
|
|
ItemNum: -v.GetN(),
|
|
})
|
|
}
|
|
_, _, ok = BagMgrSingleton.AddItemsV2(&model.AddItemParam{
|
|
P: p.PlayerData,
|
|
Change: change,
|
|
Add: 0,
|
|
GainWay: common.GainWaySkinUpGrade,
|
|
Operator: "system",
|
|
Remark: "皮肤升级消耗",
|
|
NoLog: false,
|
|
})
|
|
if !ok {
|
|
logger.Logger.Errorf("CSSkinUpgrade upgrade error")
|
|
send()
|
|
return nil
|
|
}
|
|
p.Skin.ModUnlock[msg.GetId()] = info.GetLevel() + 1
|
|
pack.RetCode = pets.OpResultCode_OPRC_Sucess
|
|
pack.Info = PetMgrSington.GetSkinInfo(p, msg.GetId())
|
|
send()
|
|
|
|
// 任务加成变更
|
|
if info.GetSkillId() == common.SkillIdTask && p.GetSkillAdd(common.SkillIdTask) > 0 {
|
|
OnNotifyChange(p, common.TaskActivityTypeEveryDay)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func SkinUnLock(p *Player, id int32) (*pets.SkinInfo, pets.OpResultCode) {
|
|
cfg := PlatformMgrSingleton.GetSkinInfo(p.Platform, id)
|
|
if cfg == nil {
|
|
return nil, pets.OpResultCode_OPRC_Error
|
|
}
|
|
|
|
info := PetMgrSington.GetSkinInfo(p, id)
|
|
if info.GetIsUnlock() {
|
|
return nil, pets.OpResultCode_OPRC_Error
|
|
}
|
|
|
|
var change []*model.Item
|
|
if info.GetUnLockType() == common.SkinGetVip {
|
|
if p.VIP < info.GetNeedVip() {
|
|
logger.Logger.Errorf("CSSKinUnLock Unlock vip error")
|
|
return nil, pets.OpResultCode_OPRC_Error
|
|
}
|
|
} else {
|
|
for _, v := range info.GetCost() {
|
|
e := BagMgrSingleton.GetItem(p.SnId, v.GetId())
|
|
if e == nil || e.ItemNum < v.GetN() {
|
|
return nil, pets.OpResultCode_OPRC_NotEnough
|
|
}
|
|
change = append(change, &model.Item{
|
|
ItemId: v.GetId(),
|
|
ItemNum: -v.GetN(),
|
|
})
|
|
}
|
|
_, _, ok := BagMgrSingleton.AddItemsV2(&model.AddItemParam{
|
|
P: p.PlayerData,
|
|
Change: change,
|
|
Add: 0,
|
|
GainWay: common.GainWaySkinUnLock,
|
|
Operator: "system",
|
|
Remark: "皮肤解锁消耗",
|
|
NoLog: false,
|
|
})
|
|
if !ok {
|
|
logger.Logger.Errorf("CSSKinUnLock Unlock error")
|
|
return nil, pets.OpResultCode_OPRC_Error
|
|
}
|
|
}
|
|
p.Skin.ModUnlock[id] = 1
|
|
if p.Skin.Mod[id] == nil {
|
|
p.Skin.Mod[id] = &model.ModEx{}
|
|
}
|
|
if p.Skin.Mod[id].Ts == 0 {
|
|
p.Skin.Mod[id].Ts = time.Now().Unix()
|
|
}
|
|
pack := &pets.SCSkinUnLock{
|
|
Id: id,
|
|
RetCode: pets.OpResultCode_OPRC_Sucess,
|
|
Info: PetMgrSington.GetSkinInfo(p, id),
|
|
}
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UNLOCK), pack)
|
|
logger.Logger.Tracef("SCSkinUnlock: %v", pack)
|
|
|
|
// 任务加成变更
|
|
if info.GetSkillId() == common.SkillIdTask && p.GetSkillAdd(common.SkillIdTask) > 0 {
|
|
OnNotifyChange(p, common.TaskActivityTypeEveryDay)
|
|
}
|
|
|
|
// 自动使用
|
|
if cfg.GetUnlockType() == common.SkinGetAuto {
|
|
CSSkinUse(p.gateSess, int(pets.PetsPacketID_PACKET_CS_SKIN_USE), &pets.CSSkinUse{Id: id}, p.sid)
|
|
}
|
|
return pack.Info, pets.OpResultCode_OPRC_Sucess
|
|
}
|
|
|
|
func CSSKinUnLock(s *netlib.Session, packetid int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSSKinUnLock %v", data)
|
|
msg, ok := data.(*pets.CSSKinUnLock)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
logger.Logger.Errorf("CSSKinUnLock p == nil")
|
|
return nil
|
|
}
|
|
|
|
pack := &pets.SCSkinUnLock{
|
|
Id: msg.GetId(),
|
|
RetCode: pets.OpResultCode_OPRC_Error,
|
|
}
|
|
send := func() {
|
|
p.SendToClient(int(pets.PetsPacketID_PACKET_SC_SKIN_UNLOCK), pack)
|
|
logger.Logger.Tracef("SCSkinUnlock: %v", pack)
|
|
}
|
|
|
|
pack.Info, pack.RetCode = SkinUnLock(p, msg.GetId())
|
|
if pack.GetRetCode() != pets.OpResultCode_OPRC_Sucess {
|
|
send()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLE_INFO), &CSRoleInfoHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLE_INFO), &CSRoleInfoPacketFactory{})
|
|
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PET_INFO), &CSPetInfoHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PET_INFO), &CSPetInfoPacketFactory{})
|
|
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PET_RISINGSTAR), &CSRisingStarHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PET_RISINGSTAR), &CSRisingStarPacketFactory{})
|
|
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLEPETUSEOP), &CSRolePetUseOpHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLEPETUSEOP), &CSRolePetUseOpPacketFactory{})
|
|
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_ROLEPETUNLOCK), &CSRolePetUnlockHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_ROLEPETUNLOCK), &CSRolePetUnlockPacketFactory{})
|
|
|
|
common.RegisterHandler(int(pets.PetsPacketID_PACKET_CS_PETSKILLLEVELUP), &CSPetSkillLevelUpHandler{})
|
|
netlib.RegisterFactory(int(pets.PetsPacketID_PACKET_CS_PETSKILLLEVELUP), &CSPetSkillLevelUpPacketFactory{})
|
|
|
|
// 皮肤信息
|
|
common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_INFO), pets.CSSkinInfo{}, CSSkinInfo)
|
|
// 皮肤解锁
|
|
common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_UNLOCK), pets.CSSKinUnLock{}, CSSKinUnLock)
|
|
// 皮肤使用
|
|
common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_USE), pets.CSSkinUse{}, CSSkinUse)
|
|
// 皮肤升级
|
|
common.Register(int(pets.PetsPacketID_PACKET_CS_SKIN_UPGRADE), pets.CSSkinUpgrade{}, CSSkinUpgrade)
|
|
}
|