```

feat: 添加ItemInfo结构体并重构抽蛋和任务系统 - 在common/data/color.go中添加ItemInfo结构体用于表示发放物品的信息 - 在common/utils/tomap.go中添加RandomSlice泛型函数用于从切片中随机选取元素 - 重构action_egg.go中的EggGamePlay功能，实现抽蛋逻辑和物品发放 - 更新fight_boss.go中使用新的ItemInfo结构体替换旧的model.ItemInfo - 修改user_talk.go中获取物品数量的逻辑 - 更新user_task.go中任务完成逻辑使用新的ItemInfo结构体 - 在egg.go中更新抽蛋结果结构体使用ItemInfo - 更新战斗奖励结构体使用ItemInfo - 在player.go中添加学习力道具处理逻辑 - 重构任务系统使用新的ItemInfo结构体 - 移除旧的model.ItemInfo定义 - 更新宠物奖励配置模型添加成长值等字段 - 实现GetEgg方法用于获取扭蛋奖励 - 修复宠物融合材料服务中的道具验证逻辑 ```
2025-12-26 20:38:08 +08:00
parent b8d6772256
commit c9bc4be244
18 changed files with 242 additions and 134 deletions
--- a/common/data/color.go
+++ b/common/data/color.go
@@ -48,3 +48,10 @@ type GlowFilter struct {
 	Knockout          bool        `json:"knockout,omitempty"`
 	ColorMatrixFilter [20]float32 `json:"matrix,omitempty"`
 }
+
+// ItemInfo
+// 用于表示发放物品的信息
+type ItemInfo struct {
+	ItemId  uint32 `json:"itemId" description:"发放物品ID"`     // 发放物品ID，
+	ItemCnt uint32 `json:"itemCount" description:"发放物品的数量"` // 发放物品的数量，
+}
--- a/common/utils/tomap.go
+++ b/common/utils/tomap.go
@@ -1,5 +1,7 @@
 package utils

+import "github.com/gogf/gf/v2/util/grand"
+
 // ToMap converts a slice to a map with the keyFunc determining what the key of a value should be.
 // Will override any double values.
 func ToMap[T any, K comparable](slice []T, keyFunc func(T) K) map[K]T {
@@ -35,6 +37,7 @@ func Max[T Number](a, b T) T {
 	}
 	return b
 }
