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的数据
		}
		backup.Reclaim() // 回收备份对象
		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 = nil
	}
}

// 消息处理
func (p *Player) handle(m *msg.Msg) error {
	switch m.Type {
	case msg.HANDLE_TYPE_APPLY: // 好友申请
		FriendMod := p.PlayMod.getFriendMod()
		var addType int
		info, ok := m.Extra.(map[string]interface{})
		if ok {
			addType = GoUtil.Int(info["type"])
		}
		ok = FriendMod.AddFriendApply(m.From, addType, m.SendT)
		// 已申请
		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()),
		})
		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()
		err := InviteMod.AddInvite(m.From)
		if err != nil {
			return err
		}
		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
			FriendMgrSend(&msg.Msg{Type: msg.HANDLE_TYPE_REG_CARD_FINISH, From: k, Extra: &v})
			CardMod.DelRequestCard(k)
		}
		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.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)
		var gameId, rank int
		if len(extra) >= 2 {
			gameId = extra[0]
			rank = extra[1]
		} else {
			return nil
		}
		p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_CHAMPSHIP, fmt.Sprintf("%d_%d", gameId, rank), m.SendT)
	case msg.HANDLE_TYPE_TREASURE_RESULT: // 好友宝藏结果
		// 暂未处理
	case msg.HANDLE_TYPE_MAIL: // 邮件操作
		SyncMailMsg(p)
	case msg.HANDLE_TYPE_PLAYROOM_LOSE: // #  玩家输了
		PlayroomMod := p.PlayMod.getPlayroomMod()
		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(m.Item) == 0 {
			return nil
		}
		var broken bool
		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", m.Item[0].Id, m.Item[0].Num, emoji), m.SendT)
		} else {
			p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_VISIT, fmt.Sprintf("%d_%d_%d", m.Item[0].Id, m.Item[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 m.Item[0].Id == item.ITEM_STAR_ID {
			BaseMod := p.PlayMod.getBaseMod()
			starNum := BaseMod.GetStar()
			m.Item[0].Num = min(m.Item[0].Num, starNum)
			if m.Item[0].Num >= starNum {
				broken = true
				p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_BROKEN, fmt.Sprintf("%d", m.Item[0].Id), m.SendT)
			}
			p.HandleLoseItem(m.Item, "HANDLE_TYPE_PLAYROOM_LOSE")
		} else {
			PlayroomMod.Lose(m.Item)
		}
		if broken {
			playerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
			p.PushClientRes(&proto.NotifyPlayroomBroken{
				Player: playerSimpleData,
			})
		}
		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": m.Item})
		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: // 收到好友赠送的充值礼包
		chargeExtra, ok := m.Extra.(*ChargeExtra)
		if !ok {
			chargeExtra = &ChargeExtra{}
		}
		playerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(m.From)
		MailMod := p.PlayMod.getMailMod()
		mt, mc, mt_en, mc_en := mailCfg.GetChargeSendMail(playerSimpleData.Name)
		items := p.ChargeItem(chargeExtra.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.(map[string]interface{})
		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.(map[string]interface{})
		if !ok {
			return nil
		}
		activityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
		if activityId != catnipMsg["ActivityId"] { // 活动ID不匹配
			return nil
		}
		CatnipMod.BeAgree(GoUtil.Int(catnipMsg["GameId"]), int(m.From))
	case msg.HANDLE_TYPE_CATNIP_AGREE_DEL: // 同意好友参与猫咪游戏后删除邀请
		CatnipMod := p.PlayMod.getCatnipMod()
		catnipMsg, ok := m.Extra.(map[string]interface{})
		if !ok {
			return nil
		}
		activityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
		if activityId != catnipMsg["ActivityId"] { // 活动ID不匹配
			return nil
		}
		CatnipMod.DelInvited(GoUtil.Int(catnipMsg["GameId"]), int(m.From))
	case msg.HANDLE_TYPE_CATNIP_REFUSE: // 拒绝好友参与猫咪游戏
		CatnipMod := p.PlayMod.getCatnipMod()
		catnipMsg, ok := m.Extra.(map[string]interface{})
		if !ok {
			return nil
		}
		activityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
		if activityId != catnipMsg["ActivityId"] { // 活动ID不匹配
			return nil
		}
		CatnipMod.DelInvited(GoUtil.Int(catnipMsg["GameId"]), int(m.From))
	case msg.HANDLE_TYPE_CATNIP_GROWTH:
		CatnipMod := p.PlayMod.getCatnipMod()
		catnipMsg, ok := m.Extra.(map[string]interface{})
		if !ok {
			return nil
		}
		activityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
		if activityId != catnipMsg["ActivityId"] { // 活动ID不匹配
			return nil
		}
		CatnipMod.GrowthByUid(m.From, GoUtil.Int(catnipMsg["Growth"]))
		if GoUtil.Int(catnipMsg["FriendItems"]) > 0 {
			Items := catnipCfg.GetItemCost(activityId, GoUtil.Int(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()+oneday, 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:
		info, ok := m.Extra.(map[string]interface{})
		if !ok {
			return nil
		}
		applyUids, ok := info["apply_uids"].([]int64)
		p.TeLog("login_recive_logout_msg", map[string]interface{}{
			"apply_uids":  applyUids,
			"other_uids":  info["other_uids"],
			"apply_count": info["apply_count"],
			"other_count": info["other_count"],
		})
		if ok && len(applyUids) > 0 {
			var faceList []int
			var name string
			var facebookPic []string
			for _, v := range applyUids {
				ps := G_GameLogicPtr.GetSimplePlayerByUid(int(v))
				if ps != nil {
					faceList = append(faceList, ps.Face)
					name = ps.Name
					facebookPic = append(facebookPic, ps.FaceBookPic)
				}
			}
			p.PushClientRes(&proto.ResPlayerLougouMsg{
				Name:        name,
				Face:        GoUtil.IntToInt32(faceList),
				Count:       GoUtil.Int32(info["apply_count"]),
				FacebookPic: facebookPic,
				Uids:        applyUids,
			})
		}
		otherUids, ok := info["other_uids"].([]int64)
		if ok && len(otherUids) > 0 {
			var faceList []int
			var name string
			var facebookPic []string
			for _, v := range otherUids {
				ps := G_GameLogicPtr.GetSimplePlayerByUid(int(v))
				if ps != nil {
					faceList = append(faceList, ps.Face)
					name = ps.Name
					facebookPic = append(facebookPic, ps.FaceBookPic)
				}
			}
			p.PushClientRes(&proto.ResPlayerLougouMsg{
				Type:        1,
				Name:        name,
				Face:        GoUtil.IntToInt32(faceList),
				Count:       GoUtil.Int32(info["other_count"]),
				FacebookPic: facebookPic,
				Uids:        otherUids,
			})
		}
	case msg.HANDLE_TYPE_ACTIVITY_RELOAD:
		p.InitActivity()
		p.BackDataActivity()
		p.PushClientRes(p.GetMailMod().BackData())
	default:
		log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
	}
	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: map[string]interface{}{
			"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.AUid
	}

	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{})
	for _, v := range emitList {
		emit_Id := mergeDataCfg.GetEmitId(v)
		if emit_Id == "" {
			continue
		}
		emitId[emit_Id] = struct{}{}
	}
	var emitId1 []string
	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{})
	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
	}
	now := GoUtil.Now()
	serveropenday := GoUtil.GetServerOpenDay()
	for _, v := range playerSimpleData.Friend {
		if CheckPlayerLose(v) {
			continue
		}
		SendPlayerMsgAsync(&msg.Msg{
			Type:  msg.HANDLE_TYPE_CHAMPSHIP_RESULT,
			From:  Uid,
			To:    v,
			SendT: now,
			End:   now + sevendays,
			Extra: []int{Rank, serveropenday},
		})
	}
}

func (player *Player) GetPetOrderItemExp() int {
	orderItemCfgList := playroomCfg.GetOrderItemList()
	items := make([]*item.Item, 0)
	itemMod := player.PlayMod.getItemMod()
	for _, v := range orderItemCfgList {
		num := itemMod.GetItem(v)
		if num <= 0 {
			continue
		}
		items = append(items, &item.Item{
			Id:  v,
			Num: num,
		})
	}
	return playroomCfg.GetPetOrderItemExpByList(items)
}

// 触发生成新的固定订单
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) {
				vType := order.Fixed_type
				orderType := orderCfg.GetOrderType(v.Id)
				if orderType != 0 {
					vType = 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,
					"order_virtual_energy": order.GetVirtualEnergy(v.MergeList, player.GetChessMod().GetStarEmitList()),
				})
				if exists {
					orderInfo.Type = order.Fixed_type
					OrderMod.OrderList[v.Id] = orderInfo
				} else {
					OrderMod.AddFixOrder(v.Id, v.MergeList, vType, 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.GetStarEmitList()))}
			}
			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.GetStarEmitList()))}
		}
		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.CreatePetOrder(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
			}
			var items []*item.Item
			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
				}
				star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
				star = int(float64(star)*float64(orderFactor)/1000) * 10
				v.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
			}
			var items []*item.Item
			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.GetOrderPartEmit(), 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
		}
		star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
		star = int(float64(star)*float64(orderFactor)/1000) * 10
		v.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
}

