1542 lines
45 KiB
Go
1542 lines
45 KiB
Go
package game
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"os/exec"
|
||
"server/GoUtil"
|
||
"server/MergeConst"
|
||
mergeCluster "server/cluster"
|
||
"server/conf"
|
||
cardCfg "server/conf/card"
|
||
chargeCfg "server/conf/charge"
|
||
decorateCfg "server/conf/decorate"
|
||
itemCfg "server/conf/item"
|
||
limitedTimeEventCfg "server/conf/limitedTimeEvent"
|
||
mailCfg "server/conf/mail"
|
||
mergeDataCfg "server/conf/mergeData"
|
||
orderCfg "server/conf/order"
|
||
playroomCfg "server/conf/playroom"
|
||
userCfg "server/conf/user"
|
||
"server/db"
|
||
"server/game/mod/activity"
|
||
"server/game/mod/card"
|
||
"server/game/mod/friend"
|
||
"server/game/mod/item"
|
||
"server/game/mod/mail"
|
||
"server/game/mod/msg"
|
||
"server/game/mod/order"
|
||
"server/game/mod/playroom"
|
||
proto "server/msg"
|
||
"server/pkg/github.com/name5566/leaf/log"
|
||
"sort"
|
||
"strings"
|
||
)
|
||
|
||
// 处理玩家异步请求
|
||
func HandleMsg(p *Player, m *msg.Msg) {
|
||
p.lock.Lock() //加锁
|
||
backup := p.BackUp() // 备份当前的 Player 值
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
log.Error("Handle msg uid : %d, msg : %v, fatal : %s", p.M_DwUin, m, r)
|
||
p.Recover(backup) //还原Player的数据
|
||
}
|
||
p.lock.Unlock() //解锁
|
||
}()
|
||
p.args = make(map[string]interface{})
|
||
err := handle(p, m)
|
||
if err != nil {
|
||
log.Debug("uid : %d, err : %s", p.M_DwUin, err)
|
||
p.Recover(backup) //还原Player的数据
|
||
return
|
||
}
|
||
p.ProcessTrigger()
|
||
p.SendClientRes()
|
||
}
|
||
|
||
// 消息处理
|
||
func handle(p *Player, m *msg.Msg) error {
|
||
switch m.Type {
|
||
case msg.HANDLE_TYPE_DEL, msg.HANDLE_TYPE_APPLY, msg.HADNLE_TYPE_AGREE, msg.HANDLE_TYPE_REQ_CARD, msg.HANDLE_TYPE_REFUSE:
|
||
return HandleFriendMsg(p, m)
|
||
case msg.SERVER_ZERO_UPDATE:
|
||
p.ZeroUpdate(nil)
|
||
case msg.SERVER_NOON_UPDATE:
|
||
p.NoonUpdate(nil)
|
||
case msg.HANDLE_TYPE_INVITE_ADD_FRIEND: // 邀请添加好友
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
if m.From == 0 && m.From == int(p.M_DwUin) {
|
||
return nil
|
||
}
|
||
FriendMod.AddFriend(m.From)
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
PlayroomMod.AddRoomPointAdd(BaseMod.GetLevel())
|
||
PlayroomBackData(p)
|
||
p.TeLog("friend_add", map[string]interface{}{
|
||
"player_id": m.From,
|
||
"add_type": "发起申请",
|
||
})
|
||
p.PlayMod.save()
|
||
case msg.HANDLE_TYPE_INVITE_FRIEND: // 邀请好友
|
||
InviteMod := p.PlayMod.getInviteMod()
|
||
InviteMod.AddInvite(m.From)
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_INVITE, "", m.SendT)
|
||
p.PlayMod.save()
|
||
p.PushClientRes(InviteMod.NotifySuccess())
|
||
case msg.HANDLE_TYPE_SEND_CARD: // B收到A赠送的卡牌
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
FriendMod.Interact(CardInfo.AUid, friend.INTERACT_TYPE_CARD, m.SendT)
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
p.PlayMod.save()
|
||
case msg.HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT: // A收到B置换卡牌选择超时
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
CardMod := p.PlayMod.getCardMod()
|
||
p.AddCard(CardInfo.CardId)
|
||
CardMod.DelExCard(&CardInfo)
|
||
p.PushClientRes(CardMod.NotifyCard())
|
||
p.PushClientRes(CardMod.NotifyTimes())
|
||
case msg.HANDLE_TYPE_EX_CARD_TIMEOUT: // B收到A同意置换卡牌超时
|
||
CardInfo, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
CardMod := p.PlayMod.getCardMod()
|
||
p.AddCard(CardInfo.ExId)
|
||
p.PushClientRes(CardMod.NotifyCard())
|
||
p.PushClientRes(CardMod.NotifyTimes())
|
||
case msg.HANDLE_TYPE_REG_CARD_FINISH, msg.HANDLE_TYPE_AGREE_CARD_FAIL: // B收到A的请求已结束
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.DelCardInfo(CardInfo.Id)
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
p.PlayMod.save()
|
||
case msg.HANDLE_TYPE_AGREE_CARD: // A收到B同意卡牌
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
CardMod := p.PlayMod.getCardMod()
|
||
OtherUid, err := CardMod.DelRequestCard(CardInfo.BUid)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
if err != nil { // 同意失败，请求已失效
|
||
msg := &msg.Msg{Type: msg.HANDLE_TYPE_AGREE_CARD_FAIL, From: CardInfo.AUid, End: CardInfo.EndTime, Extra: CardInfo}
|
||
FriendMgrSend(msg)
|
||
return nil
|
||
}
|
||
for k, v := range OtherUid { // 通知好友请求已结束
|
||
v.Status = card.STATUS_CARD_GIVE_3
|
||
msg := &msg.Msg{Type: msg.HANDLE_TYPE_REG_CARD_FINISH, From: k, Extra: &v}
|
||
FriendMgrSend(msg)
|
||
CardMod.DelRequestCard(k)
|
||
}
|
||
// p.AddLog(int(p.M_DwUin), friend.LOG_TYPE_CARD_ACCEPT_GIVE, fmt.Sprintf("%d", CardInfo.CardId))
|
||
p.PlayMod.save()
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
p.PushClientRes(CardMod.NotifyTimes())
|
||
case msg.HANDLE_TYPE_REG_CARD_REFUSE: // A收到B拒绝索要卡牌
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
CardMod := p.PlayMod.getCardMod()
|
||
CardMod.DelRequestCard(CardInfo.BUid)
|
||
CardMod.AddReqTimes(CardInfo.Id, CardInfo.StartTime)
|
||
p.PlayMod.save()
|
||
p.PushClientRes(CardMod.NotifyTimes())
|
||
p.PushClientRes(CardMod.NotifyCard())
|
||
case msg.HANDLE_TYPE_EX_CARD: // B收到A置换卡牌
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
FriendMod.Interact(CardInfo.AUid, friend.INTERACT_TYPE_EX, m.SendT)
|
||
p.PlayMod.save()
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
case msg.HANDLE_TYPE_SELECT_EX_CARD: // A收到B选择卡牌进行置换
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
// p.AddLog(int(p.M_DwUin), friend.LOG_TYPE_CARD_SELECT_GET, fmt.Sprintf("%d", CardInfo.CardId))
|
||
p.PlayMod.save()
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
case msg.HANDLE_TYPE_ARGREE_EX_CARD: // B收到A同意置换卡牌
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
p.PlayMod.save()
|
||
case msg.HANDLE_TYPE_REFUSE_SELECT_CARD: // A收到B拒绝置换卡牌
|
||
CardMod := p.PlayMod.getCardMod()
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
CardMod.AddExTimes(&CardInfo)
|
||
p.AddCard(CardInfo.CardId)
|
||
CardMod.DelExCard(&CardInfo)
|
||
p.PushClientRes(CardMod.NotifyCard())
|
||
p.PushClientRes(CardMod.NotifyTimes())
|
||
p.PlayMod.save()
|
||
case msg.HANDLE_TYPE_REFUSE_EX_CARD: // B收到A拒绝置换卡牌
|
||
CardMod := p.PlayMod.getCardMod()
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
p.AddCard(CardInfo.ExId)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.DelCardInfo(CardInfo.Id)
|
||
if cardCfg.CheckCardIsGold(CardInfo.CardId) || cardCfg.CheckCardIsGold(CardInfo.ExId) {
|
||
CardMod.AddGoldTimes()
|
||
}
|
||
p.PlayMod.save()
|
||
p.PushClientRes(CardMod.NotifyCard())
|
||
case msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY: // # 锦标赛排名变动通知
|
||
BackChampship(p)
|
||
case msg.HANDLE_TYPE_CHAMPSHIP_RESULT: // # 好友锦标赛结果
|
||
Extra := m.Extra.([]int)
|
||
p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_CHAMPSHIP, fmt.Sprintf("%d_%d", Extra[0], Extra[1]), m.SendT)
|
||
case msg.HANDLE_TYPE_TREASURE_RESULT: // # 好友宝藏结果
|
||
//p.AddLog(m.From, friend.LOG_TYPE_TREASURE, fmt.Sprintf("%d", m.Extra.(int)), m.SendT)
|
||
case msg.HANDLE_TYPE_MAIL: // 邮件操作
|
||
SyncMailMsg(p)
|
||
case msg.HANDLE_TYPE_PLAYROOM_LOSE: // # 玩家输了
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
Items := m.Item
|
||
GameId := playroom.GAME_TYPE_HOOK
|
||
Emoji := 0
|
||
if m.Extra != nil {
|
||
if val, ok := m.Extra.(GameResult); ok {
|
||
GameId = val.T
|
||
Emoji = val.Emoji
|
||
}
|
||
}
|
||
if len(Items) == 0 {
|
||
return nil
|
||
}
|
||
if GameId == playroom.GAME_TYPE_HOOK || GameId == playroom.GAME_TYPE_HIDE {
|
||
PlayroomMod.AddChip(m.From, m.SendT, Emoji)
|
||
p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_CAT_WIN, fmt.Sprintf("%d_%d_%d", Items[0].Id, Items[0].Num, Emoji), m.SendT)
|
||
} else {
|
||
p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_VISIT, fmt.Sprintf("%d_%d_%d", Items[0].Id, Items[0].Num, Emoji), m.SendT)
|
||
}
|
||
PlayroomMod.AddMood(playroom.MOOD_TYPE_FOOD, -50)
|
||
PlayroomMod.AddMood(playroom.MOOD_TYPE_CLEAN, -50)
|
||
PlayroomMod.AddVisitor(m.From, m.SendT)
|
||
|
||
if len(Items) > 0 && Items[0].Id == item.ITEM_STAR_ID {
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
StarNum := BaseMod.GetStar()
|
||
Items[0].Num = min(Items[0].Num, StarNum)
|
||
p.HandleLoseItem(Items, "HANDLE_TYPE_PLAYROOM_LOSE")
|
||
} else {
|
||
PlayroomMod.Lose(Items)
|
||
}
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.Interact(m.From, friend.INTERACT_TYPE_VISIT, m.SendT)
|
||
p.UpdateUserInfo()
|
||
p.Kafka(PLAYROOM_LOST, map[string]interface{}{"uid": m.From, "item": Items})
|
||
p.PushClientRes(PlayroomMod.NotifyLose())
|
||
case msg.HANDLE_TYPE_PLAYROOM_GAME:
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
Emoji := 0
|
||
if m.Extra != nil {
|
||
if val, ok := m.Extra.(GameResult); ok {
|
||
Emoji = val.Emoji
|
||
}
|
||
}
|
||
p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_CAT_LOSE, fmt.Sprintf("%d", Emoji), m.SendT)
|
||
FriendMod.Interact(m.From, friend.INTERACT_TYPE_VISIT, m.SendT)
|
||
case msg.FRIEND_TREASURE_HANDLE: // # 好友宝藏
|
||
Items := make([]*item.Item, 0)
|
||
if m.Extra != nil {
|
||
Items = m.Extra.([]*item.Item)
|
||
}
|
||
p.AddLog(m.From, friend.LOG_TYPE_TREASURE_HELP, "", m.SendT)
|
||
p.HandleItem(Items, proto.ITEM_POP_LABEL_Friendtreasure.String())
|
||
case msg.HANDLE_TYPE_HANDBOOK_COLLECTION: // 图鉴收集奖励
|
||
if m.Extra != nil {
|
||
return nil
|
||
}
|
||
data, ok := m.Extra.(msg.HandbookMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
p.AddLog(m.From, friend.LOG_TYPE_HANDBOOK, data.Type, m.SendT)
|
||
case msg.HANDLE_TYPE_HANDBOOK_UPVOTE: // 图鉴点赞
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.Interact(m.From, friend.INTERACT_TYPE_UPVOTE, m.SendT)
|
||
p.AddLog(m.From, friend.LOG_TYPE_HANDBOOK_UPVOTE, "", m.SendT)
|
||
case msg.HANDLE_TYPE_SEND_CHARGE: // 收到好友赠送的充值礼包
|
||
C := &ChargeExtra{}
|
||
if m.Extra != nil {
|
||
C = m.Extra.(*ChargeExtra)
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
MailMod := p.PlayMod.getMailMod()
|
||
mt, mc, mt_en, mc_en := mailCfg.GetChargeSendMail(PlayerSimpleData.Name)
|
||
Items := ChargeItem(p, C.ChargeId)
|
||
MailId := MailMod.Send(mt, "", mc, mt_en, "", mc_en, Items, mail.MAIL_TYPE_GIFT)
|
||
p.AddLog(m.From, friend.LOG_TYPE_CHARGE_SEND, fmt.Sprintf("%d", MailId), m.SendT)
|
||
p.PushClientRes(MailMod.NotifyMail(MailId))
|
||
case msg.HANDLE_TYPE_CHARGE_RECEIVE: // 收到好友的感谢信
|
||
Content := ""
|
||
if m.Extra != nil {
|
||
Content = m.Extra.(string)
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
MailMod := p.PlayMod.getMailMod()
|
||
mt, mc, mt_en, mc_en := mailCfg.GetChargeReceiveMail(PlayerSimpleData.Name, Content)
|
||
MailId := MailMod.Send(mt, "", mc, mt_en, "", mc_en, nil, mail.MAIL_TYPE_NORMAL)
|
||
p.AddLog(m.From, friend.LOG_TYPE_CHARGE_RECEIVE, fmt.Sprintf("%d", MailId), m.SendT)
|
||
p.PushClientRes(MailMod.NotifyMail(MailId))
|
||
case msg.HANDLE_TYPE_WISHLIST_SEND: // 发送愿望单请求
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.AddWishApply(int64(m.From))
|
||
case msg.HANDLE_TYPE_PLAYROOM_UPVOTE: // playroom点赞
|
||
p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_UPVOTE, "", m.SendT)
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
PlayroomMod.AddUpvote()
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.Interact(m.From, friend.INTERACT_TYPE_VISIT, m.SendT)
|
||
p.UpdateUserInfo()
|
||
case msg.HANDLE_TYPE_WISHLIST_AGREE:
|
||
ChargeMod := p.PlayMod.getChargeMod()
|
||
ChargeMod.AddWishCount()
|
||
p.AddLog(m.From, friend.LOG_TYPE_WISH, "", m.SendT)
|
||
p.PushClientRes(ChargeMod.BackData())
|
||
case msg.HANDLE_TYPE_PLAYROOM_KISS: // playroom亲吻
|
||
p.NotifyPlayroomKiss()
|
||
case msg.HANDLE_TYPE_CATNIP_INVITE: // 邀请好友参与猫咪游戏
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg := m.Extra.(CatnipMsg)
|
||
ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.BeInvited(CatnipMsg.GameId, int(m.From), m.SendT)
|
||
case msg.HANDLE_TYPE_CATNIP_AGREE: // 同意好友参与猫咪游戏
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsgInfo := m.Extra.(CatnipMsg)
|
||
ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsgInfo.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
UserList, _ := CatnipMod.Agree(CatnipMsgInfo.GameId, int(m.From))
|
||
for _, v := range UserList {
|
||
FriendMgrSend(&msg.Msg{
|
||
From: int(p.M_DwUin),
|
||
To: int(v),
|
||
Type: msg.HANDLE_TYPE_CATNIP_AGREE,
|
||
Extra: CatnipMsg{
|
||
ActivityId: ActivityId,
|
||
GameId: int(CatnipMsgInfo.GameId),
|
||
},
|
||
SendT: GoUtil.Now(),
|
||
})
|
||
}
|
||
case msg.HANDLE_TYPE_CATNIP_AGREE_DEL: // 同意好友参与猫咪游戏后删除邀请
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg := m.Extra.(CatnipMsg)
|
||
ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.DelInvited(CatnipMsg.GameId, int(m.From))
|
||
case msg.HANDLE_TYPE_CATNIP_REFUSE: // 拒绝好友参与猫咪游戏
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg := m.Extra.(CatnipMsg)
|
||
ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.DelInvited(CatnipMsg.GameId, int(m.From))
|
||
case msg.HANDLE_TYPE_CATNIP_GROWTH:
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipGrowthInfo := m.Extra.(CatnipMsg)
|
||
ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipGrowthInfo.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.Growth(CatnipGrowthInfo.GameId, CatnipGrowthInfo.Growth)
|
||
default:
|
||
log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
|
||
}
|
||
// #region 以下是处理系统请求
|
||
return nil
|
||
}
|
||
|
||
// 处理系统请求
|
||
func HandleServerMsg(p *Player, msg *msg.Msg) error {
|
||
return nil
|
||
}
|
||
|
||
// 处理好友请求
|
||
func HandleFriendMsg(p *Player, m *msg.Msg) error {
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
switch m.Type {
|
||
case msg.HANDLE_TYPE_APPLY: // 好友申请
|
||
FriendMod.AddFriendApply(m.From)
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_APPLY, "", m.SendT)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_APPLY,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HADNLE_TYPE_AGREE: // 同意好友申请
|
||
FriendMod.AgreeApply(m.From)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_AGREE,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
PlayroomMod.AddRoomPointAdd(BaseMod.GetLevel())
|
||
PlayroomBackData(p)
|
||
p.TeLog("friend_add", map[string]interface{}{
|
||
"player_id": m.From,
|
||
"add_type": "接受申请",
|
||
})
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_BECOME, "", m.SendT)
|
||
case msg.HANDLE_TYPE_DEL: // 删除好友
|
||
FriendMod.DelFriend(m.From)
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_APPLY, "", m.SendT)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_DEL,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HANDLE_TYPE_REFUSE: // 拒绝好友申请
|
||
FriendMod.RefuseApply(m.From)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_REFUSE,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HANDLE_TYPE_REQ_CARD: // 卡牌申请
|
||
CardInfo := m.Extra.(card.CardInfo)
|
||
FriendMod.SetCardInfo(&CardInfo)
|
||
p.PushClientRes(
|
||
&proto.NotifyFriendCard{
|
||
Info: GetCardInfoMsg(&CardInfo),
|
||
},
|
||
)
|
||
case msg.HANDLE_TYPE_FACEBOOK_UNBIND: // facebook解绑
|
||
FaceMod := p.PlayMod.getFaceMod()
|
||
if FaceMod.SetId == 0 {
|
||
FaceMod.SetId = 2
|
||
}
|
||
}
|
||
p.PlayMod.save()
|
||
return nil
|
||
}
|
||
|
||
// 同步好友请求
|
||
func SyncFriendMsg(p *Player) {
|
||
MsgList := G_GameLogicPtr.FriendMgrCall(&msg.Msg{Type: msg.HANDLE_TYPE_SYNC, From: int(p.M_DwUin)})
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
MsgId := FriendMod.GetSyncId()
|
||
if MsgList == nil {
|
||
return
|
||
}
|
||
ml := MsgList.([]*msg.Msg)
|
||
if len(ml) == 0 {
|
||
return
|
||
}
|
||
sort.Slice(ml, func(i, j int) bool {
|
||
return ml[i].SendT < ml[j].SendT
|
||
})
|
||
maxId := int64(0)
|
||
for _, v := range ml {
|
||
maxId = max(maxId, v.Id)
|
||
if v.H == 1 {
|
||
continue
|
||
}
|
||
if v.Id > 0 && v.Id <= MsgId {
|
||
continue
|
||
}
|
||
log.Debug("uid : %d, handle friend msg : %v", p.M_DwUin, v)
|
||
handle(p, v)
|
||
v.H = 1
|
||
}
|
||
FriendMod.SetSyncId(maxId)
|
||
p.PlayMod.save()
|
||
}
|
||
|
||
func SyncMailMsg(p *Player) {
|
||
ServerMailList := G_GameLogicPtr.MailMgr.Sync(int(p.M_DwUin), p.GetPlayerBaseMod().GetRegisterTime())
|
||
MailMod := p.PlayMod.getMailMod()
|
||
for _, v := range ServerMailList {
|
||
if GoUtil.InArray(v.Id, MailMod.ServerMail) {
|
||
continue
|
||
}
|
||
MailMod.ServerMail = append(MailMod.ServerMail, v.Id)
|
||
MailMod.Send(v.Title, "", v.Content, v.TitleEn, "", v.ContentEn, v.Items, v.Mail_type)
|
||
}
|
||
p.PushClientRes(MailMod.BackData())
|
||
}
|
||
|
||
// 返回好友信息
|
||
func FriendListBackData(p *Player) {
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
var fl []*proto.ResPlayerSimple
|
||
for k, v := range FriendMod.GetFriendList() {
|
||
if k == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
ps := G_GameLogicPtr.GetResSimplePlayerByUid(k)
|
||
if ps != nil {
|
||
ps.AddTime = v.AddTime
|
||
ps.Interact = FriendMod.GetInteractTime(k)
|
||
fl = append(fl, ps)
|
||
}
|
||
}
|
||
ReqFriendList := make([]int64, 0)
|
||
for k := range FriendMod.SendApply {
|
||
ReqFriendList = append(ReqFriendList, int64(k))
|
||
}
|
||
p.PushClientRes(&proto.ResFriendList{
|
||
FriendList: fl,
|
||
ReqApplyList: ReqFriendList,
|
||
Npc: GoUtil.IntToInt32(FriendMod.GetNpc()),
|
||
})
|
||
}
|
||
|
||
func FriendApplyBackData(p *Player) {
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
var al []*proto.ResFriendApplyInfo
|
||
for k, v := range FriendMod.ApplyList {
|
||
ps := G_GameLogicPtr.GetResSimplePlayerByUid(k)
|
||
if ps != nil {
|
||
al = append(al, &proto.ResFriendApplyInfo{
|
||
Player: ps,
|
||
Time: int32(v),
|
||
})
|
||
}
|
||
}
|
||
p.PushClientRes(&proto.ResFriendApply{
|
||
ApplyList: al,
|
||
})
|
||
}
|
||
|
||
func FriendLogBackData(p *Player) {
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
var log []*proto.ResFriendLog
|
||
for _, v := range FriendMod.Log {
|
||
ps := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
|
||
log = append(log, &proto.ResFriendLog{
|
||
Player: ps,
|
||
Type: int32(v.Type),
|
||
Time: int32(v.Time),
|
||
Param: v.Param,
|
||
Id: int32(v.Id),
|
||
Upvote: v.Upvote,
|
||
})
|
||
}
|
||
p.PushClientRes(&proto.ResFriendTimeLine{
|
||
Log: log,
|
||
})
|
||
}
|
||
|
||
func FriendCardBackData(p *Player) {
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
var msgList []*proto.ResFriendCard
|
||
for _, v := range FriendMod.Card {
|
||
m := GetCardInfoMsg(v)
|
||
msgList = append(msgList, m)
|
||
}
|
||
p.PushClientRes(&proto.ResFriendCardMsg{
|
||
MsgList: msgList,
|
||
})
|
||
}
|
||
|
||
// 发送消息给玩家
|
||
func ClusterSendMsg(ServerId int, m *msg.Msg) {
|
||
mergeCluster.SendServerMsg(m, ServerId)
|
||
}
|
||
|
||
// 创建订单
|
||
func CreateOrderSn(p *Player, req *proto.ReqCreateOrderSn) (string, error) {
|
||
Uid := int(p.M_DwUin)
|
||
OrderSn := GoUtil.CreateOrderSn(Uid)
|
||
|
||
Price, Currency := chargeCfg.GetChargeInfo(int(req.ChargeId))
|
||
Extra := &ChargeExtra{
|
||
Type: int(req.Type),
|
||
Uid: req.Uid,
|
||
}
|
||
ExtraData, _ := json.Marshal(Extra)
|
||
err := db.CreateOrderSn(Uid, int(req.ChargeId), OrderSn, req.PlatForm, req.Channel, Price, Currency, string(ExtraData))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return OrderSn, nil
|
||
}
|
||
|
||
func GoogleVerify(p *Player, OrderSn, ProduceId, Token string) (*db.SqlChargeOrderStruct, error) {
|
||
Order, err := db.GetPlayerChargeData(OrderSn)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if Order.PayStatus == MergeConst.ORDER_STATUS_SHIP {
|
||
return nil, fmt.Errorf("订单已经发货")
|
||
}
|
||
if !conf.Server.GoogleVerify {
|
||
Order.PayStatus = MergeConst.ORDER_STATUS_PAY
|
||
return Order, nil
|
||
}
|
||
if Order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
|
||
return nil, fmt.Errorf("订单已经支付")
|
||
}
|
||
cmd := exec.Command(conf.Server.AppPath+"/script/verifyOrder", ProduceId, Token)
|
||
|
||
// 获取命令的输出
|
||
output, err := cmd.Output()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
// 将输出转换为字符串
|
||
outputStr := string(output)
|
||
|
||
// 替换单引号为双引号
|
||
outputStr = strings.Replace(outputStr, "'", "\"", -1)
|
||
type VerifyData struct {
|
||
PurchaseState int `json:"purchaseState"`
|
||
DeveloperPayload string `json:"developerPayload"`
|
||
OrderId string `json:"orderId"`
|
||
ConsumptionState int `json:"consumptionState"`
|
||
}
|
||
r := &VerifyData{}
|
||
err = json.Unmarshal([]byte(outputStr), &r)
|
||
if err != nil {
|
||
log.Debug("output %s", string(output))
|
||
return nil, err
|
||
}
|
||
_, err = db.GetPlayerPayChannelOrderId(r.OrderId)
|
||
if err == nil {
|
||
return nil, fmt.Errorf("订单已支付发货 param: %v", r)
|
||
}
|
||
// if r.DeveloperPayload != OrderSn {
|
||
// return nil, fmt.Errorf("订单号不匹配")
|
||
// }
|
||
if r.ConsumptionState != 1 {
|
||
return nil, fmt.Errorf("订单未消费")
|
||
}
|
||
Order.PayStatus = MergeConst.ORDER_STATUS_PAY
|
||
Order.PayChannelOrderId = r.OrderId
|
||
Order.PayTime = GoUtil.Now()
|
||
return Order, nil
|
||
}
|
||
|
||
func CancelOrder(p *Player, OrderSn string) error {
|
||
Order, err := db.GetPlayerChargeData(OrderSn)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if Order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
|
||
return fmt.Errorf("订单已支付")
|
||
}
|
||
Order.PayStatus = MergeConst.ORDER_STATUS_CANCEL
|
||
err = db.UpdatePlayerChargeData(Order)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func GetCardInfoMsg(CardInfo *card.CardInfo) *proto.ResFriendCard {
|
||
Uid := 0
|
||
if CardInfo.Type == card.TYPE_CARD_SEND {
|
||
Uid = CardInfo.BUid
|
||
}
|
||
|
||
if CardInfo.Type == card.TYPE_CARD_GIVE {
|
||
if CardInfo.Status == card.STATUS_CARD_GIVE_1 {
|
||
Uid = CardInfo.AUid
|
||
} else {
|
||
Uid = CardInfo.BUid
|
||
}
|
||
}
|
||
|
||
if CardInfo.Type == card.TYPE_CARD_EX {
|
||
if CardInfo.Status == card.STATUS_CARD_EX_2 {
|
||
Uid = CardInfo.AUid
|
||
} else {
|
||
Uid = CardInfo.BUid
|
||
}
|
||
}
|
||
|
||
ps := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
|
||
return &proto.ResFriendCard{
|
||
Uid: int64(Uid),
|
||
Name: ps.Name,
|
||
Face: int32(ps.Face),
|
||
Avatar: int32(ps.Avatar),
|
||
Level: int32(ps.Level),
|
||
CardId: int32(CardInfo.CardId),
|
||
ExCardId: int32(CardInfo.ExId),
|
||
Time: int32(CardInfo.StartTime),
|
||
Type: int32(CardInfo.Type),
|
||
Status: int32(CardInfo.Status),
|
||
Id: CardInfo.Id,
|
||
Emoji: int32(CardInfo.Emoji),
|
||
}
|
||
}
|
||
|
||
func BackChampship(p *Player) {
|
||
ChampshipMod := p.PlayMod.getChampshipMod()
|
||
MyRank := G_GameLogicPtr.ChampshipMgr.getMyRank(int(p.M_DwUin))
|
||
MyPreRank := G_GameLogicPtr.ChampshipMgr.getLastMyRank(int(p.M_DwUin))
|
||
p.PushClientRes(ChampshipMod.BackData(MyRank, MyPreRank))
|
||
}
|
||
|
||
func GetVisitorPlayer(p *Player) int {
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
VisitorList := PlayroomMod.GetVisitor() // 到访用户
|
||
TodayVisitedUsers := PlayroomMod.GetTodayVisitedUsers() // 今日已互动用户
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
type sortData struct {
|
||
Uid int
|
||
Time int64
|
||
}
|
||
PlayerList := make([]sortData, 0)
|
||
PlayerList2 := make([]sortData, 0)
|
||
Now := GoUtil.Now()
|
||
/**
|
||
排除当日玩家已对其发起过交互的用户
|
||
优先选择24小时内曾经与玩家进行过宠物交互的好友
|
||
若存在复数对象的情况下，优先选择交互发生时间与当前时间最近的好友
|
||
若不存在符合条件的用户，则选择24小时内曾经与玩家进行过宠物交互的陌生用户
|
||
若存在复数对象的情况下，优先选择交互发生时间与当前时间最近的用户
|
||
若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
|
||
若不存在符合条件的用户，则依据以上用户推荐算法，选择一位随机推荐用户，并且在下次触发式订单完成时，不再排除已发起过交互的用户
|
||
*/
|
||
for k, v := range VisitorList {
|
||
if GoUtil.InArray(k, TodayVisitedUsers) {
|
||
continue
|
||
}
|
||
if v.Time < Now-86400 {
|
||
continue
|
||
}
|
||
if FriendMod.CheckFriend(k) {
|
||
PlayerList = append(PlayerList, sortData{k, v.Time})
|
||
} else {
|
||
PlayerList2 = append(PlayerList, sortData{k, v.Time})
|
||
}
|
||
}
|
||
if len(PlayerList) != 0 {
|
||
sort.Slice(PlayerList, func(i, j int) bool {
|
||
return PlayerList[i].Time < PlayerList[j].Time
|
||
})
|
||
return PlayerList[0].Uid
|
||
}
|
||
if len(PlayerList2) != 0 {
|
||
sort.Slice(PlayerList2, func(i, j int) bool {
|
||
return PlayerList2[i].Time < PlayerList2[j].Time
|
||
})
|
||
return PlayerList2[0].Uid
|
||
}
|
||
// 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
|
||
var recentFriendUid int
|
||
var recentLoginTime int64 = 0
|
||
for uid := range FriendMod.GetFriendList() {
|
||
if uid == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
if GoUtil.InArray(uid, TodayVisitedUsers) {
|
||
continue
|
||
}
|
||
ps := G_GameLogicPtr.GetSimplePlayerByUid(uid)
|
||
if ps == nil {
|
||
continue
|
||
}
|
||
if GoUtil.Now()-ps.Loginout > 86400 { // 24小时内登录过
|
||
continue
|
||
}
|
||
if ps.Loginout > recentLoginTime {
|
||
recentLoginTime = ps.Loginout
|
||
recentFriendUid = uid
|
||
}
|
||
}
|
||
if recentFriendUid != 0 {
|
||
return recentFriendUid
|
||
}
|
||
PlayerList3 := G_GameLogicPtr.RankMgr.getAllRank(RANK_TYPE_USER)
|
||
PlayerList4 := make([]int, 0)
|
||
for _, v := range PlayerList3 {
|
||
if v.Uid == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
|
||
if PlayerSimpleData.Level < 15 {
|
||
continue
|
||
}
|
||
PlayerList4 = append(PlayerList4, v.Uid)
|
||
}
|
||
L := GoUtil.RandSliceNum(PlayerList4, 1)
|
||
if len(L) == 0 {
|
||
return 0
|
||
}
|
||
return L[0]
|
||
}
|
||
|
||
func GetRecommendPlayer(p *Player, Num int) []int {
|
||
PlayerList := G_GameLogicPtr.RankMgr.getAllRank(RANK_TYPE_USER)
|
||
PlayerList1 := make([]int, 0)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
for _, v := range PlayerList {
|
||
if v.Uid == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
if FriendMod.CheckSendApply(v.Uid) {
|
||
continue
|
||
}
|
||
if FriendMod.CheckFriend(v.Uid) {
|
||
continue
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
|
||
if PlayerSimpleData == nil {
|
||
continue
|
||
}
|
||
if GoUtil.Now()-PlayerSimpleData.Loginout > 86400 {
|
||
continue
|
||
}
|
||
if PlayerSimpleData.Level < 4 {
|
||
continue
|
||
}
|
||
PlayerList1 = append(PlayerList1, v.Uid)
|
||
}
|
||
if len(PlayerList1) == 0 {
|
||
for _, v := range PlayerList {
|
||
if v.Uid == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
PlayerList1 = append(PlayerList1, v.Uid)
|
||
}
|
||
}
|
||
return GoUtil.RandSliceNum(PlayerList1, Num)
|
||
}
|
||
|
||
// 发射器退役第一步 不再生成此发射器订单
|
||
func EmitRetireTrigger1(p *Player) {
|
||
ChessMod := p.PlayMod.getChessMod()
|
||
EmitList := ChessMod.GetEmitList()
|
||
EmitId := make(map[string]struct{}, 0)
|
||
for _, v := range EmitList {
|
||
Emit_Id := mergeDataCfg.GetEmitId(v)
|
||
if Emit_Id == "" {
|
||
continue
|
||
}
|
||
EmitId[Emit_Id] = struct{}{}
|
||
}
|
||
EmitId1 := make([]string, 0)
|
||
for k := range EmitId {
|
||
EmitId1 = append(EmitId1, k)
|
||
}
|
||
if len(EmitId1) <= 5 {
|
||
return
|
||
}
|
||
sort.Slice(EmitId1, func(i, j int) bool {
|
||
return EmitId1[i] < EmitId1[j]
|
||
})
|
||
OrderMod := p.PlayMod.getOrderMod()
|
||
OrderMod.Retire(EmitId1[0])
|
||
p.TeLog("launcher_retire", map[string]interface{}{
|
||
"launcher_type": EmitId1[0],
|
||
})
|
||
ChessMod.BeginRetire(EmitId1[0])
|
||
}
|
||
|
||
// 发射器退役第二步 生成清理订单
|
||
func EmitRetireTrigger2(p *Player) {
|
||
ChessMod := p.PlayMod.getChessMod()
|
||
OrderMod := p.PlayMod.getOrderMod()
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
OrderList := OrderMod.GetOrderList()
|
||
AllChess := make(map[string]struct{}, 0)
|
||
for _, v := range OrderList {
|
||
for _, v1 := range v.MergeId {
|
||
Color := mergeDataCfg.GetColorById(v1)
|
||
AllChess[Color] = struct{}{}
|
||
}
|
||
}
|
||
RetireEmit := ChessMod.GetRetireEmit()
|
||
for k, v := range RetireEmit {
|
||
if k == "" {
|
||
continue
|
||
}
|
||
if v != 1 {
|
||
continue
|
||
}
|
||
RetireLv := mergeDataCfg.GetEmitRetire(k)
|
||
if RetireLv > BaseMod.GetLevel() {
|
||
continue
|
||
}
|
||
|
||
NeedFinishOrder := false
|
||
Produce := mergeDataCfg.GetEmitOrderProduce(k)
|
||
for _, v1 := range Produce {
|
||
if _, ok := AllChess[v1]; ok {
|
||
NeedFinishOrder = true
|
||
break
|
||
}
|
||
}
|
||
if NeedFinishOrder {
|
||
continue
|
||
}
|
||
ChessMod.RetireOrder(k)
|
||
}
|
||
for _, v := range OrderList {
|
||
if v.Type == order.Clean_type {
|
||
return
|
||
}
|
||
}
|
||
RetireEmit1 := ChessMod.GetRetireEmit()
|
||
for k, v := range RetireEmit1 {
|
||
if k == "" {
|
||
continue
|
||
}
|
||
if v != 2 {
|
||
continue
|
||
}
|
||
ChessList := ChessMod.GetRetireChess(k)
|
||
// 清理完成
|
||
if len(ChessList) == 0 {
|
||
ChessMod.FinishRetire(k)
|
||
ChargeMod := p.PlayMod.getChargeMod()
|
||
ChargeMod.InitChessShop(ChessMod.GetEmitList())
|
||
p.PushClientRes(ChargeMod.BackData())
|
||
continue
|
||
}
|
||
OrderMod.CreateCleanOrder(ChessList)
|
||
return
|
||
}
|
||
}
|
||
|
||
func LoignBack(p *Player) {
|
||
|
||
}
|
||
|
||
func Benchmark(player *Player) {
|
||
ChampshipMod := player.PlayMod.getChampshipMod()
|
||
ChampshipMod.AddScore([]int{949, 941, 10})
|
||
player.HandleInChampshipRank()
|
||
player.HandleInUserRank()
|
||
}
|
||
|
||
func GetUidByFaceBook(Fb string) (int, error) {
|
||
sqlStr := "SELECT dwUin FROM t_player_baseinfo WHERE FaceBookId = ?"
|
||
type Result struct {
|
||
Uid int `db:"dwUin"`
|
||
}
|
||
R := Result{}
|
||
err := db.SqlDb.Get(&R, sqlStr, Fb)
|
||
log.Debug("Fb :%s;Uid :%d", Fb, R.Uid)
|
||
return R.Uid, err
|
||
}
|
||
|
||
func NotifyAllFriend(p *Player, m1 *msg.Msg) {
|
||
m := m1.Clone()
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
for k := range FriendMod.GetFriendList() {
|
||
if k == int(p.M_DwUin) {
|
||
continue
|
||
}
|
||
m.To = k
|
||
FriendMgrSend(m)
|
||
}
|
||
}
|
||
|
||
func NotifyChampshipResult(Uid, Rank int) {
|
||
PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
|
||
if PlayerSimpleData == nil {
|
||
return
|
||
}
|
||
for _, v := range PlayerSimpleData.Friend {
|
||
Msg := &msg.Msg{
|
||
Type: msg.HANDLE_TYPE_CHAMPSHIP_RESULT,
|
||
From: Uid,
|
||
To: v,
|
||
SendT: GoUtil.Now(),
|
||
Extra: []int{Rank, GoUtil.GetServerOpenDay()},
|
||
}
|
||
FriendMgrSend(Msg)
|
||
}
|
||
}
|
||
|
||
func (player *Player) GetPetOrderItemExp() int {
|
||
OrderItemCfgList := playroomCfg.GetOrderItemList()
|
||
itemList := make([]*item.Item, 0)
|
||
ItemMod := player.PlayMod.getItemMod()
|
||
for _, v := range OrderItemCfgList {
|
||
Num := ItemMod.GetItem(v)
|
||
if Num <= 0 {
|
||
continue
|
||
}
|
||
itemList = append(itemList, &item.Item{
|
||
Id: v,
|
||
Num: Num,
|
||
})
|
||
}
|
||
return playroomCfg.GetPetOrderItemExpByList(itemList)
|
||
}
|
||
|
||
// 触发生成新的固定订单
|
||
func (player *Player) TriggerOrder(lv int, Type string, Emit []int, EnergyMul int) error {
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
TriggerOrderList := orderCfg.GetStartOrderList()
|
||
FixedOrder := 0
|
||
for _, v := range OrderMod.OrderList {
|
||
if v.Type == order.Fixed_type {
|
||
FixedOrder++
|
||
}
|
||
}
|
||
OrderList := make(map[int]order.Order, len(OrderMod.OrderList))
|
||
for k, v := range OrderMod.OrderList {
|
||
OrderList[k] = v
|
||
}
|
||
// 触发生成新的固定订单
|
||
for _, v := range TriggerOrderList {
|
||
if GoUtil.InArray(v.Id, OrderMod.FinishOrder) {
|
||
continue
|
||
}
|
||
orderInfo, exists := OrderList[v.Id]
|
||
if exists && v.Preview == "" {
|
||
continue
|
||
}
|
||
// 预览条件不为空且未存在且未完成
|
||
if v.Preview != "" && !exists && !GoUtil.InArray(v.Id, OrderMod.FinishOrder) {
|
||
if OrderMod.CheckCondition(lv, v.Preview, Type, Emit, FixedOrder, OrderList) {
|
||
OrderMod.AddFixOrder(v.Id, v.MergeList, order.Preview_type, v.Items)
|
||
}
|
||
}
|
||
|
||
if v.Appear != "" {
|
||
if OrderMod.CheckCondition(lv, v.Appear, Type, Emit, FixedOrder, OrderList) {
|
||
Type := order.Fixed_type
|
||
OrderType := orderCfg.GetOrderType(v.Id)
|
||
if OrderType != 0 {
|
||
Type = OrderType
|
||
}
|
||
player.TeLog("preset_order_birth", map[string]interface{}{
|
||
"order_id": v.Id,
|
||
"order_item_id": v.MergeList,
|
||
"preset_order_group": v.Group,
|
||
"preset_order_step": v.Step,
|
||
})
|
||
if exists {
|
||
orderInfo.Type = order.Fixed_type
|
||
OrderMod.OrderList[v.Id] = orderInfo
|
||
} else {
|
||
OrderMod.AddFixOrder(v.Id, v.MergeList, Type, v.Items)
|
||
if v.Id == 78 {
|
||
OrderMod.Retire("D")
|
||
OrderMod.AutoEmit = append(OrderMod.AutoEmit, "D")
|
||
}
|
||
if v.Id == 79 {
|
||
OrderMod.Retire("I")
|
||
OrderMod.AutoEmit = append(OrderMod.AutoEmit, "I")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
func (player *Player) AddOrder() {
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
MaxOrderNum := orderCfg.GetOrderNum(BaseMod.GetLevel())
|
||
n := 0
|
||
if OrderMod.LastOrder.Type == order.Preheat_type {
|
||
ChessId := OrderMod.LastOrder.MergeId[0]
|
||
ChessColor := mergeDataCfg.GetColorById(ChessId)
|
||
PreheatStep := OrderMod.PreheatStep[ChessColor]
|
||
OrderMod.PreheatStep[ChessColor]++
|
||
if PreheatStep < 4 {
|
||
NewChessId := mergeDataCfg.GetChessIdByLvAndColor(BaseMod.GetEnergyMul()+PreheatStep+1, ChessColor)
|
||
Items, ok := order.PreheatItems[OrderMod.PreheatStep[ChessColor]]
|
||
if !ok {
|
||
Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetOrderEmit()))}
|
||
}
|
||
OrderMod.AddPreheatOrder([]int{NewChessId}, order.DIFF_LOW, order.Preheat_type, Items)
|
||
}
|
||
}
|
||
for _, v := range OrderMod.OrderList {
|
||
if v.Type == order.Common_type || v.Type == order.Pet_type || v.Type == order.Part_type || v.Type == order.Fixed_type || v.Type == order.Preview_type {
|
||
n++
|
||
}
|
||
}
|
||
for i := n; i < MaxOrderNum; i++ {
|
||
player.CreateNormalOrder()
|
||
}
|
||
}
|
||
|
||
func (player *Player) FixOrderBug() {
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
for k, v := range OrderMod.PreheatStep {
|
||
if v > 4 {
|
||
continue
|
||
}
|
||
Exit := false
|
||
for _, o := range OrderMod.OrderList {
|
||
if o.Type != order.Preheat_type {
|
||
continue
|
||
}
|
||
Color := mergeDataCfg.GetColorById(o.MergeId[0])
|
||
if Color == k {
|
||
Exit = true
|
||
break
|
||
}
|
||
|
||
}
|
||
if Exit {
|
||
continue
|
||
}
|
||
NewChessId := mergeDataCfg.GetChessIdByLvAndColor(BaseMod.GetEnergyMul()+v+1, k)
|
||
OrderMod.PreheatStep[k]++
|
||
Items, ok := order.PreheatItems[OrderMod.PreheatStep[k]]
|
||
if !ok {
|
||
Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetOrderEmit()))}
|
||
}
|
||
OrderMod.AddPreheatOrder([]int{NewChessId}, order.DIFF_LOW, order.Preheat_type, Items)
|
||
}
|
||
}
|
||
|
||
func (player *Player) CreateNormalOrder() {
|
||
Exp, PExp := userCfg.GetLevUpExp(player.GetPlayerBaseMod().GetLevel())
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
DecorateMod := player.PlayMod.getDecorateMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
OrderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
|
||
ExpCoin := (Exp-BaseMod.GetExp())*decorateCfg.GetAreaPerPExp(DecorateMod.GetAreaId()) - BaseMod.GetStar()
|
||
PExpCoin := (PExp-BaseMod.GetPExp())*50 - player.GetPetOrderItemExp()
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
|
||
// 预热订单
|
||
|
||
// 安慰订单
|
||
Now := GoUtil.Now()
|
||
if OrderMod.LastOrder.Type == order.COMFORT_TYPE && Now < int64(OrderMod.ComfortEndTime) {
|
||
OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.COMFORT_TYPE)
|
||
for k, v := range OrderMod.GetOrderList() {
|
||
if k == OrderMod.Auto_id {
|
||
if v.Type != order.COMFORT_TYPE {
|
||
continue
|
||
}
|
||
Items := make([]*item.Item, 0)
|
||
Star := order.GetOrderStar(v.MergeId, ChessMod.GetOrderEmit())
|
||
Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
|
||
v.Items = append(Items, &item.Item{Id: item.ITEM_STAR_ID, Num: Star})
|
||
OrderMod.OrderList[k] = v
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
PetTrigger := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if v.Type == order.Pet_type {
|
||
PetTrigger = false
|
||
break
|
||
}
|
||
}
|
||
if PExpCoin > ExpCoin && PetTrigger && BaseMod.GetLevel() >= 17 {
|
||
OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Pet_type)
|
||
for k, v := range OrderMod.GetOrderList() {
|
||
if len(v.Items) != 0 {
|
||
continue
|
||
}
|
||
if v.Type != order.Pet_type {
|
||
continue
|
||
}
|
||
Items := make([]*item.Item, 0)
|
||
Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
|
||
// Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
|
||
Items = player.GetPetOrderReward(Star, Items)
|
||
if len(Items) == 1 && Items[0].Id == item.ITEM_STAR_ID {
|
||
v.Type = order.Common_type
|
||
} else {
|
||
v.Type = order.Pet_type
|
||
}
|
||
v.Items = Items
|
||
OrderMod.OrderList[k] = v
|
||
}
|
||
return
|
||
}
|
||
// if ExpCoin > PExpCoin || BaseMod.GetLevel() < 17 {
|
||
// for k, v := range OrderMod.GetOrderList() {
|
||
// if len(v.Items) != 0 {
|
||
// continue
|
||
// }
|
||
// if v.Type != order.Common_type {
|
||
// continue
|
||
// }
|
||
// Star := order.GetOrderStar(v.MergeId)
|
||
// Star = int(float64(Star)*float64(OrderFactor)/10) * 10
|
||
// v.Items = append(v.Items, &item.Item{
|
||
// Id: item.ITEM_STAR_ID,
|
||
// Num: Star,
|
||
// })
|
||
// OrderMod.OrderList[k] = v
|
||
// }
|
||
// } else {
|
||
// for k, v := range OrderMod.GetOrderList() {
|
||
// if len(v.Items) != 0 {
|
||
// continue
|
||
// }
|
||
// if v.Type != order.Common_type {
|
||
// continue
|
||
// }
|
||
// Items := make([]*item.Item, 0)
|
||
// Star := order.GetOrderStar(v.MergeId)
|
||
// Star = int(float64(Star)*float64(OrderFactor)/10) * 10
|
||
// Items = player.GetPetOrderReward(Star, Items)
|
||
// if len(Items) == 1 && Items[0].Id == item.ITEM_STAR_ID {
|
||
// v.Type = order.Common_type
|
||
// } else {
|
||
// v.Type = order.Pet_type
|
||
// }
|
||
// v.Items = Items
|
||
// OrderMod.OrderList[k] = v
|
||
// }
|
||
// }
|
||
|
||
// 触发式订单 满足条件生成零件订单
|
||
PartCost := DecorateMod.GetPartCost()
|
||
PartBag := ChessMod.GetPartBag()
|
||
Trigger := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if v.Type == order.Part_type {
|
||
Trigger = false
|
||
}
|
||
}
|
||
Trigger2 := false
|
||
for k, v := range PartCost {
|
||
if v > PartBag[k] {
|
||
Trigger2 = true
|
||
}
|
||
}
|
||
if Trigger && Trigger2 && BaseMod.GetLevel() >= 12 {
|
||
OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Part_type)
|
||
for k, v := range OrderMod.GetOrderList() {
|
||
if v.Type == order.Part_type {
|
||
v.Items = []*item.Item{item.NewItem(item.ITEM_LAUNCHER_ID, 2)}
|
||
OrderMod.OrderList[k] = v
|
||
}
|
||
}
|
||
return
|
||
}
|
||
OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Common_type)
|
||
|
||
}
|
||
func (player *Player) InitOrderItem() {
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
DecorateMod := player.PlayMod.getDecorateMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
OrderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
|
||
for k, v := range OrderMod.GetOrderList() {
|
||
if v.Type == order.Super_type {
|
||
continue
|
||
}
|
||
if len(v.Items) != 0 {
|
||
continue
|
||
}
|
||
Items := make([]*item.Item, 0)
|
||
Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
|
||
Star = int(float64(Star)*float64(OrderFactor)/1000+0.5) * 10
|
||
v.Items = append(Items, &item.Item{Id: item.ITEM_STAR_ID, Num: Star})
|
||
OrderMod.OrderList[k] = v
|
||
}
|
||
}
|
||
func (player *Player) GetPetOrderReward(Star int, Items []*item.Item) []*item.Item {
|
||
HighNum := Star / 225
|
||
if HighNum > 0 {
|
||
HighNum = min(HighNum, 3)
|
||
Items = append(Items, item.NewItem(item.ITEM_PLAYROOM_BOX_HIGH_ID, HighNum))
|
||
Star -= HighNum * 225
|
||
}
|
||
|
||
MidNum := Star / 150
|
||
if MidNum > 0 {
|
||
MidNum = min(MidNum, 3)
|
||
Items = append(Items, item.NewItem(item.ITEM_PLAYROOM_BOX_MID_ID, MidNum))
|
||
Star -= MidNum * 150
|
||
}
|
||
if len(Items) >= 2 {
|
||
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, Star))
|
||
return Items
|
||
}
|
||
LowNum := Star / 75
|
||
if LowNum > 0 {
|
||
LowNum = min(LowNum, 3)
|
||
Items = append(Items, item.NewItem(item.ITEM_PLAYROOM_BOX_LOW_ID, LowNum))
|
||
Star -= LowNum * 75
|
||
}
|
||
if Star > 0 {
|
||
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, Star))
|
||
}
|
||
return Items
|
||
}
|
||
|
||
func ExcludeCardStar(CardList []int) []int {
|
||
StarList := make([]int, 0)
|
||
for _, v := range CardList {
|
||
Star := cardCfg.GetStarById(v)
|
||
if Star < 2 || Star > 4 {
|
||
continue
|
||
}
|
||
StarList = append(StarList, v)
|
||
}
|
||
return StarList
|
||
}
|
||
|
||
func (p *Player) GetPlayroomGameReward(Type, SelectId int) []*item.Item {
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
Level := BaseMod.GetLevel()
|
||
Items := make([]*item.Item, 0)
|
||
switch Type {
|
||
case playroom.GAME_RESULT_LOSE:
|
||
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 20))
|
||
case playroom.GAME_RESULT_LOW:
|
||
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, Level*2))
|
||
case playroom.GAME_RESULT_MIDDLE:
|
||
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, Level*3))
|
||
default:
|
||
Items = PlayroomMod.SelectReward(SelectId)
|
||
}
|
||
return Items
|
||
}
|
||
|
||
func (p *Player) GetPetThiefReward(Target int) error {
|
||
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Target)
|
||
if PlayerData == nil {
|
||
return fmt.Errorf("target %d not exist", Target)
|
||
}
|
||
CardStar := limitedTimeEventCfg.GetThiefProb()
|
||
starMap := make(map[int][]int, 0)
|
||
cardList := []int{}
|
||
for _, v := range PlayerData.CardInfo {
|
||
Star := cardCfg.GetStarById(v)
|
||
starMap[Star] = append(starMap[Star], v)
|
||
}
|
||
for {
|
||
if l, ok := starMap[CardStar]; ok {
|
||
cardList = l
|
||
break
|
||
}
|
||
if CardStar <= 1 {
|
||
break
|
||
}
|
||
CardStar--
|
||
}
|
||
ItemId := 0
|
||
if len(cardList) == 0 {
|
||
List := cardCfg.GetCardListByStar(0, 1, 0)
|
||
CardId := GoUtil.RandSlice(List)
|
||
ItemId = cardCfg.GetItemIdByCardId(CardId)
|
||
if ItemId == 0 {
|
||
log.Error("LimitEventPetTheif ItemId %d not exist", ItemId)
|
||
return fmt.Errorf("ItemId %d not exist", ItemId)
|
||
}
|
||
} else {
|
||
CardId := GoUtil.RandSlice(cardList)
|
||
ItemId = cardCfg.GetItemIdByCardId(CardId)
|
||
}
|
||
p.HandleItem([]*item.Item{{Id: ItemId, Num: 1}}, proto.ITEM_POP_LABEL_PetTheif.String())
|
||
return nil
|
||
}
|
||
|
||
// 高级产物订单
|
||
func (p *Player) AddHighOrder() {
|
||
OrderMod := p.PlayMod.getOrderMod()
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
ChessMod := p.PlayMod.getChessMod()
|
||
LastChess := OrderMod.LastOrder.MergeId[len(OrderMod.LastOrder.MergeId)-1]
|
||
maxId := 0
|
||
for k := range OrderMod.GetOrderList() {
|
||
maxId = max(maxId, k)
|
||
}
|
||
if maxId == 0 || BaseMod.GetLevel() < 12 {
|
||
return
|
||
}
|
||
NewChess := OrderMod.GetOrderList()[maxId].MergeId[0]
|
||
LastColor := mergeDataCfg.GetColorById(LastChess)
|
||
NewColor := mergeDataCfg.GetColorById(NewChess)
|
||
LastEmitId := order.GetEmitByColor(ChessMod.GetOrderEmit(), LastColor)
|
||
AddNewEmitId := order.GetEmitByColor(ChessMod.GetOrderEmit(), NewColor)
|
||
Product := []string{}
|
||
Product = append(Product, mergeDataCfg.GetEmitProduceType(LastEmitId)...)
|
||
Product = append(Product, mergeDataCfg.GetEmitProduceType(AddNewEmitId)...)
|
||
ChessMap := make(map[string]int, 0)
|
||
ChessList := ChessMod.GetUnlockChessList()
|
||
for _, v := range ChessList {
|
||
ChessType := mergeDataCfg.GetTypeById(v)
|
||
if ChessType != "Product" {
|
||
continue
|
||
}
|
||
Color := mergeDataCfg.GetColorById(v)
|
||
if GoUtil.InStringArray(Color, Product) {
|
||
continue
|
||
}
|
||
if v > ChessMap[Color] {
|
||
ChessMap[Color] = v
|
||
}
|
||
}
|
||
|
||
for Color, ChessId := range ChessMap {
|
||
EmitId := order.GetEmitByColor(ChessMod.GetOrderEmit(), Color)
|
||
_, ChessMaxLv := getChesslvRange(EmitId, BaseMod.GetEnergyMul(), OrderMod.IsCharge)
|
||
NewLev2 := mergeDataCfg.DynamicLev(ChessMaxLv, EmitId, Color)
|
||
NewLev3 := order.AdjustLev(NewLev2, BaseMod.GetEnergyMul())
|
||
ChessLv := mergeDataCfg.GetLvById(ChessId)
|
||
if NewLev3 >= ChessLv {
|
||
continue
|
||
}
|
||
Add := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if GoUtil.InArray(ChessId, v.MergeId) {
|
||
Add = false
|
||
}
|
||
}
|
||
if Add {
|
||
OrderMod.AddExtraOrder([]int{ChessId})
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
// 高级产物订单
|
||
func (p *Player) AddHighOrder2() {
|
||
OrderMod := p.PlayMod.getOrderMod()
|
||
ChessMod := p.PlayMod.getChessMod()
|
||
ChessList := ChessMod.GetUnlockChessList()
|
||
ChessMap := make(map[int]int, 0)
|
||
for _, v := range ChessList {
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
MaxLv := mergeDataCfg.GetMaxLvById(v)
|
||
if Lv != MaxLv {
|
||
continue
|
||
}
|
||
Type := mergeDataCfg.GetTypeById(v)
|
||
if Type != "Product" {
|
||
continue
|
||
}
|
||
ChessMap[v]++
|
||
}
|
||
for ChessId, Num := range ChessMap {
|
||
if Num < 3 {
|
||
continue
|
||
}
|
||
add := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if GoUtil.SliceEqual(v.MergeId, []int{ChessId, ChessId, ChessId}) {
|
||
add = false
|
||
break
|
||
}
|
||
}
|
||
if add {
|
||
OrderMod.AddExtraOrder([]int{ChessId, ChessId, ChessId})
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
func (p *Player) FormatPetOrderItem(Items []*item.Item) []*item.Item {
|
||
NewItems := make([]*item.Item, 0)
|
||
PlayroomMod := p.PlayMod.getPlayroomMod()
|
||
for _, v := range Items {
|
||
if v.Id != item.ITEM_PLAYROOM_BOX_LOW_ID && v.Id != item.ITEM_PLAYROOM_BOX_MID_ID && v.Id != item.ITEM_PLAYROOM_BOX_HIGH_ID {
|
||
NewItems = append(NewItems, v)
|
||
continue
|
||
}
|
||
var OrderItem map[int][]int
|
||
switch v.Id {
|
||
case item.ITEM_PLAYROOM_BOX_LOW_ID:
|
||
OrderItem = playroomCfg.GetOrderItemByGrade(1)
|
||
case item.ITEM_PLAYROOM_BOX_MID_ID:
|
||
OrderItem = playroomCfg.GetOrderItemByGrade(2)
|
||
default:
|
||
OrderItem = playroomCfg.GetOrderItemByGrade(3)
|
||
}
|
||
feed := PlayroomMod.GetPhysiology(playroom.PHYSIOLOGY_TYPE_FEED)
|
||
feedItem := p.GetPlayroomFood()
|
||
feedPlo := playroomCfg.GetItemAddPhysiology(feedItem)
|
||
if feed.Num+feedPlo <= 1 {
|
||
RandList := OrderItem[1]
|
||
NewItems = append(NewItems, item.NewItem(GoUtil.RandSlice(RandList), 1))
|
||
continue
|
||
}
|
||
clean := PlayroomMod.GetPhysiology(playroom.PHYSIOLOGY_TYPE_CLEAN)
|
||
cleanItem := p.GetPlayroomClean()
|
||
cleanPlo := playroomCfg.GetItemAddPhysiology(cleanItem)
|
||
// 卫生值低于等于5点，优先产出清洁类物品
|
||
if clean.Num+cleanPlo <= 5 {
|
||
RandList := OrderItem[2]
|
||
NewItems = append(NewItems, item.NewItem(GoUtil.RandSlice(RandList), 1))
|
||
continue
|
||
}
|
||
RandList := make([]int, 0)
|
||
for k, v1 := range OrderItem {
|
||
if k == 1 || k == 2 {
|
||
continue
|
||
}
|
||
RandList = append(RandList, v1...)
|
||
}
|
||
NewItems = append(NewItems, item.NewItem(GoUtil.RandSlice(RandList), 1))
|
||
}
|
||
return NewItems
|
||
}
|
||
|
||
func (player *Player) GetPlayroomFood() map[int]int {
|
||
ItemMod := player.PlayMod.getItemMod()
|
||
Item := make(map[int]int)
|
||
for k, v := range ItemMod.Data {
|
||
ItemType := itemCfg.GetItemType(k)
|
||
if ItemType == item.ITEM_TYPE_PLAYROOM_PET {
|
||
Effect := itemCfg.GetItemEffect(k)
|
||
if Effect == 1 {
|
||
Item[k] = v
|
||
}
|
||
}
|
||
}
|
||
return Item
|
||
}
|
||
|
||
func (player *Player) GetPlayroomClean() map[int]int {
|
||
ItemMod := player.PlayMod.getItemMod()
|
||
Item := make(map[int]int)
|
||
for k, v := range ItemMod.Data {
|
||
ItemType := itemCfg.GetItemType(k)
|
||
if ItemType == item.ITEM_TYPE_PLAYROOM_PET {
|
||
Effect := itemCfg.GetItemEffect(k)
|
||
if Effect == 2 {
|
||
Item[k] = v
|
||
}
|
||
}
|
||
}
|
||
return Item
|
||
}
|