+
 // Max 泛型函数：接收两个同类型的 Number 参数，返回最大值
 func Min[T Number](a, b T) T {
 	if a < b {
@@ -42,3 +45,42 @@ func Min[T Number](a, b T) T {
 	}
 	return b
 }
+
+// RandomSlice 泛型函数：从任意类型的切片中随机选取n个不重复元素
+// T: 泛型类型参数，any表示兼容任意类型
+// slice: 源切片（任意类型）
+// n: 要选取的元素数量
+// 返回值: 与源切片同类型的新切片，包含随机选取的n个元素
+func RandomSlice[T any](slice []T, n int) []T {
+	// 边界条件1：n≤0 或 源切片为空 → 返回空切片
+	if n <= 0 || len(slice) == 0 {
+		return []T{}
+	}
+
+	// 边界条件2：n≥源切片长度 → 返回源切片的拷贝（避免修改原切片）
+	if n >= len(slice) {
+		copySlice := make([]T, len(slice))
+		copy(copySlice, slice)
+		return copySlice
+	}
+
+	// 步骤1：生成源切片的索引切片
+	indices := make([]int, len(slice))
+	for i := range indices {
+		indices[i] = i
+	}
+
+	// 步骤2：Fisher-Yates洗牌算法打乱索引（保证随机性均匀）
+	for i := len(indices) - 1; i > 0; i-- {
+		j := grand.Intn(i + 1) // 生成0~i的随机数
+		indices[i], indices[j] = indices[j], indices[i]
+	}
+
+	// 步骤3：取前n个打乱后的索引，映射为源切片的元素
+	result := make([]T, n)
+	for i := 0; i < n; i++ {
+		result[i] = slice[indices[i]]
+	}
+
+	return result
+}
--- a/logic/controller/action_egg.go
+++ b/logic/controller/action_egg.go
@@ -1,17 +1,44 @@
 package controller

 import (
+	"blazing/common/data"
 	"blazing/common/socket/errorcode"
 	"blazing/logic/service/egg"
 	"blazing/logic/service/player"
 	"blazing/modules/blazing/model"
+	"blazing/modules/config/service"
+
+	"github.com/gogf/gf/v2/util/grand"
 )

-func (h Controller) EggGamePlay(data *egg.C2S_EGG_GAME_PLAY, c *player.Player) (result *egg.S2C_EGG_GAME_PLAY, err errorcode.ErrorCode) {
-	newPet := model.GenPetInfo(1, -1, -1, -1, 1, nil)
-	c.Service.Pet.PetAdd(newPet)
-	result = &egg.S2C_EGG_GAME_PLAY{HadTime: newPet.CatchTime, ListInfo: []model.ItemInfo{}, PetID: newPet.ID}
+func (h Controller) EggGamePlay(data1 *egg.C2S_EGG_GAME_PLAY, c *player.Player) (result *egg.S2C_EGG_GAME_PLAY, err errorcode.ErrorCode) {

+	switch data1.EggNum {
+	case 2:
+		data1.EggNum = 5
+
+	case 3:
+		data1.EggNum = 10
+	}
+	result = &egg.S2C_EGG_GAME_PLAY{ListInfo: []data.ItemInfo{}}
+	if grand.Meet(int(data1.EggNum), 100) {
+		r := service.NewPetRewardService().GetEgg()
+		newPet := model.GenPetInfo(int(r.MonID), int(r.DV), int(r.Nature), int(r.Effect), int(r.Lv), nil)
+		c.Service.Pet.PetAdd(newPet)
+		result.HadTime = newPet.CatchTime
+		result.PetID = newPet.ID
+	}
+
+	items := service.NewItemService().GetEgg(data1.EggNum)
+	for _, item := range items {
+		if item.ItemId == 0 {
+			continue
+		}
+		c.ItemAdd(item.ItemId, item.ItemCnt)
+		result.ListInfo = append(result.ListInfo, data.ItemInfo{ItemId: item.ItemId, ItemCnt: item.ItemCnt})
+	}
+
+	c.Service.Item.UPDATE(400501, int(-data1.EggNum))
 	return

 }
--- a/logic/controller/fight_boss.go
+++ b/logic/controller/fight_boss.go
@@ -1,6 +1,7 @@
 package controller

 import (
+	"blazing/common/data"
 	"blazing/common/data/xmlres"
 	"blazing/common/socket/errorcode"
 	"strings"
@@ -160,11 +161,11 @@ func (h Controller) PlayerFightBoss(data *fight.ChallengeBossInboundInfo, p *pla
 // data: 包含战斗野怪信息的输入数据
 // player: 当前玩家对象
 // 返回: 战斗结果和错误码
-func (h Controller) OnPlayerFightNpcMonster(data *fight.FightNpcMonsterInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
+func (h Controller) OnPlayerFightNpcMonster(data1 *fight.FightNpcMonsterInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
 	if !p.CanFight() {
 		return nil, errorcode.ErrorCodes.ErrSystemError
 	}
-	refPet := p.OgreInfo.Data[data.Number]
+	refPet := p.OgreInfo.Data[data1.Number]
 	if refPet.Id == 0 {

 		return nil, errorcode.ErrorCodes.ErrPokemonNotExists
@@ -203,7 +204,7 @@ func (h Controller) OnPlayerFightNpcMonster(data *fight.FightNpcMonsterInboundIn
 			}
 			if refPet.Item != 0 {
 				p.ItemAdd(refPet.Item, uint32(grand.Intn(2)+1))
-				items.ItemList = append(items.ItemList, model.ItemInfo{
+				items.ItemList = append(items.ItemList, data.ItemInfo{
 					ItemId:  refPet.Item,
 					ItemCnt: uint32(grand.Intn(2) + 1),
 				})
--- a/logic/controller/user_talk.go
+++ b/logic/controller/user_talk.go
@@ -34,15 +34,13 @@ func (h Controller) GetTalkCategory(data *item.TalkCateInboundInfo, c *player.Pl
 	//service.NewItemService().GetItemCount(config.ItemID)

 	for _, itemID := range config.ItemIDS {
-		itemCount := service.NewItemService().GetItemCount(itemID)
-		success := c.ItemAdd(uint32(itemID), uint32(itemCount))
+		iteminfo := service.NewItemService().GetItemCount(itemID)
+		success := c.ItemAdd(uint32(iteminfo.ItemId), uint32(iteminfo.ItemCnt))
 		if success {
-			result.OutList = append(result.OutList, item.CateInfo{ID: itemID, Count: uint32(itemCount)})
+			result.OutList = append(result.OutList, item.CateInfo{ID: iteminfo.ItemId, Count: uint32(iteminfo.ItemCnt)})

 		}
 	}
-
 	c.Service.Talk.Update(int(data.ID))
-
 	return result, 0
 }
--- a/logic/controller/user_task.go
+++ b/logic/controller/user_task.go
@@ -1,6 +1,7 @@
 package controller

 import (
+	"blazing/common/data"
 	"blazing/common/socket/errorcode"

 	"blazing/logic/service/player"
@@ -46,19 +47,19 @@ func (h Controller) AddTaskBuf(data *task.AddTaskBufInboundInfo, c *player.Playe
 // data: 包含任务ID的输入信息
 // c: 当前玩家对象
 // 返回: 任务完成结果和错误码
-func (h Controller) CompleteTask(data *task.CompleteTaskInboundInfo, c *player.Player) (result *task.CompleteTaskOutboundInfo, err errorcode.ErrorCode) {
-	if c.Info.GetTask(int(data.TaskId)) != model.Accepted {
+func (h Controller) CompleteTask(data1 *task.CompleteTaskInboundInfo, c *player.Player) (result *task.CompleteTaskOutboundInfo, err errorcode.ErrorCode) {
+	if c.Info.GetTask(int(data1.TaskId)) != model.Accepted {
 		return result, 0
 	}

-	c.Info.SetTask(int(data.TaskId), model.Completed)
+	c.Info.SetTask(int(data1.TaskId), model.Completed)

 	result = &task.CompleteTaskOutboundInfo{
-		TaskId:   data.TaskId,
-		ItemList: make([]model.ItemInfo, 0),
+		TaskId:   data1.TaskId,
+		ItemList: make([]data.ItemInfo, 0),
 	}

-	taskInfo := task.Get_Task_Info(*data)
+	taskInfo := task.Get_Task_Info(*data1)
 	if taskInfo == nil {
 		return result, 0
 	}
--- a/logic/service/egg/egg.go
+++ b/logic/service/egg/egg.go
@@ -1,8 +1,8 @@
 package egg

 import (
+	"blazing/common/data"
 	"blazing/logic/service/common"
-	"blazing/modules/blazing/model"
 )

 // C2S_EGG_GAME_PLAY 前端向后端发送的抽蛋请求结构体
@@ -16,9 +16,9 @@ type C2S_EGG_GAME_PLAY struct {
 // S2C_EGG_GAME_PLAY 后端向前端返回的抽蛋结果结构体
 // 对应原 C# 的 S2C_EGG_GAME_PLAY
 type S2C_EGG_GAME_PLAY struct {
-	GiftIN      uint32           `json:"giftIN"`  // 未知字段 写0 未引用
-	PetID       uint32           `json:"petID"`   // 抽中精灵的id
-	HadTime     uint32           `json:"hadTime"` // 抽中精灵的捕捉时间（若为时间戳，建议改为 uint64）
-	ListInfoLen uint32           `struc:"sizeof=ListInfo"`
-	ListInfo    []model.ItemInfo `json:"listinfo"` // 抽中物品的物品数组
+	GiftIN      uint32          `json:"giftIN"`  // 未知字段 写0 未引用
+	PetID       uint32          `json:"petID"`   // 抽中精灵的id
+	HadTime     uint32          `json:"hadTime"` // 抽中精灵的捕捉时间（若为时间戳，建议改为 uint64）
+	ListInfoLen uint32          `struc:"sizeof=ListInfo"`
+	ListInfo    []data.ItemInfo `json:"listinfo"` // 抽中物品的物品数组
 }
--- a/logic/service/fight/info/over.go
+++ b/logic/service/fight/info/over.go
@@ -1,15 +1,15 @@
 package info

-import "blazing/modules/blazing/model"
+import "blazing/common/data"

 type S2C_GET_BOSS_MONSTER struct {
-	BonusID     uint32           // 激活前端任务的ID
-	EXP         uint32           `json:"exp" description:"奖励经验"`
-	EV          uint32           `json:"ev" description:"奖励累计学习力"`
-	PetID       uint32           // 发放精灵的ID
-	CaptureTm   uint32           // 发放精灵的捕获时间
-	ItemListLen uint32           `struc:"sizeof=ItemList"`
-	ItemList    []model.ItemInfo // 发放物品的数组：
+	BonusID     uint32          // 激活前端任务的ID
+	EXP         uint32          `json:"exp" description:"奖励经验"`
+	EV          uint32          `json:"ev" description:"奖励累计学习力"`
+	PetID       uint32          // 发放精灵的ID
+	CaptureTm   uint32          // 发放精灵的捕获时间
+	ItemListLen uint32          `struc:"sizeof=ItemList"`
+	ItemList    []data.ItemInfo // 发放物品的数组：
 	// 特殊说明：
 	// 1. 仅发放精灵不发放物品时：ItemList 无需填充元素，但序列化时需先写入 uint 类型的长度（值为0）
 	// 2. 发放多个物品时：序列化时先写入 uint 类型的数组长度，再依次写入每个ItemInfo元素
--- a/logic/service/player/player.go
+++ b/logic/service/player/player.go
@@ -204,6 +204,8 @@ func (p *Player) ItemAdd(ItemId, ItemCnt uint32) (result bool) {
 	case 5: //金豆ItemAdd
 		p.User.UpdateGold(p.Info.UserID, int64(ItemCnt*100))
 		return true
+	case 9: //学习力
+		p.Info.EVPool = p.Info.EVPool + ItemCnt

 	default:
 		itemx, ok := xmlres.ItemsMAP[int(ItemId)]
--- a/logic/service/task/CompleteTask.go
+++ b/logic/service/task/CompleteTask.go
@@ -1,8 +1,8 @@
 package task

 import (
+	"blazing/common/data"
 	"blazing/logic/service/common"
-	"blazing/modules/blazing/model"
 )

 type CompleteTaskInboundInfo struct {
@@ -11,9 +11,9 @@ type CompleteTaskInboundInfo struct {
 	OutState uint32             `json:"outState" `                 // 当前状态，1表示完成任务，
 }
 type CompleteTaskOutboundInfo struct {
-	TaskId      uint32           `json:"taskId" description:"任务ID"`           // 任务ID，
-	PetTypeId   uint32           `json:"petTypeId" description:"发放的精灵ID"`     // 发放的精灵ID，
-	CaptureTime uint32           `json:"captureTime" description:"发放的精灵捕获时间"` // 发放的精灵捕获时间，
-	ItemLen     uint32           `struc:"sizeof=ItemList"`
-	ItemList    []model.ItemInfo `json:"itemList" description:"发放物品的数组"` // 发放物品的数组，
+	TaskId      uint32          `json:"taskId" description:"任务ID"`           // 任务ID，
+	PetTypeId   uint32          `json:"petTypeId" description:"发放的精灵ID"`     // 发放的精灵ID，
+	CaptureTime uint32          `json:"captureTime" description:"发放的精灵捕获时间"` // 发放的精灵捕获时间，
+	ItemLen     uint32          `struc:"sizeof=ItemList"`
+	ItemList    []data.ItemInfo `json:"itemList" description:"发放物品的数组"` // 发放物品的数组，
 }
--- a/logic/service/task/list.go
+++ b/logic/service/task/list.go
@@ -1,13 +1,13 @@
 package task

 import (
-	"blazing/modules/blazing/model"
+	"blazing/common/data"
 	"sync"
 )

 // RegisterTask 注册任务奖励
 // 参数：任务ID、分支(OutState)、物品列表、精灵类型(0=无)
-func RegisterTask(taskID uint32, outState uint32, items []model.ItemInfo, petType uint32) {
+func RegisterTask(taskID uint32, outState uint32, items []data.ItemInfo, petType uint32) {
 	if _, ok := TaskResultMap[taskID]; !ok {
 		TaskResultMap[taskID] = make(map[uint32]TaskResult)
 	}
@@ -19,24 +19,24 @@ func RegisterTask(taskID uint32, outState uint32, items []model.ItemInfo, petTyp

 func init() {
 	// -------------------------- 新手任务 --------------------------
-	RegisterTask(85, 1, []model.ItemInfo{ // 新手任务1（默认分支1）
+	RegisterTask(85, 1, []data.ItemInfo{ // 新手任务1（默认分支1）
 		{100027, 1}, // 新手帽
 		{100028, 1}, // 新手腰带
 		{500001, 1}, // 精灵仓库
 		{500502, 1}, // 精灵恢复仓
 	}, 0)

-	RegisterTask(86, 1, []model.ItemInfo{}, 1) // 新手任务2（分支1：布布种子）
-	RegisterTask(86, 2, []model.ItemInfo{}, 7) // 新手任务2（分支2：小火猴）
-	RegisterTask(86, 3, []model.ItemInfo{}, 4) // 新手任务2（分支3：伊优）
-	RegisterTask(86, 0, []model.ItemInfo{}, 1) // 新手任务2（默认分支：布布种子）
+	RegisterTask(86, 1, []data.ItemInfo{}, 1) // 新手任务2（分支1：布布种子）
+	RegisterTask(86, 2, []data.ItemInfo{}, 7) // 新手任务2（分支2：小火猴）
+	RegisterTask(86, 3, []data.ItemInfo{}, 4) // 新手任务2（分支3：伊优）
+	RegisterTask(86, 0, []data.ItemInfo{}, 1) // 新手任务2（默认分支：布布种子）

-	RegisterTask(87, 0, []model.ItemInfo{ // 新手任务3（默认分支）
+	RegisterTask(87, 0, []data.ItemInfo{ // 新手任务3（默认分支）
 		{300001, 5}, // 普通胶囊x5
 		{300011, 3}, // 初级体力药剂x3
 	}, 0)

-	RegisterTask(88, 1, []model.ItemInfo{ // 新手任务4（默认分支）
+	RegisterTask(88, 1, []data.ItemInfo{ // 新手任务4（默认分支）
 		{1, 50000},  // 赛尔豆x50000
 		{3, 50000},  // 累积经验x50000
 		{5, 20},     // 金豆x20
@@ -45,19 +45,19 @@ func init() {
 	}, 0)

 	// -------------------------- 普通任务（无精灵奖励） --------------------------
-	RegisterTask(90, 0, []model.ItemInfo{ // 克洛斯星的皮皮
+	RegisterTask(90, 0, []data.ItemInfo{ // 克洛斯星的皮皮
 		{1, 1000}, // 赛尔豆x1000
 		{3, 1000}, // 经验x1000
 	}, 0)

-	RegisterTask(8, 0, []model.ItemInfo{{500510, 1}}, 0)   // 西塔的珍贵回忆（记忆晶体x1）
-	RegisterTask(9, 0, []model.ItemInfo{{100059, 1}}, 0)   // 进入神秘通道（电能锯子x1）
-	RegisterTask(10, 0, []model.ItemInfo{}, 0)             // 神秘通道拼图（无奖励）
-	RegisterTask(12, 0, []model.ItemInfo{}, 0)             // 精灵广场拿石头（无奖励）
-	RegisterTask(19, 0, []model.ItemInfo{{3, 3000}}, 0)    // 先锋队招募（积累经验x3000）
-	RegisterTask(25, 0, []model.ItemInfo{{400501, 10}}, 0) // 新船员的考验（神奇扭蛋牌x10）
+	RegisterTask(8, 0, []data.ItemInfo{{500510, 1}}, 0)   // 西塔的珍贵回忆（记忆晶体x1）
+	RegisterTask(9, 0, []data.ItemInfo{{100059, 1}}, 0)   // 进入神秘通道（电能锯子x1）
+	RegisterTask(10, 0, []data.ItemInfo{}, 0)             // 神秘通道拼图（无奖励）
+	RegisterTask(12, 0, []data.ItemInfo{}, 0)             // 精灵广场拿石头（无奖励）
+	RegisterTask(19, 0, []data.ItemInfo{{3, 3000}}, 0)    // 先锋队招募（积累经验x3000）
+	RegisterTask(25, 0, []data.ItemInfo{{400501, 10}}, 0) // 新船员的考验（神奇扭蛋牌x10）

-	RegisterTask(37, 0, []model.ItemInfo{ // 帕诺星系星球测绘
+	RegisterTask(37, 0, []data.ItemInfo{ // 帕诺星系星球测绘
 		{1, 3000}, // 赛尔豆x3000

 		{100178, 1}, // 勘察头盔x1
@@ -66,182 +66,182 @@ func init() {
 		{100181, 1}, // 勘察军靴x1
 	}, 0)

-	RegisterTask(47, 0, []model.ItemInfo{ // 突围磁风暴
+	RegisterTask(47, 0, []data.ItemInfo{ // 突围磁风暴
 		{3, 5000},   // 累积经验x5000
 		{1, 5000},   // 赛尔豆x5000
 		{500585, 1}, // 磁力光束枪台x1
 	}, 0)

-	RegisterTask(48, 0, []model.ItemInfo{ // 神秘失踪的爱丽丝
+	RegisterTask(48, 0, []data.ItemInfo{ // 神秘失踪的爱丽丝
 		{3, 3000}, // 累积经验x3000
 		{1, 2000}, // 赛尔豆x2000
 		//{700452, 2}, // 中型智慧芯片x2
 	}, 0)

-	RegisterTask(52, 0, []model.ItemInfo{ // 谁偷走了雪球能源？
+	RegisterTask(52, 0, []data.ItemInfo{ // 谁偷走了雪球能源？
 		{3, 3000},    // 累积经验x3000
 		{400021, 10}, // 雪球能源x10
 		{100254, 1},  // 斯诺纪念x1
 	}, 0)

-	RegisterTask(54, 0, []model.ItemInfo{ // 米鲁族的两个小不点
+	RegisterTask(54, 0, []data.ItemInfo{ // 米鲁族的两个小不点
 		{3, 5000},    // 累积经验x5000
 		{400021, 10}, // 雪球能源x10
 	}, 0)

-	RegisterTask(57, 0, []model.ItemInfo{ // 米鲁族食王选拔赛
+	RegisterTask(57, 0, []data.ItemInfo{ // 米鲁族食王选拔赛
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(58, 0, []model.ItemInfo{ // 斯诺岩洞的不解之谜
+	RegisterTask(58, 0, []data.ItemInfo{ // 斯诺岩洞的不解之谜
 		{3, 3000},    // 累积经验x3000
 		{1, 3000},    // 赛尔豆x3000
 		{400021, 10}, // 雪球能源x10
 	}, 0)

-	RegisterTask(63, 0, []model.ItemInfo{ // 新型试作机SR-01同步调试
+	RegisterTask(63, 0, []data.ItemInfo{ // 新型试作机SR-01同步调试
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(64, 0, []model.ItemInfo{ // 铸造斯诺冰冠
+	RegisterTask(64, 0, []data.ItemInfo{ // 铸造斯诺冰冠
 		{3, 3000},    // 累积经验x3000
 		{1, 3000},    // 赛尔豆x3000
 		{400021, 10}, // 雪球能源x10
 	}, 0)

-	RegisterTask(65, 0, []model.ItemInfo{ // 露希欧星勘察
+	RegisterTask(65, 0, []data.ItemInfo{ // 露希欧星勘察
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(66, 0, []model.ItemInfo{ // 合金强化试验
+	RegisterTask(66, 0, []data.ItemInfo{ // 合金强化试验
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(68, 0, []model.ItemInfo{ // 资料室的神秘事件
+	RegisterTask(68, 0, []data.ItemInfo{ // 资料室的神秘事件
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(69, 0, []model.ItemInfo{ // 宇宙遭遇站
+	RegisterTask(69, 0, []data.ItemInfo{ // 宇宙遭遇站
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(70, 0, []model.ItemInfo{ // 船体紧急修复
+	RegisterTask(70, 0, []data.ItemInfo{ // 船体紧急修复
 		{3, 3000}, // 累积经验x3000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(72, 0, []model.ItemInfo{ // 船长搜救任务
+	RegisterTask(72, 0, []data.ItemInfo{ // 船长搜救任务
 		{3, 2000}, // 累积经验x2000
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(73, 0, []model.ItemInfo{ // 秘制改良机SR-02
+	RegisterTask(73, 0, []data.ItemInfo{ // 秘制改良机SR-02
 		{100303, 1},  // SR-02铠甲x1
 		{400055, 30}, // 变形能量块x30
 		{3, 3000},    // 累积经验x3000
 	}, 0)

-	RegisterTask(74, 0, []model.ItemInfo{{3, 3000}}, 0) // 露希欧星历险（积累经验x3000）
+	RegisterTask(74, 0, []data.ItemInfo{{3, 3000}}, 0) // 露希欧星历险（积累经验x3000）

-	RegisterTask(75, 0, []model.ItemInfo{ // 哈莫的童年片段一
+	RegisterTask(75, 0, []data.ItemInfo{ // 哈莫的童年片段一
 		{3, 3000},   // 累积经验x3000
 		{100324, 1}, // 龙之纪念x1
 	}, 0)

-	RegisterTask(79, 0, []model.ItemInfo{ // 寻找哈莫雷特的族人
+	RegisterTask(79, 0, []data.ItemInfo{ // 寻找哈莫雷特的族人
 		{3, 3000}, // 累积经验x3000
 		{1, 2000}, // 赛尔豆x2000
 	}, 0)

-	RegisterTask(80, 0, []model.ItemInfo{ // 重铸贾斯丁站长
+	RegisterTask(80, 0, []data.ItemInfo{ // 重铸贾斯丁站长
 		{3, 2000}, // 累积经验x2000
 		{1, 3000}, // 赛尔豆x3000
 	}, 0)

-	RegisterTask(81, 0, []model.ItemInfo{ // 守候宿命的追随者
+	RegisterTask(81, 0, []data.ItemInfo{ // 守候宿命的追随者
 		{3, 1000}, // 累积经验x1000
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(83, 0, []model.ItemInfo{ // 光暗之迷
+	RegisterTask(83, 0, []data.ItemInfo{ // 光暗之迷
 		{3, 1000}, // 累积经验x1000
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(84, 0, []model.ItemInfo{ // 星球改造计划
+	RegisterTask(84, 0, []data.ItemInfo{ // 星球改造计划
 		{3, 2000}, // 累积经验x2000
 		{1, 2000}, // 赛尔豆x2000
 	}, 0)

-	RegisterTask(89, 0, []model.ItemInfo{ // 试炼之塔的磨练
+	RegisterTask(89, 0, []data.ItemInfo{ // 试炼之塔的磨练
 		{3, 500},  // 累积经验x500
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(91, 0, []model.ItemInfo{ // 月光下的约定
+	RegisterTask(91, 0, []data.ItemInfo{ // 月光下的约定
 		{3, 2000}, // 累积经验x2000
 		{1, 2000}, // 赛尔豆x2000
 	}, 246)

-	RegisterTask(93, 0, []model.ItemInfo{ // 云霄星的新来客
+	RegisterTask(93, 0, []data.ItemInfo{ // 云霄星的新来客
 		{3, 1000}, // 累积经验x1000
 		{1, 500},  // 赛尔豆x500
 	}, 0)

-	RegisterTask(94, 0, []model.ItemInfo{ // 初识星球能源
+	RegisterTask(94, 0, []data.ItemInfo{ // 初识星球能源
 		{3, 500},  // 累积经验x500
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(96, 0, []model.ItemInfo{ // 旅途中的伙伴
+	RegisterTask(96, 0, []data.ItemInfo{ // 旅途中的伙伴
 		{3, 500},  // 累积经验x500
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(97, 0, []model.ItemInfo{ // 我是音乐小麦霸
+	RegisterTask(97, 0, []data.ItemInfo{ // 我是音乐小麦霸
 		{3, 1000}, // 累积经验x1000
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(98, 0, []model.ItemInfo{ // 尼布守卫战
+	RegisterTask(98, 0, []data.ItemInfo{ // 尼布守卫战
 		{3, 2000}, // 累积经验x2000
 		{1, 1000}, // 赛尔豆x1000
 	}, 0)

-	RegisterTask(201, 0, []model.ItemInfo{{100062, 1}}, 0) // 教官考核（教官指挥棒x1）
-	RegisterTask(300, 0, []model.ItemInfo{}, 300)          // 领取谱尼真身（谱尼的精元x1）
+	RegisterTask(201, 0, []data.ItemInfo{{100062, 1}}, 0) // 教官考核（教官指挥棒x1）
+	RegisterTask(300, 0, []data.ItemInfo{}, 300)          // 领取谱尼真身（谱尼的精元x1）

 	// -------------------------- 带精灵奖励的任务 --------------------------
-	RegisterTask(28, 0, []model.ItemInfo{}, 102) // 遗迹中的精灵信号（奇塔，类型102）
-	RegisterTask(40, 0, []model.ItemInfo{}, 139) // 时空之门（迪卢卡，类型139）
+	RegisterTask(28, 0, []data.ItemInfo{}, 102) // 遗迹中的精灵信号（奇塔，类型102）
+	RegisterTask(40, 0, []data.ItemInfo{}, 139) // 时空之门（迪卢卡，类型139）

-	RegisterTask(49, 0, []model.ItemInfo{ // 密林中的托尼（托尼+物品）
+	RegisterTask(49, 0, []data.ItemInfo{ // 密林中的托尼（托尼+物品）
 		//	{700452, 2}, // 中型智慧芯片x2
 	}, 158) // 托尼（类型158）

-	RegisterTask(71, 0, []model.ItemInfo{ // 赛尔号大整修（TOE+物品）
+	RegisterTask(71, 0, []data.ItemInfo{ // 赛尔号大整修（TOE+物品）
 		{3, 1000}, // 累积经验x1000
 		{1, 1000}, // 赛尔豆x1000
 	}, 213) // TOE（类型213）

-	RegisterTask(92, 0, []model.ItemInfo{ // 站长归来（尼布+物品）
+	RegisterTask(92, 0, []data.ItemInfo{ // 站长归来（尼布+物品）
 		{3, 2000}, // 累积经验x2000
 		{1, 2000}, // 赛尔豆x2000
 	}, 95) // 尼布（类型95）

-	RegisterTask(133, 0, []model.ItemInfo{ // 寻找迷失的心（史空+物品）
+	RegisterTask(133, 0, []data.ItemInfo{ // 寻找迷失的心（史空+物品）
 		{3, 2000}, // 累积经验x2000
 		{1, 2000}, // 赛尔豆x2000
 	}, 381) // 史空（类型381）

 	// -------------------------- 多分支任务 --------------------------
-	RegisterTask(95, 1, []model.ItemInfo{ // 宇宙中的黑色旋涡（分支1：刺蜂套装）
+	RegisterTask(95, 1, []data.ItemInfo{ // 宇宙中的黑色旋涡（分支1：刺蜂套装）
 		{3, 4000},   // 累积经验x4000
 		{1, 2000},   // 赛尔豆x2000
 		{100346, 1}, // 刺蜂重盔x1
@@ -250,7 +250,7 @@ func init() {
 		{100349, 1}, // 刺蜂滚轮x1
 	}, 0)

-	RegisterTask(95, 2, []model.ItemInfo{ // 宇宙中的黑色旋涡（分支2：锡蝶套装）
+	RegisterTask(95, 2, []data.ItemInfo{ // 宇宙中的黑色旋涡（分支2：锡蝶套装）
 		{3, 4000},   // 累积经验x4000
 		{1, 2000},   // 赛尔豆x2000
 		{100350, 1}, // 锡蝶重盔x1
--- a/logic/service/task/list_daily.go
+++ b/logic/service/task/list_daily.go
@@ -1,11 +1,13 @@
 package task

-import "blazing/modules/blazing/model"
+import (
+	"blazing/common/data"
+)

 type TaskResult struct {
 	PetTypeId uint32 `json:"petTypeId" description:"发放的精灵ID"` // 发放的精灵ID，

-	ItemList []model.ItemInfo `json:"itemList" description:"发放物品的数组"` // 发放物品的数组，
+	ItemList []data.ItemInfo `json:"itemList" description:"发放物品的数组"` // 发放物品的数组，
 }

 var TaskResultMap = make(map[uint32]map[uint32]TaskResult)
@@ -27,9 +29,9 @@ func Get_Task_Info(v CompleteTaskInboundInfo) *TaskResult {
 }
 func init() {
 	// 定义通用奖励：经验奖励（ItemId:3，数量20000）
-	expReward := []model.ItemInfo{{ItemId: 3, ItemCnt: 20000}}
+	expReward := []data.ItemInfo{{ItemId: 3, ItemCnt: 20000}}
 	// 定义扭蛋牌奖励（ItemId:400501，数量5）
-	eggReward := []model.ItemInfo{{ItemId: 400501, ItemCnt: 5}}
+	eggReward := []data.ItemInfo{{ItemId: 400501, ItemCnt: 5}}

 	// 批量初始化任务ID 401-407（奖励均为经验）
 	for taskID := 401; taskID <= 407; taskID++ {
--- a/modules/blazing/model/item.go
+++ b/modules/blazing/model/item.go
@@ -6,13 +6,6 @@ import (

 const TableNamePlayerBagItem = "player_bag_item"

-// ItemInfo
-// 用于表示发放物品的信息
-type ItemInfo struct {
-	ItemId  uint32 `json:"itemId" description:"发放物品ID"`     // 发放物品ID，
-	ItemCnt uint32 `json:"itemCount" description:"发放物品的数量"` // 发放物品的数量，
-}
-
 // PlayerBagItem mapped from table <player_bag_item>
 type Item struct {
 	*cool.Model
--- a/modules/config/model/pet_gift.go
+++ b/modules/config/model/pet_gift.go
@@ -11,22 +11,14 @@ const (

 // PetReward 精灵奖励基础配置模型（核心存储结构，与数据库表字段一一对应）
 type PetReward struct {
-	*cool.Model // 嵌入通用Model（包含ID/创建时间/更新时间等通用字段，保持与BossConfig一致）
-
-	MonID  int32    `gorm:"not null;comment:'BOSS对应的精灵ID'" json:"mon_id"`
-	Nature uint32   `gorm:"not null;default:0;comment:'BOSS属性-性格'" json:"nature"`
-	Effect []uint32 `gorm:"type:jsonb;not null;default:'[]';comment:'BOSS特性'" json:"effect"`
-	Lv     int32    `gorm:"not null;comment:'BOSS等级（LvHpMatchUser非0时此配置无效）'" json:"lv"`
-	Color  string   `gorm:"comment:'BOSS颜色'" json:"color"`
-	IsEgg  uint32   `gorm:"not null;default:0;comment:'是否蛋'" json:"is_egg"` //奖励是否为扭蛋奖励
-}
-
-// PetRewardEX 精灵奖励扩展配置模型（用于前端/业务层的复杂数据解析，继承基础模型）
-type PetRewardEX struct {
-	PetReward           // 嵌入基础精灵奖励模型
-	RewardName   string `json:"reward_name"`    // 奖励名称（前端展示用，非数据库存储字段）
-	RewardIcon   string `json:"reward_icon"`    // 奖励图标路径（前端展示用，非数据库存储字段）
-	DropRateDesc string `json:"drop_rate_desc"` // 掉落概率描述（如"10%概率获取"，前端展示用）
+	*cool.Model        // 嵌入通用Model（包含ID/创建时间/更新时间等通用字段，保持与BossConfig一致）
+	IsEnabled   uint32 `gorm:"not null;default:0;comment:'是否启用（0-禁用 1-启用）'" json:"is_enabled"`
+	MonID       int32  `gorm:"not null;comment:'BOSS对应的精灵ID'" json:"mon_id"`
+	DV          int32  `gorm:"not null;default:0;comment:'成长值'" json:"dv"`
+	Nature      uint32 `gorm:"not null;default:0;comment:'BOSS属性-性格'" json:"nature"`
+	Effect      uint32 `gorm:"not null;comment:'BOSS特性'" json:"effect"`
+	Lv          int32  `gorm:"not null;comment:'BOSS等级（LvHpMatchUser非0时此配置无效）'" json:"lv"`
+	IsEgg       uint32 `gorm:"not null;default:0;comment:'是否蛋'" json:"is_egg"` //奖励是否为扭蛋奖励
 }

 // TableName 指定PetReward对应的数据库表名（遵循现有代码规范）
--- a/modules/config/service/PetReward.go
+++ b/modules/config/service/PetReward.go
@@ -16,3 +16,10 @@ func NewPetRewardService() *PetRewardService {
 		},
 	}
 }
+func (s *PetRewardService) GetEgg() model.PetReward {
+	var item model.PetReward
+	cool.DBM(s.Model).Where("is_egg", 1).Where("is_enabled", 1).OrderRandom().Limit(1).Scan(&item)
+
+	return item
+
+}
--- a/modules/config/service/item.go
+++ b/modules/config/service/item.go
@@ -1,6 +1,8 @@
 package service

 import (
+	"blazing/common/data"
+	"blazing/common/utils"
 	"blazing/cool"
 	"blazing/modules/config/model"

@@ -14,24 +16,50 @@ type ItemService struct {

 //实现物品数量的获取

-func (s *ItemService) GetItemCount(id uint32) uint32 {
+func (s *ItemService) GetItemCount(id uint32) data.ItemInfo {
 	var item model.ItemGift
-	cool.DBM(s.Model).Where("id", id).Cache(gdb.CacheOption{
+	var res data.ItemInfo
+	cool.DBM(s.Model).Where("id", id).Where("is_enabled", 1).Cache(gdb.CacheOption{
 		// Duration: time.Hour,

 		Force: false,
 	}).Scan(&item)

 	if item.ItemID == 0 {
-		return 0
+
+		return res
 	}
+	res.ItemId = item.ItemID
+	res.ItemCnt = item.ItemMinCount

 	if item.ItemMaxCount != 0 {
-		return uint32(grand.N(int(item.ItemMinCount), int(item.ItemMaxCount)))
-	}
-	return item.ItemMinCount
-}
+		res.ItemCnt = uint32(grand.N(int(item.ItemMinCount), int(item.ItemMaxCount)))

+	}
+	return res
+}
+func (s *ItemService) GetEgg(count uint32) []data.ItemInfo {
+	var item []model.ItemGift
+	cool.DBM(s.Model).Where("is_egg", 1).Where("is_enabled", 1).Cache(gdb.CacheOption{
+		// Duration: time.Hour,
+
+		Force: false,
+	}).Scan(&item)
+
+	rr := utils.RandomSlice(item, int(count))
+	var res = make([]data.ItemInfo, len(rr))
+	for _, v := range rr {
+		if v.ItemMaxCount != 0 {
+			v.ItemMinCount = uint32(grand.N(int(v.ItemMinCount), int(v.ItemMaxCount)))
+
+		}
+		res = append(res, data.ItemInfo{ItemId: v.ItemID, ItemCnt: v.ItemMinCount})
+
+	}
+
+	return res
+
+}
 func NewItemService() *ItemService {
 	return &ItemService{
 		&cool.Service{
--- a/modules/config/service/pet_fusion_material_service.go
+++ b/modules/config/service/pet_fusion_material_service.go
@@ -18,8 +18,6 @@ type PetFusionMaterialService struct {
 	*cool.Service // 嵌入通用Service（继承基础CRUD方法）
 }

- 
-
 // NewPetFusionMaterialService 创建PetFusionMaterialService实例
 func NewPetFusionMaterialService() *PetFusionMaterialService {
 	return &PetFusionMaterialService{
@@ -39,10 +37,10 @@ func (s *PetFusionMaterialService) Data(Material1 [4]uint32) uint32 {
 	fusions := service.DictInfoServiceS.GetData("fusion")

 	for _, v := range Material1 {
-		if v < 10000 {
-			//使用过小的道具
-			return 0
-		}
+		// if v < 10000 {
+		// 	//使用过小的道具
+		// 	return 0
+		// }
 		_, ok := fusions[v]
 		if !ok {
 			//todo使用了非法材料
--- a/modules/config/service/shiny.go
+++ b/modules/config/service/shiny.go
@@ -3,6 +3,9 @@ package service
 import (
 	"blazing/cool"
 	"blazing/modules/config/model"
+	"context"
+
+	"github.com/gogf/gf/v2/frame/g"
 )

 type ShinyService struct {
@@ -13,6 +16,13 @@ func NewShinyService() *ShinyService {
 	return &ShinyService{
 		&cool.Service{
 			Model: model.NewColorfulSkin(),
+			InsertParam: func(ctx context.Context) g.MapStrAny {
+				admin := cool.GetAdmin(ctx)
+				userId := admin.UserId
+				return g.MapStrAny{
+					"author": userId,
+				}
+			},
 		},
 	}
 }