bl/logic/service/player/player.go

package player

import (
	"blazing/common/data"
	"blazing/common/data/xmlres"
	"blazing/common/socket/errorcode"
	"blazing/cool"
	"blazing/logic/service/common"
	"blazing/logic/service/fight/info"
	"blazing/logic/service/space"
	"fmt"
	"sync"
	"sync/atomic"
	"time"

	"blazing/modules/base/service"

	config "blazing/modules/config/service"
	dictrvice "blazing/modules/dict/service"
	blservice "blazing/modules/player/service"
	"context"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/grand"
	csmap "github.com/mhmtszr/concurrent-swiss-map"
	"github.com/panjf2000/gnet/v2"
)

// Mainplayer 全局玩家数据存储映射
var Mainplayer = csmap.New[uint32, *ClientData]()

type OgrePetInfo struct {
	ID        uint32
	ShinyLen  uint32            `json:"-" struc:"sizeof=ShinyInfo"`
	ShinyInfo []data.GlowFilter `json:"ShinyInfo,omitempty"`
	Lv        uint32            `struc:"skip"` //等级
	//XUANCAI   int64             `struc:"skip"`
	//Item      int64  `struc:"skip"` //奖励,如果有的话
	Ext       uint32 `struc:"skip"` //是否变尼尔尼奥
	IsCapture int    `struc:"skip"`
}

func (o *OgrePetInfo) GetID() int {

	if o.Ext != 0 {
		return int(o.Ext)
	}
	return int(o.ID)
}
func (o *OgrePetInfo) GetLevel() int {

	if o.Ext != 0 {
		return 16
	}
	return int(o.Lv)
}

// handleNPCFightSpecial 处理NPC战斗特殊情况
func (o *OgrePetInfo) HandleNPCFightSpecial(can int) {
	if can == 0 && o.Ext == 0 { //不能抓并且不是尼尔
		o.IsCapture = 0
		return
	}

	petCfg, ok := xmlres.PetMAP[o.GetID()]
	if !ok {

		o.IsCapture = 0
	} else {
		o.IsCapture = gconv.Int(petCfg.CatchRate)
	}
	if o.Ext != 0 {
		return
	}
	var co *data.GlowFilter

	if cool.Config.ServerInfo.IsVip != 0 { //测试服,百分百异色
		co = config.NewShinyService().RandShiny(o.ID)
	} else {
		if o.IsCapture != 0 && grand.Meet(1, 500) {

			co = config.NewShinyService().RandomByWeightShiny(o.ID)

		}
	}
	if co != nil && len(o.ShinyInfo) == 0 {
		o.ShinyInfo = append(o.ShinyInfo, *co)

	}
}

type Player struct {
	MainConn gnet.Conn
	baseplayer
	IsLogin bool //是否登录
	IsJoin  bool //是否加入RPC对局 用重连函数写临时缓存join，重连后统一join
	Done

	MapNPC *time.Timer

	context.Context
	Fightinfo info.Fightinfo // 当前邀请的玩家ID

	Logintime uint32 // 当前登录时间
	OgrePet
	PetDisplay PetDisplayState

	Service *blservice.UserService
	User    *service.BaseSysUserService
	// PVP被邀请信息
	HavePVPinfo []common.PlayerI
	monsters    [3]int
	// 0 无,1可以刷怪,2是切换过地图
	Canmon  uint32 // 可以刷怪
	CurDark uint32
	Hash    uint32

	ArenaFlags uint32

	logoutMu    sync.Mutex
	logoutDone  chan struct{}
	logoutSaved bool
}

const (
	ArenaFlagNoSwitchPet uint32 = 1 << iota
	ArenaFlagNoHeal
	ArenaFlagNoPVP
)

const arenaHostFlagMask = ArenaFlagNoSwitchPet | ArenaFlagNoHeal | ArenaFlagNoPVP

func (p *Player) addArenaFlag(mask uint32) {
	for {
		current := atomic.LoadUint32(&p.ArenaFlags)
		next := current | mask
		if current == next || atomic.CompareAndSwapUint32(&p.ArenaFlags, current, next) {
			return
		}
	}
}