// 获取playroom小游戏奖励
func (p *Player) GetPlayroomGameReward(gType, selectId int) []*item.Item {
	PlayroomMod := p.PlayMod.getPlayroomMod()
	BaseMod := p.PlayMod.getBaseMod()
	level := BaseMod.GetLevel()
	var items []*item.Item
	switch gType {
	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)
	var 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
}

/*
高级产物订单
当玩家完成一个订单时，扫描棋盘上的产物，剔除：1)刚完成的订单的最后一个棋子所属发射器的所有产物链产物，2)下一个订单的第一个棋子所属发射器的所有产物链产物
剩下的棋盘产物中，是否有棋子等级等级>pLvmax（适配翻倍和动态难度）的，如有，则生成一个订单，将等级最高的那个收走
注意：当现有订单（无论是自动或固定订单）中有此棋子，则不执行此逻辑
*/
func (p *Player) AddHighOrder() {
	OrderMod := p.PlayMod.getOrderMod()
	BaseMod := p.PlayMod.getBaseMod()
	ChessMod := p.PlayMod.getChessMod()
	if len(OrderMod.LastOrder.MergeId) == 0 {
		return
	}
	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)
	var product []string
	product = append(product, mergeDataCfg.GetEmitProduceType(lastEmitId)...)
	product = append(product, mergeDataCfg.GetEmitProduceType(addNewEmitId)...)
	chessMap := make(map[string]int)
	chessList := ChessMod.GetUnlockChessList()
	chessBagList := ChessMod.GetChessBagList()
	chessList = append(chessList, chessBagList...)
	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
		}
	}
	RetireProduceColor := ChessMod.GetRetireProduceColor()
	emitList := ChessMod.GetEmitList()
	for Color, ChessId := range chessMap {
		emitId := order.GetEmitByColor(emitList, Color)
		if emitId == 0 {
			continue
		}
		_, ChessMaxLv := getChesslvRange(emitId, BaseMod.GetEnergyMul(), OrderMod.IsCharge)
		newLev2 := mergeDataCfg.DynamicLev(ChessMaxLv, emitId, Color)
		newLev3 := order.AdjustLev(newLev2, BaseMod.GetEnergyMul())
		chessLv := mergeDataCfg.GetLvById(ChessId)
		chessColor := mergeDataCfg.GetColorById(ChessId)
		// 退役产物不生成订单
		if GoUtil.InStringArray(chessColor, RetireProduceColor) {
			continue
		}
		if newLev3 >= chessLv {
			continue
		}
		add := true
		for _, v := range OrderMod.GetOrderList() {
			if GoUtil.InArray(ChessId, v.MergeId) {
				add = false
			}
			// 增加当订单中已有同类型且等级大于等于该棋子的订单时，不生成订单
			for _, v1 := range v.MergeId {
				if mergeDataCfg.GetColorById(v1) == Color && mergeDataCfg.GetLvById(v1) >= chessLv {
					add = false
					break
				}
			}
		}
		if add {
			OrderMod.AddExtraOrder([]int{ChessId})
			return
		}
	}
}

