pet_home_server/src/server/game/PlayerFunc.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"
	mailCfg "server/conf/mail"
	mergeDataCfg "server/conf/mergeData"
	playroomCfg "server/conf/playroom"
	userCfg "server/conf/user"
	"server/db"
	"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()
		PlayroomMod.AddRoomPointAdd()
		PlayroomBackData(p)
		p.TeLog("friend_add", map[string]interface{}{
			"player_id": m.From,
			"add_type":  "invite add friend",
		})
		p.PlayMod.save()
	case msg.HANDLE_TYPE_INVITE_FRIEND: // 邀请好友
		InviteMod := p.PlayMod.getInviteMod()
		InviteMod.AddInvite(m.From)
		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)
		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 := m.Extra.(card.CardInfo)
		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)
		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]))
	case msg.HANDLE_TYPE_TREASURE_RESULT: // #  好友宝藏结果
		p.AddLog(m.From, friend.LOG_TYPE_TREASURE, fmt.Sprintf("%d", m.Extra.(int)))
	case msg.HANDLE_TYPE_MAIL: // 邮件操作
		SyncMailMsg(p)
	case msg.HANDLE_TYPE_PLAYROOM_LOSE: // #  玩家输了
		PlayroomMod := p.PlayMod.getPlayroomMod()
		Items := m.Item
		IsChip := false
		if m.Extra != nil {
			IsChip = m.Extra.(bool)
		}
		if IsChip {
			PlayroomMod.AddChip(m.From, m.SendT)
		}
		PlayroomMod.AddMood(playroom.MOOD_TYPE_FOOD, -50)
		PlayroomMod.AddMood(playroom.MOOD_TYPE_CLEAN, -50)
		PlayroomMod.AddVisitor(m.From, m.SendT)
		p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_VISIT, fmt.Sprintf("%d_%d", Items[0].Id, Items[0].Num))
		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)
		}
		p.UpdateUserInfo()
		p.Kafka(PLAYROOM_LOST, map[string]interface{}{"uid": m.From, "item": Items})
		p.PushClientRes(PlayroomMod.NotifyLose())
	case msg.FRIEND_TREASURE_HANDLE: // #  好友宝藏
		Items := make([]*item.Item, 0)
		if m.Extra != nil {
			Items = m.Extra.([]*item.Item)
		}
		p.HandleItem(Items, proto.ITEM_POP_LABEL_Friendtreasure.String())
	case msg.HANDLE_TYPE_HANDBOOK_COLLECTION: // 图鉴收集奖励
		data := m.Extra.(msg.HandbookMsg)
		p.AddLog(m.From, friend.LOG_TYPE_HANDBOOK, data.Type)
	case msg.HANDLE_TYPE_HANDBOOK_UPVOTE: // 图鉴点赞
		p.AddLog(m.From, friend.LOG_TYPE_HANDBOOK_UPVOTE, "")
	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))
		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))
		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, "")
		PlayroomMod := p.PlayMod.getPlayroomMod()
		PlayroomMod.AddUpvote()
		p.UpdateUserInfo()
	case msg.HANDLE_TYPE_WISHLIST_AGREE:
		ChargeMod := p.PlayMod.getChargeMod()
		ChargeMod.AddWishCount()
		p.AddLog(m.From, friend.LOG_TYPE_WISH, "")
		p.PushClientRes(ChargeMod.BackData())
	case msg.HANDLE_TYPE_PLAYROOM_KISS: // playroom亲吻
		p.NotifyPlayroomKiss()
	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, "")
		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()
		PlayroomMod.AddRoomPointAdd()
		PlayroomBackData(p)
		p.TeLog("friend_add", map[string]interface{}{
			"player_id": m.From,
			"add_type":  "agree",
		})
		p.AddLog(m.From, friend.LOG_TYPE_FRIEND_BECOME, "")
	case msg.HANDLE_TYPE_DEL: // 删除好友
		FriendMod.DelFriend(m.From)
		p.AddLog(m.From, friend.LOG_TYPE_FRIEND_APPLY, "")
		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
			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 BackUserInfo(p *Player) {
	BaseMod := p.PlayMod.getBaseMod()
	FaceMod := p.PlayMod.getFaceMod()
	AvatarMod := p.PlayMod.getAvatarMod()
	DecorateMod := p.PlayMod.getDecorateMod()
	p.PushClientRes(&proto.UserInfo{
		Uid:         p.M_DwUin,
		Nickname:    BaseMod.NickName,
		Avatar:      int32(AvatarMod.SetId),
		Face:        int32(FaceMod.SetId),
		DecorateCnt: int32(DecorateMod.DecorateNum),
		AvatarList:  AvatarMod.BackData(),
		FaceList:    FaceMod.BackData(),
		EmojiList:   p.PlayMod.getEmojiMod().BackData(),
		SetEmoji:    p.PlayMod.getEmojiMod().GetEmojiSet(),
		Login:       int32(BaseMod.GetLoginTime()),
		PetName:     BaseMod.PetName,
		IdNum:       BaseMod.IdCardNum,
	})
}

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,
	}
}

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()
	HasVisit := PlayroomMod.GetHasVisit()
	type sortData struct {
		Uid  int
		Time int64
	}
	PlayerList := make([]sortData, 0)

	Now := GoUtil.Now()
	for k, v := range VisitorList {
		if _, ok := HasVisit[k]; ok {
			continue
		}
		if v.Time < Now-86400 {
			continue
		}
		PlayerList = 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
	}
	FriendMod := p.PlayMod.getFriendMod()
	PlayerList2 := make([]sortData, 0)
	for _, v := range PlayerList {
		if FriendMod.CheckFriend(v.Uid) {
			continue
		}
	}
	if len(PlayerList2) != 0 {
		sort.Slice(PlayerList2, func(i, j int) bool {
			return PlayerList2[i].Time < PlayerList2[j].Time
		})
		return PlayerList2[0].Uid
	}
	L := GetRecommendPlayer(p, 1)
	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.Score < 15 {
			continue
		}
		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 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])
	ChessMod.BeginRetire(EmitId1[0])
}

