```

refactor(common/rpc): 移除Redis PubSub心跳机制并优化连接管理

移除Redis PubSub连接的心跳保活功能，因为PubSub连接只应负责订阅和接收，
避免在同一连接上并发执行PING操作。更新了ListenFunc和ListenFight函数，
统一代码结构，移除了context包依赖，并添加了相关注释说明。

feat(logic/pet): 新增宠物技能提交功能

新增CommitPetSkills接口用于一次性提交宠物技能学习/替换/排序结果。
实现技能验证、费用计算和状态更新逻辑，包括新技能学习成本和排序费用。
添加isSameUint32Slice辅助函数用于比较技能数组。
```

common/rpc/func.go

@@ -5,7 +5,6 @@ import (
 	"blazing/logic/service/fight/pvp"
 	"blazing/logic/service/fight/pvpwire"
 
-	"context"
 	"fmt"
 	"time"
 
@@ -16,7 +15,8 @@ import (
 )
 
 // ListenFunc 监听函数
-// ListenFunc 改造后的 Redis PubSub 监听函数，支持自动重连和心跳保活
+// ListenFunc 改造后的 Redis PubSub 监听函数，支持自动重连。
+// 注意：PubSub 连接只负责订阅和接收，避免在同一连接上并发 PING。
 func ListenFunc(ctx g.Ctx) {
 	if !cool.IsRedisMode {
 		panic(gerror.New("集群模式下, 请使用Redis作为缓存"))
@@ -24,9 +24,8 @@ func ListenFunc(ctx g.Ctx) {
 
 	// 定义常量配置
 	const (
-		subscribeTopic    = "cool:func"      // 订阅的主题
-		retryDelay        = 10 * time.Second // 连接失败重试间隔
-		heartbeatInterval = 30 * time.Second // 心跳保活间隔
+		subscribeTopic = "cool:func"      // 订阅的主题
+		retryDelay     = 10 * time.Second // 连接失败重试间隔
 	)
 
 	// 外层循环：负责连接断开后的整体重连
@@ -47,47 +46,25 @@ func ListenFunc(ctx g.Ctx) {
 			continue
 		}
 
-		// 2. 启动心跳保活协程，防止连接因空闲被断开
-		heartbeatCtx, heartbeatCancel := context.WithCancel(context.Background())
-		go func() {
-			ticker := time.NewTicker(heartbeatInterval)
-			defer func() {
-				ticker.Stop()
-				heartbeatCancel()
-			}()
-
-			for {
-				select {
-				case <-heartbeatCtx.Done():
-					cool.Logger.Info(ctx, "心跳协程退出")
-					return
-				case <-ticker.C:
-					// 发送 PING 心跳，保持连接活跃
-					_, pingErr := conn.Do(ctx, "PING")
-					if pingErr != nil {
-						cool.Logger.Error(ctx, "Redis 心跳失败，触发重连", "error", pingErr)
-						// 心跳失败时主动关闭连接，触发外层重连
-						_ = conn.Close(ctx)
-						return
-					}
-
-				}
-			}
-		}()
-
-		// 3. 订阅主题
+		// 2. 订阅主题
 		_, err = conn.Do(ctx, "subscribe", subscribeTopic)
 		if err != nil {
 			cool.Logger.Error(ctx, "订阅 Redis 主题失败", "topic", subscribeTopic, "error", err)
-			heartbeatCancel() // 关闭心跳协程
 			_ = conn.Close(ctx)
 			time.Sleep(retryDelay)
 			continue
 		}
 		cool.Logger.Info(ctx, "成功订阅 Redis 主题", "topic", subscribeTopic)
 		_, err = conn.Do(ctx, "subscribe", "sun:join") //加入队列
+		if err != nil {
+			cool.Logger.Error(ctx, "订阅 Redis 主题失败", "topic", "sun:join", "error", err)
+			_ = conn.Close(ctx)
+			time.Sleep(retryDelay)
+			continue
+		}
+		cool.Logger.Info(ctx, "成功订阅 Redis 主题", "topic", "sun:join")
 
-		// 4. 循环接收消息
+		// 3. 循环接收消息
 		connError := false
 		for !connError {
 			select {
@@ -130,15 +107,15 @@ func ListenFunc(ctx g.Ctx) {
 			}
 		}
 
-		// 5. 清理资源，准备重连
-		heartbeatCancel()   // 关闭心跳协程
+		// 4. 清理资源，准备重连
 		_ = conn.Close(ctx) // 关闭当前连接
-		//	Logger.Warn(ctx, "Redis 连接异常，准备重连", "retry_after", retryDelay)
+		cool.Logger.Info(ctx, "Redis 订阅连接异常，准备重连", "retry_after", retryDelay)
 		time.Sleep(retryDelay)
 	}
 }
 
-// ListenFight 完全对齐 ListenFunc 写法，修复收不到消息问题
+// ListenFight 完全对齐 ListenFunc 写法，修复收不到消息问题。
+// 注意：PubSub 连接只负责订阅和接收，避免在同一连接上并发 PING。
 func ListenFight(ctx g.Ctx) {
 	if !cool.IsRedisMode {
 		panic(gerror.New("集群模式下, 请使用Redis作为缓存"))
@@ -146,8 +123,7 @@ func ListenFight(ctx g.Ctx) {
 
 	// 定义常量配置（对齐 ListenFunc 风格）
 	const (
-		retryDelay        = 10 * time.Second // 连接失败重试间隔
-		heartbeatInterval = 30 * time.Second // 心跳保活间隔
+		retryDelay = 10 * time.Second // 连接失败重试间隔
 	)
 
 	// 提前拼接订阅主题（避免重复拼接，便于日志打印）
@@ -176,35 +152,7 @@ func ListenFight(ctx g.Ctx) {
 			continue
 		}
 
-		// 2. 启动心跳保活协程（完全对齐 ListenFunc 逻辑）
-		heartbeatCtx, heartbeatCancel := context.WithCancel(context.Background())
-		go func() {
-			ticker := time.NewTicker(heartbeatInterval)
-			defer func() {
-				ticker.Stop()
-				heartbeatCancel()
-			}()
-
-			for {
-				select {
-				case <-heartbeatCtx.Done():
-					cool.Logger.Info(ctx, "心跳协程退出")
-					return
-				case <-ticker.C:
-					// 发送 PING 心跳，保持连接活跃
-					_, pingErr := conn.Do(ctx, "PING")
-					if pingErr != nil {
-						cool.Logger.Error(ctx, "Redis 心跳失败，触发重连", "error", pingErr)
-						// 心跳失败时主动关闭连接，触发外层重连
-						_ = conn.Close(ctx)
-						return
-					}
-					cool.Logger.Debug(ctx, "Redis 心跳发送成功，连接正常")
-				}
-			}
-		}()
-
-		// 3. 订阅主题（对齐 ListenFunc 的错误处理，替换 panic 为优雅重连）
+		// 2. 订阅主题（对齐 ListenFunc 的错误处理，替换 panic 为优雅重连）
 		subscribeTopics := []string{startTopic, pvpServerTopic}
 		if cool.Config.GameOnlineID == pvp.CoordinatorOnlineID {
 			subscribeTopics = append(subscribeTopics, pvpCoordinatorTopic)
@@ -214,7 +162,6 @@ func ListenFight(ctx g.Ctx) {
 			_, err = conn.Do(ctx, "subscribe", topic)
 			if err != nil {
 				cool.Logger.Error(ctx, "订阅 Redis 主题失败", "topic", topic, "error", err)
-				heartbeatCancel()
 				_ = conn.Close(ctx)
 				time.Sleep(retryDelay)
 				subscribeFailed = true
@@ -240,7 +187,7 @@ func ListenFight(ctx g.Ctx) {
 		// 打印监听提示（保留原有日志）
 		fmt.Println("监听战斗", startTopic)
 
-		// 4. 循环接收消息（完全对齐 ListenFunc 逻辑）
+		// 3. 循环接收消息（完全对齐 ListenFunc 逻辑）
 		connError := false
 		for !connError {
 			select {
@@ -282,9 +229,9 @@ func ListenFight(ctx g.Ctx) {
 			}
 		}
 
-		// 5. 清理资源，准备重连（完全对齐 ListenFunc）
-		heartbeatCancel()   // 关闭心跳协程
+		// 4. 清理资源，准备重连（完全对齐 ListenFunc）
 		_ = conn.Close(ctx) // 关闭当前连接
+		cool.Logger.Info(ctx, "Redis 战斗订阅连接异常，准备重连", "retry_after", retryDelay)
 		time.Sleep(retryDelay)
 	}
 }