func (p *Player) clearArenaFlag(mask uint32) {
	for {
		current := atomic.LoadUint32(&p.ArenaFlags)
		next := current &^ mask
		if current == next || atomic.CompareAndSwapUint32(&p.ArenaFlags, current, next) {
			return
		}
	}
}

func (p *Player) HasArenaFlag(mask uint32) bool {
	return atomic.LoadUint32(&p.ArenaFlags)&mask != 0
}

func (p *Player) SetArenaHostFlags() {
	p.addArenaFlag(arenaHostFlagMask)
}

func (p *Player) ClearArenaHostFlags() {
	p.clearArenaFlag(arenaHostFlagMask)
}

func (p *Player) IsArenaHost() bool {
	return p.HasArenaFlag(arenaHostFlagMask)
}

func (p *Player) IsArenaSwitchLocked() bool {
	return p.HasArenaFlag(ArenaFlagNoSwitchPet)
}

func (p *Player) IsArenaHealLocked() bool {
	return p.HasArenaFlag(ArenaFlagNoHeal)
}

func (p *Player) IsArenaPVPLocked() bool {
	return p.HasArenaFlag(ArenaFlagNoPVP)
}

type OgrePet struct {
	Data [9]OgrePetInfo
}

func (p *Player) GetCoins(amount int64) bool {
	if int64(p.Info.Coins) < amount {
		return false
	}
	return true
}

func (p *Player) UseGold(amount int64) bool {
	if p.User.GetGold(uint(p.Info.UserID)) < amount {
		return false
	}
	return true
}

func (p *Player) GetAction() {

}

// InvitePlayer 邀请玩家进行对战
func (f *Player) InvitePlayer(ff common.PlayerI) {
	f.HavePVPinfo = append(f.HavePVPinfo, ff)
	tt := common.NewTomeeHeader(2501, f.GetInfo().UserID)
	f.SendPack(tt.Pack(&info.NoteInviteToFightOutboundInfo{
		UserID: ff.GetInfo().UserID,
		Nick:   ff.GetInfo().Nick,
		Mode:   ff.Getfightinfo().Mode,
	}))
}

// Getfightinfo 获取玩家的战斗信息
func (p *Player) Getfightinfo() info.Fightinfo {
	return p.Fightinfo
}

// QuitFight 退出战斗
func (p *Player) QuitFight() {
	p.FightC = nil
	atomic.StoreUint32(&p.Fightinfo.Mode, 0)
}

// GetSpace 获取玩家所在的空间
func (p *Player) GetSpace() *space.Space {
	return space.GetSpace(p.Info.MapID)
}

func (p *Player) CurrentMapPetLevelLimit() uint32 {
	if p == nil {
		return 100
	}
	currentSpace := p.GetSpace()
	if currentSpace != nil && currentSpace.IsLevelBreakMap {
		return 0
	}
	return 100
}

func (p *Player) IsCurrentMapLevelBreak() bool {
	return p != nil && p.CurrentMapPetLevelLimit() == 0
}

// CanFight 检查玩家是否可以进行战斗
// 0无战斗，1PVP，2,BOOS,3PVE
func (p *Player) CanFight() errorcode.ErrorCode {
	if len(p.Info.PetList) == 0 {
		atomic.StoreUint32(&p.Fightinfo.Mode, 0)
		return errorcode.ErrorCodes.ErrBattleCancelled
	}

	if p.FightC != nil {
		atomic.StoreUint32(&p.Fightinfo.Mode, 0)
		return errorcode.ErrorCodes.ErrBattleEnded
	}

	for _, pet := range p.Info.PetList {
		if pet.Hp > 0 { // 只要找到一个血量大于0的宠物，就可以战斗
			return 0
		}
	}

	// 遍历完所有宠物，都没有血量大于0的，才不能战斗
	atomic.StoreUint32(&p.Fightinfo.Mode, 0)
	return errorcode.ErrorCodes.ErrPokemonNoStamina
}

func (p *Player) SendPack(b []byte) error {
	if p.MainConn == nil {
		return nil
	}
	psocket, ok := p.MainConn.Context().(*ClientData)
	if ok {
		return psocket.SendPack(b)
	} else {

		return fmt.Errorf("链接错误,取消发包")

	}

}