// 发射器退役第二步 生成清理订单
func EmitRetireTrigger2(p *Player) {
	ChessMod := p.PlayMod.getChessMod()
	OrderMod := p.PlayMod.getOrderMod()
	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
		}
		NeedFinishOrder := false
		Produce := mergeDataCfg.GetEmitProduce(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,
			Extra: []int{Rank, GoUtil.GetServerOpenDay()},
		}
		FriendMgrSend(Msg)
	}
}

func (player *Player) FormatOrderReward() {
	Exp, PExp := userCfg.GetLevUpExp(player.GetPlayerBaseMod().GetLevel())
	BaseMod := player.PlayMod.getBaseMod()
	DecorateMod := player.PlayMod.getDecorateMod()
	ExpCoin := (Exp - BaseMod.GetExp()) * decorateCfg.GetAreaPerPExp(DecorateMod.GetAreaId())
	PExpCoin := (PExp - BaseMod.GetPExp()) * 50
	OrderMod := player.PlayMod.getOrderMod()
	if ExpCoin > PExpCoin || BaseMod.GetLevel() < 6 {
		for k, v := range OrderMod.GetOrderList() {
			if len(v.Items) != 0 {
				continue
			}
			if v.Type != order.Common_type {
				continue
			}
			Star := order.GetOrderStar(v.MergeId)
			v.Items = append(v.Items, &item.Item{
				Id:  item.ITEM_STAR_ID,
				Num: Star,
			})
			OrderMod.OrderList[k] = v
		}
		return
	}
	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)
		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
	}
}

func (player *Player) GetPetOrderReward(Star int, Items []*item.Item) []*item.Item {
	OrderItem := playroomCfg.GetOrderItem(Star)
	type sortData struct {
		Type int
		Num  int
	}
	ItemMod := player.PlayMod.getItemMod()
	sortList := make([]sortData, 0)
	for k, v := range OrderItem {
		ids := make([]int, 0)
		for _, v1 := range v {
			if v1.Id == 0 {
				continue
			}
			ids = append(ids, v1.Id)
		}
		Num := ItemMod.GetItemNumByList(ids)
		sortList = append(sortList, sortData{
			Type: k,
			Num:  Num,
		})
	}
	if len(sortList) == 0 && Star > 0 {
		Items = append(Items, item.NewItem(item.ITEM_STAR_ID, Star))
		return Items
	}

	sort.Slice(sortList, func(i, j int) bool {
		return sortList[i].Num < sortList[j].Num
	})

	ItemsId := OrderItem[sortList[0].Type]
	if len(ItemsId) == 0 {
		return Items
	}

	for k, v := range ItemsId {
		ItemNum := ItemMod.GetItem(v.Id)
		for _, v1 := range Items {
			if v1.Id == v.Id {
				ItemNum += v1.Num
			}
		}
		v.Num = ItemNum
		ItemsId[k] = v
	}
	sort.Slice(ItemsId, func(i, j int) bool {
		return ItemsId[i].Num < ItemsId[j].Num
	})
	Items = append(Items, item.NewItem(ItemsId[0].Id, 1))
	Star -= ItemsId[0].Star
	if Star <= 0 {
		return Items
	}
	if len(Items) >= 2 {
		return Items
	}
	return player.GetPetOrderReward(Star, Items)
}

func (p *Player) GetPetThiefReward(Target int) []*item.Item {
	PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Target)
	if PlayerSimpleData == nil {
		log.Error("GetPetThiefReward Target %d not exist", Target)
		return nil
	}
	CardMod := p.PlayMod.getCardMod()
	CardList := ExcludeCardStar(CardMod.GetCardList())
	TargetCardList := ExcludeCardStar(PlayerSimpleData.CardInfo)
	if len(TargetCardList) == 0 {
		return []*item.Item{
			{Id: item.ITEM_STAR_ID, Num: 50},
		}
	}
	if GoUtil.IsContainSlice(CardList, TargetCardList) {
		CardId := GoUtil.RandSliceNum(TargetCardList, 1)[0]
		ItemId := cardCfg.GetItemIdByCardId(CardId)
		return []*item.Item{
			{Id: ItemId, Num: 1},
		}
	} else {
		CardList2 := GoUtil.SubSlices(TargetCardList, CardList)
		if len(CardList2) == 0 {
			return []*item.Item{
				{Id: item.ITEM_STAR_ID, Num: 50},
			}
		}
		CardId := GoUtil.RandSliceNum(CardList2, 1)[0]
		ItemId := cardCfg.GetItemIdByCardId(CardId)
		if ItemId == 0 {
			log.Error("GetPetThiefReward ItemId %d not exist", ItemId)
			return nil
		}
		return []*item.Item{
			{Id: ItemId, Num: 1},
		}
	}
}

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
}