重构

logic/service/maps/mapin.go

@@ -1,7 +1,7 @@
 package maps
 
 import (
-	"blazing/common/data/entity"
+	"blazing/common/data/socket"
 	"blazing/common/socket/handler"
 	"blazing/logic/service/space"
 	"blazing/modules/blazing/model"
@@ -26,7 +26,7 @@ type InInfo struct {
 
 func (t *InInfo) Broadcast(mapid uint32, o OutInfo) {
 
-	space.GetSpace(mapid).Range(func(playerID uint32, player *entity.Player) bool {
+	space.GetSpace(mapid).Range(func(playerID uint32, player *socket.Player) bool {
 		t.Head.Result = 0
 
 		player.SendPack(t.Head.Pack(&o))
@@ -35,7 +35,7 @@ func (t *InInfo) Broadcast(mapid uint32, o OutInfo) {
 }
 
 // 刷怪具体实现
-func (t *InInfo) SpawnMonsters(c *entity.Player, isfrist bool) {
+func (t *InInfo) SpawnMonsters(c *socket.Player, isfrist bool) {
 	// 获取当前地图的怪物配置
 
 	// if c == nil || mservice.NewMonsterService().GetId(c.MapId) == 0 { //用户离线
@@ -52,7 +52,7 @@ func (t *InInfo) SpawnMonsters(c *entity.Player, isfrist bool) {
 	}
 
 	// 创建数据包
-	tt := handler.NewTomeeHeader(2004, c.UserID)
+	tt := handler.NewTomeeHeader(2004, c.Info.UserID)
 
 	if isfrist {
 		t.monsters = generateThreeUniqueNumbers()
@@ -60,7 +60,7 @@ func (t *InInfo) SpawnMonsters(c *entity.Player, isfrist bool) {
 
 		t.monsters, _, _ = replaceOneNumber(t.monsters)
 	}
-	t1 := t.genMonster(c.MapId)
+	t1 := t.genMonster(c.Info.UserID)
 
 	c.SendPack(tt.Pack(&t1))
 }

logic/service/maps/mapout.go

@@ -1,7 +1,7 @@
 package maps
 
 import (
-	"blazing/common/data/entity"
+	"blazing/common/data/socket"
 	"blazing/common/socket/handler"
 	"blazing/logic/service/space"
 )
@@ -17,7 +17,7 @@ type LeaveMapInboundInfo struct {
 
 func (t *LeaveMapInboundInfo) Broadcast(mapid uint32, o LeaveMapOutboundInfo) {
 
-	space.GetSpace(mapid).Range(func(playerID uint32, player *entity.Player) bool {
+	space.GetSpace(mapid).Range(func(playerID uint32, player *socket.Player) bool {
 		t.Head.Result = 0
 
 		player.SendPack(t.Head.Pack(&o))

logic/service/nono/nono.go

@@ -0,0 +1,62 @@
+package nono
+
+import "blazing/common/socket/handler"
+
+// NonoOutboundInfo 用于表示Nono相关的出站信息
+type NonoOutboundInfo struct {
+	// UserID: 米米号，对应uint32类型，无符号
+	UserID uint32
+
+	// Num: 未知，对应uint32类型，无符号
+	Num uint32
+
+	// Flying: 飞行状态 0为不飞行 大于0为飞行模式，对应uint32类型，无符号
+	Flying uint32
+
+	// Nick: 16字节，固定长度16字节字符串
+	Nick string `struc:"[16]byte"`
+
+	// SuperNono: 是不是超能nono，对应uint32类型，无符号
+	SuperNono uint32
+
+	// Color: nono颜色 00 rgb，对应uint32类型，无符号
+	Color uint32
+
+	// Power: 未知, 返回的实际数值要*1000，对应uint32类型，无符号
+	Power uint32
+
+	// Mate: 未知, 返回的实际数值要*1000，对应uint32类型，无符号
+	Mate uint32
+
+	// IQ: 未知，对应uint32类型，无符号
+	IQ uint32
+
+	// AI: 未知，对应uint16类型，无符号短整数
+	AI uint16
+
+	// Birth: 未知, 返回的实际数值要除以1000，对应uint32类型，无符号
+	Birth uint32
+
+	// ChargeTime: 充电时间，对应uint32类型，无符号
+	ChargeTime uint32
+
+	// Func: 20字节，固定长度20字节数组
+	Func [20]byte
+
+	// SuperEnergy: 超能nono能力，对应uint32类型，无符号
+	SuperEnergy uint32
+
+	// SuperLevel: 超能nono等级，对应uint32类型，无符号
+	SuperLevel uint32
+
+	// SuperStage: 超能nono阶段，对应uint32类型，无符号
+	SuperStage uint32
+}
+
+type NonoInboundInfo struct {
+	// 消息头部，命令ID对应MessageCommandIDRegistry.Nono_Info
+	Head handler.TomeeHeader `cmd:"9003" struc:"[0]pad"`
+
+	// 米米号，对应Java的@UInt long类型
+	UserID uint32 `fieldDescription:"米米号" struc:"uint32" uint:"true"`
+}

logic/service/service.go

@@ -1,22 +1,22 @@
 package service
 
 import (
-	"blazing/common/data/entity"
+	"blazing/common/data/socket"
 	"blazing/common/socket/errorcode"
 	"blazing/common/socket/handler"
-	"blazing/cool"
+	"blazing/modules/blazing/model"
 )
 
-func GetPlayer(c *entity.Conn, userid uint32) *entity.Player { //TODO 这里待优化,可能存在内存泄漏问题
+func GetPlayer(c *socket.Conn, userid uint32) *socket.Player { //TODO 这里待优化,可能存在内存泄漏问题
 
 	//检查player初始化，是否为conn初始后取map，防止二次连接后存在两个player
 
-	clientdata := c.MainConn.Context().(*entity.ClientData)
+	clientdata := c.MainConn.Context().(*socket.ClientData)
 	if clientdata.GetPlayer() != nil {
 		return clientdata.GetPlayer()
 	}
-	var player *entity.Player
-	if player1, ok := cool.Mainplayer.Load((userid)); ok {
+	var player *socket.Player
+	if player1, ok := socket.Mainplayer.Load((userid)); ok {
 
 		clientdata.SetPlayer(player1)
 	}
@@ -27,7 +27,7 @@ func GetPlayer(c *entity.Conn, userid uint32) *entity.Player { //TODO 这里待
 func KickPlayer(userid uint32) { //踢出玩家
 	//TODO 返回错误码
 	//var player *entity.Player
-	if player1, ok := cool.Mainplayer.Load((userid)); ok {
+	if player1, ok := socket.Mainplayer.Load((userid)); ok {
 		//取成功,否则创建
 		head := handler.NewTomeeHeader(1001, userid)
 		head.Result = uint32(errorcode.ErrorCodes.ErrAccountLoggedInElsewhere)
@@ -40,27 +40,19 @@ func KickPlayer(userid uint32) { //踢出玩家
 	//return player
 	//	return nil
 }
-func SetPlayer(c *entity.Conn, userid uint32) *entity.Player { //TODO 这里待优化,
+func SetPlayer(c *socket.Conn, user *model.PlayerInfo) *socket.Player { //TODO 这里待优化,
 
-	clientdata := c.MainConn.Context().(*entity.ClientData)
+	clientdata := c.MainConn.Context().(*socket.ClientData)
 
-	player := entity.NewPlayer(
-		entity.WithUserID(userid), //注入ID
-		entity.WithConn(*c),       //注入conn
+	player := socket.NewPlayer(
+	
+
+		socket.WithConn(*c), //注入conn
 	)
-	cool.Mainplayer.Store(userid, player)
+	socket.Mainplayer.Store(user.UserID, player)
 
 	clientdata.SetPlayer(player) //= player
 
 	return player
 	//	return nil
 }
-
-// /**
-//  * @var		type	OutboundInf
-//  * @global
-//  */
-// type OutInfo interface {
-// 	error                      //实现错误接口
-// 	Code() errorcode.ErrorCode //返回错误码,如果error不等于nil就返回这个实现对前台传错误码
-// }

logic/service/space/space.go

@@ -1,7 +1,7 @@
 package space
 
 import (
-	"blazing/common/data/entity"
+	"blazing/common/data/socket"
 	xml "blazing/common/data/xml/map"
 	"blazing/common/utils"
 	"blazing/modules/blazing/model"
@@ -11,7 +11,7 @@ import (
 // Space 针对Player的并发安全map，键为uint32类型
 type Space struct {
 	mu         sync.RWMutex              // 读写锁，读多写少场景更高效
-	data       map[uint32]*entity.Player // 存储玩家数据的map，键为玩家ID
+	data       map[uint32]*socket.Player // 存储玩家数据的map，键为玩家ID
 	CanRefresh bool                      //是否能够刷怪
 	ID         uint32                    // 地图ID
 	Name       string                    //地图名称
@@ -22,13 +22,13 @@ type Space struct {
 // NewSyncMap 创建一个新的玩家同步map
 func NewSpace() *Space {
 	return &Space{
-		data: make(map[uint32]*entity.Player),
+		data: make(map[uint32]*socket.Player),
 	}
 }
 
 // Get 根据玩家ID获取玩家实例
 // 读操作使用RLock，允许多个goroutine同时读取
-func (m *Space) Get(playerID uint32) (*entity.Player, bool) {
+func (m *Space) Get(playerID uint32) (*socket.Player, bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	val, exists := m.data[playerID]
@@ -37,10 +37,12 @@ func (m *Space) Get(playerID uint32) (*entity.Player, bool) {
 
 // Set 存储玩家实例（按ID）
 // 写操作使用Lock，独占锁保证数据一致性
-func (m *Space) Set(playerID uint32, player *entity.Player) {
+func (m *Space) Set(playerID uint32, player *socket.Player)*Space {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.data[playerID] = player
+
+	return m
 }
 
 // Delete 根据玩家ID删除玩家实例
@@ -61,7 +63,7 @@ func (m *Space) Len() int {
 
 // Range 遍历所有玩家并执行回调函数
 // 读操作使用RLock，遍历过程中不会阻塞其他读操作
-func (m *Space) Range(f func(playerID uint32, player *entity.Player) bool) {
+func (m *Space) Range(f func(playerID uint32, player *socket.Player) bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	for id, player := range m.data {

logic/service/space/walk.go

@@ -1,7 +1,7 @@
 package space
 
 import (
-	"blazing/common/data/entity"
+	"blazing/common/data/socket"
 	"blazing/common/socket/handler"
 	"blazing/modules/blazing/model"
 )
@@ -23,7 +23,7 @@ func (t *InInfo) Broadcast(mapid uint32, o OutInfo) {
 	//tt := planetmap
 	//g.Dump(GetSpace(mapid).Len())
 
-	GetSpace(mapid).Range(func(playerID uint32, player *entity.Player) bool {
+	GetSpace(mapid).Range(func(playerID uint32, player *socket.Player) bool {
 		t.Head.Result = 0
 		tt := t.Head.Pack(&o)
 		err := player.SendPack(tt)