// 添加物品 返回成功添加的物品
// ItemAddBatch 批量添加物品，普通道具先按 ItemAdd 的规则校验上限，再批量落库。
func (p *Player) ItemAddBatch(items []data.ItemInfo) []data.ItemInfo {
	if len(items) == 0 {
		return nil
	}

	sendErr := func(code errorcode.ErrorCode) {
		t1 := common.NewTomeeHeader(2601, p.Info.UserID)
		t1.Result = uint32(code)
		p.SendPack(t1.Pack(nil))
	}

	var (
		regularItems   = make([]data.ItemInfo, 0, len(items))
		regularIndexes = make([]int, 0, len(items))
		itemIDs        = make([]uint32, 0, len(items))
		seenIDs        = make(map[uint32]struct{}, len(items))
		specialSuccess = make(map[int]bool, len(items))
	)

	for idx, item := range items {
		if item.ItemCnt <= 0 {
			sendErr(errorcode.ErrorCodes.ErrSystemError200007)
			continue
		}

		switch item.ItemId {
		case 1, 3, 5, 9:
			if p.ItemAdd(item.ItemId, item.ItemCnt) {
				specialSuccess[idx] = true
			}
		default:
			regularItems = append(regularItems, item)
			regularIndexes = append(regularIndexes, idx)

			itemID := uint32(item.ItemId)
			if _, ok := seenIDs[itemID]; ok {
				continue
			}
			seenIDs[itemID] = struct{}{}
			itemIDs = append(itemIDs, itemID)
		}
	}

	if len(regularItems) == 0 {
		result := make([]data.ItemInfo, 0, len(items))
		for idx, item := range items {
			if specialSuccess[idx] {
				result = append(result, item)
			}
		}
		return result
	}

	currentItems := p.Service.Item.CheakItemM(itemIDs...)
	currentMap := make(map[uint32]int64, len(currentItems))
	for _, item := range currentItems {
		currentMap[item.ItemId] = item.ItemCnt
	}
	maxMap := dictrvice.NewDictInfoService().GetMaxMap(itemIDs...)

	batchItems := make([]data.ItemInfo, 0, len(regularItems))
	pendingMap := make(map[uint32]int64, len(itemIDs))
	for _, item := range regularItems {
		itemID := uint32(item.ItemId)
		itemmax := maxMap[itemID]
		if itemmax == 0 {
			cool.Logger.Error(context.TODO(), "物品不存在", p.Info.UserID, item.ItemId)
			sendErr(errorcode.ErrorCodes.ErrSystemError200007)
			continue
		}

		if currentMap[itemID]+pendingMap[itemID]+item.ItemCnt > int64(itemmax) {
			println(p.Info.UserID, "物品超过拥有最大限制", item.ItemId)
			sendErr(errorcode.ErrorCodes.ErrTooManyOfItem)
			continue
		}

		pendingMap[itemID] += item.ItemCnt
		batchItems = append(batchItems, item)
	}

	addedRegularItems, err := p.Service.Item.AddItemsChecked(batchItems, currentMap)
	if err != nil {
		sendErr(errorcode.ErrorCodes.ErrSystemError200007)
		return nil
	}

	regularSuccess := make(map[int]bool, len(addedRegularItems))
	regularPos := 0
	for idx, item := range regularItems {
		if regularPos < len(addedRegularItems) &&
			addedRegularItems[regularPos].ItemId == item.ItemId &&
			addedRegularItems[regularPos].ItemCnt == item.ItemCnt {
			regularSuccess[regularIndexes[idx]] = true
			regularPos++
		}
	}

	result := make([]data.ItemInfo, 0, len(items))
	for idx, item := range items {
		if specialSuccess[idx] || regularSuccess[idx] {
			result = append(result, item)
		}
	}
	return result
}

