1380 lines
41 KiB
Go
1380 lines
41 KiB
Go
package game
|
||
|
||
import (
|
||
"fmt"
|
||
mergeCluster "server/cluster"
|
||
cardCfg "server/conf/card"
|
||
catnipCfg "server/conf/catnip"
|
||
decorateCfg "server/conf/decorate"
|
||
itemCfg "server/conf/item"
|
||
limitedTimeEventCfg "server/conf/limited_time_event"
|
||
mailCfg "server/conf/mail"
|
||
mergeDataCfg "server/conf/merge_data"
|
||
orderCfg "server/conf/order"
|
||
playroomCfg "server/conf/playroom"
|
||
userCfg "server/conf/user"
|
||
"server/game/mod/activity"
|
||
"server/game/mod/card"
|
||
"server/game/mod/decorate"
|
||
"server/game/mod/friend"
|
||
"server/game/mod/item"
|
||
limitedTimeEvent "server/game/mod/limited_time_event"
|
||
"server/game/mod/mail"
|
||
"server/game/mod/msg"
|
||
"server/game/mod/order"
|
||
"server/game/mod/playroom"
|
||
GoUtil "server/game_util"
|
||
proto "server/msg"
|
||
"server/pkg/github.com/name5566/leaf/log"
|
||
"sort"
|
||
)
|
||
|
||
// 处理玩家异步请求
|
||
func (p *Player) HandleMsg(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 := p.handle(m)
|
||
if err != nil {
|
||
log.Debug("uid : %d, err : %s", p.M_DwUin, err)
|
||
p.Recover(backup) //还原Player的数据
|
||
return
|
||
}
|
||
|
||
// 处理在线消息
|
||
if m.H == msg.MSG_TYPE_ONLINE {
|
||
p.ProcessTrigger()
|
||
p.SendClientRes()
|
||
} else {
|
||
p.Msg = make([]PlayerMsg, 0)
|
||
}
|
||
}
|
||
|
||
// 消息处理
|
||
func (p *Player) handle(m *msg.Msg) error {
|
||
switch m.Type {
|
||
case msg.HANDLE_TYPE_APPLY: // 好友申请
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
ok := FriendMod.AddFriendApply(m.From)
|
||
// 已申请
|
||
if ok {
|
||
return nil
|
||
}
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_APPLY, "", m.SendT)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_APPLY,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HADNLE_TYPE_AGREE: // 同意好友申请
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.AgreeApply(m.From)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(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())
|
||
// p.PlayroomBackData()
|
||
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 := p.PlayMod.getFriendMod()
|
||
FriendMod.DelFriend(m.From)
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_APPLY, "", m.SendT)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_DEL,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HANDLE_TYPE_REFUSE: // 拒绝好友申请
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
FriendMod.RefuseApply(m.From)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
p.PushClientRes(&proto.ResFriendApplyNotify{
|
||
Player: PlayerSimpleData,
|
||
Type: friend.FRIEND_NOTIFY_REFUSE,
|
||
Time: int32(GoUtil.Now()),
|
||
})
|
||
case msg.HANDLE_TYPE_REQ_CARD: // 卡牌申请
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
CardInfo, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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
|
||
}
|
||
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)
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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, ok := m.Extra.(card.CardInfo)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
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: // # 锦标赛排名变动通知
|
||
p.BackChampship()
|
||
case msg.HANDLE_TYPE_CHAMPSHIP_RESULT: // # 好友锦标赛结果
|
||
Extra := GoUtil.IntSlice(m.Extra)
|
||
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.TeLog("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, ok := m.Extra.([]*item.Item)
|
||
if !ok {
|
||
Items = []*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, ok := m.Extra.(*ChargeExtra)
|
||
if !ok {
|
||
C = &ChargeExtra{}
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
MailMod := p.PlayMod.getMailMod()
|
||
mt, mc, mt_en, mc_en := mailCfg.GetChargeSendMail(PlayerSimpleData.Name)
|
||
Items := p.ChargeItem(C.ChargeId)
|
||
mailId := MailMod.SendMail(&mail.MailStruct{
|
||
Title: mt,
|
||
Content: mc,
|
||
TitleEn: mt_en,
|
||
ContentEn: mc_en,
|
||
Items: Items,
|
||
Type: 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, ok := m.Extra.(string)
|
||
if !ok {
|
||
Content = ""
|
||
}
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
MailMod := p.PlayMod.getMailMod()
|
||
mt, mc, mt_en, mc_en := mailCfg.GetChargeReceiveMail(PlayerSimpleData.Name, Content)
|
||
mailId := MailMod.SendMail(&mail.MailStruct{
|
||
Title: mt,
|
||
Content: mc,
|
||
TitleEn: mt_en,
|
||
ContentEn: mc_en,
|
||
Type: 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.ChargeBackData()
|
||
case msg.HANDLE_TYPE_PLAYROOM_KISS: // playroom亲吻
|
||
p.NotifyPlayroomKiss()
|
||
case msg.HANDLE_TYPE_CATNIP_INVITE: // 邀请好友参与猫咪游戏
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg, ok := m.Extra.(CatnipMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
ActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.BeInvited(int(m.From), m.SendT)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
ReplyInfo := FriendMod.AddReplyInfo(m.From, friend.REPLY_TYPE_CATNIP, fmt.Sprintf("%d", CatnipMsg.GameId), m.End, nil)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
p.PushClientRes(&proto.ResFriendReplyNotify{
|
||
Info: &proto.ResFriendReply{
|
||
Player: PlayerSimpleData,
|
||
Param: ReplyInfo.Param,
|
||
Type: int32(ReplyInfo.Type),
|
||
Id: int32(ReplyInfo.Id),
|
||
},
|
||
Type: int32(friend.REPLY_TYPE_CATNIP),
|
||
Time: int32(m.SendT),
|
||
})
|
||
case msg.HANDLE_TYPE_CATNIP_AGREE: // 同意好友参与猫咪游戏
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg, ok := m.Extra.(CatnipMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
ActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.BeAgree(CatnipMsg.GameId, int(m.From))
|
||
case msg.HANDLE_TYPE_CATNIP_AGREE_DEL: // 同意好友参与猫咪游戏后删除邀请
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
CatnipMsg, ok := m.Extra.(CatnipMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
ActivityId := p.GetActivityId(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, ok := m.Extra.(CatnipMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
ActivityId := p.GetActivityId(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()
|
||
CatnipMsg, ok := m.Extra.(CatnipMsg)
|
||
if !ok {
|
||
return nil
|
||
}
|
||
ActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
|
||
if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
|
||
return nil
|
||
}
|
||
CatnipMod.GrowthByUid(m.From, CatnipMsg.Growth)
|
||
if CatnipMsg.FriendItems > 0 {
|
||
Items := catnipCfg.GetItemCost(ActivityId, CatnipMsg.FriendItems)
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
ReplyInfo := FriendMod.AddReplyInfo(m.From, friend.REPLY_TYPE_CATNIP_ITEMS, "", m.End, Items)
|
||
PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
|
||
p.PushClientRes(&proto.ResFriendReplyNotify{
|
||
Info: &proto.ResFriendReply{
|
||
Player: PlayerSimpleData,
|
||
Param: ReplyInfo.Param,
|
||
Type: int32(ReplyInfo.Type),
|
||
Id: int32(ReplyInfo.Id),
|
||
},
|
||
Type: int32(friend.REPLY_TYPE_CATNIP_ITEMS),
|
||
Time: int32(m.SendT),
|
||
})
|
||
}
|
||
p.CatnipBackData()
|
||
case msg.HANDLE_TYPE_CATNIP_SEND_EMOJI:
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
EmojiId := GoUtil.Int(m.Extra)
|
||
CatnipMod.SetEmoji(m.From, EmojiId)
|
||
p.CatnipBackData()
|
||
case msg.HANDLE_TYPE_FRIEND_GREETING_REPLY:
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
if v, ok := m.Extra.(friend.ReplyInfo); ok {
|
||
FriendMod.AddReplyInfo(v.Uid, v.Type, v.Param, GoUtil.Now()+24*3600, nil)
|
||
p.FriendLogBackData()
|
||
}
|
||
case msg.HANDLE_TYPE_FRIEND_SPONSOER:
|
||
p.AddLog(m.From, friend.LOG_TYPE_FRIEND_SPONSOR_GET, "", m.SendT)
|
||
case msg.SERVER_PLAYER_SYNC_LOGOUT_MSG:
|
||
p.LoginBackData()
|
||
default:
|
||
log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
|
||
}
|
||
// #region 以下是处理系统请求
|
||
return nil
|
||
}
|
||
|
||
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.SendMail(&mail.MailStruct{
|
||
Title: v.Title,
|
||
Content: v.Content,
|
||
TitleEn: v.TitleEn,
|
||
ContentEn: v.ContentEn,
|
||
TitlePtBr: v.TitlePtBr,
|
||
ContentPtBr: v.ContentPtBr,
|
||
TitleEsLatam: v.TitleEsLatam,
|
||
ContentEsLatam: v.ContentEsLatam,
|
||
Items: v.Items,
|
||
Type: v.Mail_type,
|
||
})
|
||
}
|
||
p.PushClientRes(MailMod.BackData())
|
||
}
|
||
|
||
func (p *Player) CatnipGrowthMsg(To, Id, Growth, FriendItems int) error {
|
||
ActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
|
||
FriendMgrSend(&msg.Msg{
|
||
From: int(p.M_DwUin),
|
||
To: To,
|
||
Type: msg.HANDLE_TYPE_CATNIP_GROWTH,
|
||
SendT: GoUtil.Now(),
|
||
Extra: CatnipMsg{
|
||
ActivityId: ActivityId,
|
||
GameId: Id,
|
||
Growth: Growth,
|
||
FriendItems: FriendItems,
|
||
},
|
||
})
|
||
return nil
|
||
}
|
||
|
||
// 发送消息给玩家
|
||
func ClusterSendMsg(ServerId int, m *msg.Msg) {
|
||
mergeCluster.SendServerMsg(m, ServerId)
|
||
}
|
||
|
||
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)
|
||
if ps == nil {
|
||
return &proto.ResFriendCard{}
|
||
}
|
||
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 (p *Player) EmitRetireTrigger1() {
|
||
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 (p *Player) EmitRetireTrigger2() {
|
||
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.ChargeBackData()
|
||
continue
|
||
}
|
||
OrderMod.CreateCleanOrder(ChessList)
|
||
return
|
||
}
|
||
}
|
||
|
||
func NotifyChampshipResult(Uid, Rank int) {
|
||
PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
|
||
if PlayerSimpleData == nil {
|
||
return
|
||
}
|
||
for _, v := range PlayerSimpleData.Friend {
|
||
SendPlayerMsgAsync(&msg.Msg{
|
||
Type: msg.HANDLE_TYPE_CHAMPSHIP_RESULT,
|
||
From: Uid,
|
||
To: v,
|
||
SendT: GoUtil.Now(),
|
||
Extra: []int{Rank, GoUtil.GetServerOpenDay()},
|
||
})
|
||
}
|
||
}
|
||
|
||
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) FixDecorate() {
|
||
DecorateMod := player.PlayMod.getDecorateMod()
|
||
area_id := DecorateMod.GetAreaId()
|
||
progress := DecorateMod.GetProgress()
|
||
if GoUtil.InArray(area_id, []int{3, 4, 5}) && progress >= 20 {
|
||
items := []*item.Item{}
|
||
for i := progress + 1; i <= 25; i++ {
|
||
if area_id == 3 && i == 25 {
|
||
items = append(items, item.NewItem(item.ITEM_ENERGY_ID, 50))
|
||
items = append(items, item.NewItem(101449, 1))
|
||
}
|
||
if area_id == 4 && i == 22 {
|
||
items = append(items, item.NewItem(906, 1))
|
||
}
|
||
if area_id == 4 && i == 25 {
|
||
items = append(items, item.NewItem(item.ITEM_ENERGY_ID, 50))
|
||
items = append(items, item.NewItem(101452, 1))
|
||
}
|
||
if area_id == 5 && i == 25 {
|
||
items = append(items, item.NewItem(item.ITEM_ENERGY_ID, 50))
|
||
items = append(items, item.NewItem(101450, 1))
|
||
}
|
||
}
|
||
title := "Game Update & Thank-You Gift"
|
||
content := `Hi there!
|
||
|
||
Thanks so much for your continued support!
|
||
We've made a few updates to the game—and as a small thank-you, we've prepared a special gift for you.
|
||
|
||
Happy merging!
|
||
|
||
Meowment Team`
|
||
title_ptbr := "Atualização do Jogo e Presente de Agradecimento"
|
||
content_ptbr := `Olá!
|
||
|
||
Muito obrigado pelo seu apoio contínuo!
|
||
Fizemos algumas atualizações no jogo — e como forma de agradecimento, preparamos um presente especial para você.
|
||
|
||
Boa diversão nas combinações!
|
||
|
||
Equipe Meowment `
|
||
|
||
MailMod := player.PlayMod.getMailMod()
|
||
MailMod.SendMail(&mail.MailStruct{
|
||
Title: title,
|
||
Content: content,
|
||
TitleEn: title,
|
||
ContentEn: content,
|
||
TitlePtBr: title_ptbr,
|
||
ContentPtBr: content_ptbr,
|
||
Items: items,
|
||
Type: mail.MAIL_TYPE_NORMAL,
|
||
})
|
||
DecorateMod.AreaId = area_id + 1
|
||
DecorateMod.FinishList = make(map[int]struct{})
|
||
DecorateMod.Progress = 0
|
||
DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
|
||
DecorateMod.PartClassPool = []int{}
|
||
DecorateMod.PartPool = make(map[int]int)
|
||
DecorateMod.InitData()
|
||
log.Debug("player id : %d fix decorate old area id : %d old progress : %d", player.M_DwUin, area_id, progress)
|
||
player.PushClientRes(DecorateMod.BackData())
|
||
}
|
||
}
|
||
|
||
func (player *Player) CreatePetOrder() {
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
PetTrigger := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if v.Type == order.Pet_type {
|
||
PetTrigger = false
|
||
break
|
||
}
|
||
}
|
||
if 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
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
// 触发式订单 满足条件生成零件订单
|
||
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, len(CardList))
|
||
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 < 2 {
|
||
continue
|
||
}
|
||
add := true
|
||
for _, v := range OrderMod.GetOrderList() {
|
||
if GoUtil.SliceEqual(v.MergeId, []int{ChessId, ChessId}) || GoUtil.SliceEqual(v.MergeId, []int{ChessId, ChessId, ChessId}) {
|
||
add = false
|
||
break
|
||
}
|
||
}
|
||
if add {
|
||
OrderMod.AddExtraOrder([]int{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
|
||
}
|
||
|
||
func (player *Player) IsWeeklyDiscount() bool {
|
||
ChargeMod := player.PlayMod.getChargeMod()
|
||
LimitEventMod := player.PlayMod.getLimitedTimeEventMod()
|
||
return ChargeMod.IsWeeklyDiscountDay() || LimitEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_DAY_SALE)
|
||
}
|
||
|
||
func (p *Player) SetCatnipPartner(GameId, Partner int, EndTime int64) error {
|
||
_, err := SendMsgToCenterSync(&msg.Msg{
|
||
From: int(p.M_DwUin),
|
||
To: int(p.M_DwUin),
|
||
Type: msg.HANDLE_MOD_CATNIP_PARTNER,
|
||
Extra: CatnipPartner{
|
||
GameId: GameId,
|
||
Partner: Partner,
|
||
EndTime: EndTime,
|
||
Uid: int(p.M_DwUin),
|
||
},
|
||
})
|
||
return err
|
||
}
|