// 高级产物订单
/**
当玩家生成了两个一样的最高等级产物，自动生成一个订单收掉它们。
注意：当现有订单（无论是自动或固定订单）中已有两个或三个最高等级产物订单的时候，不执行此逻辑
*/
func (p *Player) AddHighOrder2() {
	BaseMod := p.PlayMod.getBaseMod()
	if BaseMod.GetLevel() < 12 {
		return
	}
	OrderMod := p.PlayMod.getOrderMod()
	ChessMod := p.PlayMod.getChessMod()
	chessList := ChessMod.GetUnlockChessList()
	chessBagList := ChessMod.GetChessBagList()
	chessList = append(chessList, chessBagList...)
	chessMap := make(map[int]int)
	for _, v := range chessList {
		lv := mergeDataCfg.GetLvById(v)
		maxLv := mergeDataCfg.GetMaxLvById(v)
		if lv != maxLv {
			continue
		}
		chessType := mergeDataCfg.GetTypeById(v)
		if chessType != "Product" {
			continue
		}
		chessMap[v]++
	}
	retireProduceColor := ChessMod.GetRetireProduceColor()
	for ChessId, Num := range chessMap {
		if Num < 2 {
			continue
		}
		chessColor := mergeDataCfg.GetColorById(ChessId)
		// 退役产物不生成订单
		if GoUtil.InStringArray(chessColor, retireProduceColor) {
			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) DeleteHighOrder() {
	OrderMod := p.PlayMod.getOrderMod()
	ChessMod := p.PlayMod.getChessMod()
	chessList := ChessMod.GetUnlockChessList()
	for k, v := range OrderMod.GetOrderList() {
		if v.Type != order.Extra_type {
			continue
		}
		if len(v.MergeId) == 0 {
			continue
		}
		chessId := v.MergeId[0]
		chessNum := len(v.MergeId)
		elementNum := GoUtil.ElemNumber(chessList, chessId)
		if elementNum < chessNum {
			OrderMod.DeleteOrder(k)
		}
	}
}

func (p *Player) FormatPetOrderItem(Items []*item.Item) []*item.Item {
	var newItems []*item.Item
	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 != nil && 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 != nil && clean.Num+cleanPlo <= 5 {
			randList := orderItem[2]
			newItems = append(newItems, item.NewItem(GoUtil.RandSlice(randList), 1))
			continue
		}
		var randList []int
		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()
	items := 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 {
				items[k] = v
			}
		}
	}
	return items
}

func (player *Player) GetPlayroomClean() map[int]int {
	ItemMod := player.PlayMod.getItemMod()
	items := 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 {
				items[k] = v
			}
		}
	}
	return items
}

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
}