func (p *Player) ItemAdd(ItemId, ItemCnt int64) (result bool) {
	if ItemCnt <= 0 {
		t1 := common.NewTomeeHeader(2601, p.Info.UserID)
		t1.Result = uint32(errorcode.ErrorCodes.ErrSystemError200007)

		p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
	}
	switch ItemId {
	case 1: //塞尔豆
		p.Info.Coins = p.Info.Coins + ItemCnt
		return true
	case 3: //累计经验
		p.Info.ExpPool = p.Info.ExpPool + ItemCnt
		return true

	case 5: //金豆ItemAdd
		p.User.UpdateGold(p.Info.UserID, int64(ItemCnt*100))
		return true
	case 9: //学习力
		p.Info.EVPool = p.Info.EVPool + ItemCnt

	default:
		itemmax := dictrvice.NewDictInfoService().GetMax(ItemId)
		if itemmax == 0 {
			cool.Logger.Error(context.TODO(), "物品不存在", p.Info.UserID, ItemId)

			t1 := common.NewTomeeHeader(2601, p.Info.UserID)
			t1.Result = uint32(errorcode.ErrorCodes.ErrSystemError200007)

			p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
			return false

		}

		if p.Service.Item.CheakItem(uint32(ItemId))+int64(ItemCnt) > int64(itemmax) {

			println(p.Info.UserID, "物品超过拥有最大限制", ItemId)
			t1 := common.NewTomeeHeader(2601, p.Info.UserID)
			t1.Result = uint32(errorcode.ErrorCodes.ErrTooManyOfItem)

			p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
			return false
		}
		if err := p.Service.Item.UPDATE(uint32(ItemId), gconv.Int(ItemCnt)); err != nil {
			cool.Logger.Error(context.TODO(), "item add update failed", p.Info.UserID, ItemId, ItemCnt, err)

			t1 := common.NewTomeeHeader(2601, p.Info.UserID)
			t1.Result = uint32(errorcode.ErrorCodes.ErrSystemError200007)

			p.SendPack(t1.Pack(nil)) //准备包由各自发,因为协议不一样
			return false
		}
		return true
	}

	return false
}

// Kick  是否热更退出
func (player1 *Player) Kick(isquit bool) {
	if player1.Info == nil {
		return
	}

	head := common.NewTomeeHeader(1001, player1.Info.UserID)

	head.Result = uint32(errorcode.ErrorCodes.ErrAccountLoggedInElsewhere)
	if isquit {
		head.Result = uint32(errorcode.ErrorCodes.ErrXinPlanSleepMode)
	}
	// 实际上这里有个问题,会造成重复保存问题

	player1.SendPack(head.Pack(nil))

	CloseChan := make(chan struct{})

	player1.MainConn.CloseWithCallback(func(c gnet.Conn, err error) error {
		close(CloseChan)
		return nil
	})

	// --- 新增超时机制核心代码 ---
	// 设定超时时间（可根据业务需求调整，这里以3秒为例）
	const kickTimeout = 10 * time.Second
	timeout := false
	select {
	case <-CloseChan:
		// 正常流程：连接关闭回调已执行，CloseChan 被关闭
	case <-time.After(kickTimeout):
		timeout = true
	}
	player1.SaveOnDisconnect()
	if timeout {
		service.NewBaseSysLogService().RecordKick(uint32(player1.Info.UserID), fmt.Sprintf("踢人操作超时（超时时间：%v）", kickTimeout))
	}
}

// 1是延迟踢人,0是强制踢人
func (player1 *Player) KickMessage() {
	if player1.Info == nil {
		return
	}
	// 取成功,否则创建
	// player1.Save() //先保存数据再返回
	head := common.NewTomeeHeader(1001, player1.Info.UserID)

	head.Result = uint32(errorcode.ErrorCodes.ErrXinPlanSleepMode)
	// 实际上这里有个问题,会造成重复保存问题

	player1.SendPack(head.Pack(nil))

}

func (p *Player) Cheak(b error) {
	if b != nil {
		g.Log().Error(context.Background(), "出现错误", p.Info.UserID, b.Error())
	}

}

func (p *Player) GiveTitle(id uint32) {
	r := p.Service.Title.Can(id) //已经有了就不给了
	if r {
		return
	}
	p.Service.Title.Give(id)
	p.SendPackCmd(50005, &info.S2C_50005{
		Title: id,
	})
}