diff --git a/common/cool/db.go b/common/cool/db.go
index 3e0685f4..f8b3e982 100644
--- a/common/cool/db.go
+++ b/common/cool/db.go
@@ -12,5 +12,5 @@ func GDBM(m IModel) *gdb.Model {
 
 // DBM 根据model获取 *gdb.Model
 func DBM(m IModel) *gdb.Model {
-	return g.DB(m.GroupName()).Model(m.TableName())
+	return g.DB(m.GroupName()).Model(m.TableName()).FieldsEx("id")
 }
diff --git a/common/data/socket/player.go b/common/data/socket/player.go
index f59c9291..d0a21d71 100644
--- a/common/data/socket/player.go
+++ b/common/data/socket/player.go
@@ -4,6 +4,7 @@ import (
 	"blazing/common/utils"
 	"blazing/modules/blazing/model"
 	"blazing/modules/blazing/service"
+
 	"context"
 	"fmt"
 	"sync"
diff --git a/logic/controller/login.go b/logic/controller/login.go
index 0067334a..3ec54d7e 100644
--- a/logic/controller/login.go
+++ b/logic/controller/login.go
@@ -16,6 +16,16 @@ import (
 	"github.com/gogf/gf/v2/os/glog"
 )
 
+func IsToday(t time.Time) bool {
+	// 获取当前时间
+	now := time.Now()
+
+	// 比较年、月、日是否相同
+	return t.Year() == now.Year() &&
+		t.Month() == now.Month() &&
+		t.Day() == now.Day()
+}
+
 // 处理命令: 1001
 func (h *Controller) Login(data *login.InInfo, c *socket.Conn) (result *login.OutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
 
@@ -27,7 +37,17 @@ func (h *Controller) Login(data *login.InInfo, c *socket.Conn) (result *login.Ou
 		t.Info.UserID = data.Head.UserID
 		t.Onlinetime = uint32(time.Now().Unix())                   //保存时间戳
 		share.ShareManager.SetUserOnline(data.Head.UserID, h.Port) //设置用户登录服务器
-		t.CompleteLogin()                                          //通知客户端登录成功
+
+		if !IsToday(t.Info.LastResetTime) { //判断是否是今天
+			t.Info.LastResetTime = time.Now()
+			//每天login时候检查重置时间，然后把电池，任务，挖矿重置
+			t.Info.TimeToday = 0 //重置电池
+			for i := 400; i < 500; i++ {//每日任务区段
+				t.Info.TaskList[i] = 0 //重置每日任务
+			}
+		}
+
+		t.CompleteLogin() //通知客户端登录成功
 
 		glog.Debug(context.Background(), "登录成功,初始地图 人数:", space.GetSpace(t.Info.MapID).Len())
 
diff --git a/logic/controller/pet.go b/logic/controller/pet.go
index fc16b4d5..cbc1e264 100644
--- a/logic/controller/pet.go
+++ b/logic/controller/pet.go
@@ -4,6 +4,7 @@ import (
 	"blazing/common/data/socket"
 	"blazing/common/socket/errorcode"
 	"blazing/logic/service/pet"
+	"blazing/modules/blazing/model"
 	"blazing/modules/blazing/service"
 )
 
@@ -25,6 +26,33 @@ func (h *Controller) PetRelease(
 	c *socket.Player) (
 	result *pet.PetReleaseOutboundInfo,
 	err errorcode.ErrorCode) { //这个时候player应该是空的
+	//放入背包=数据库置1+添加到背包+pet release发包    仓库=数据库置0+移除背包   设置首发等于取到首发精灵后重新排序
+	//这里只修改，因为添加和移除背包在宠物获取时已经做了
+	result = &pet.PetReleaseOutboundInfo{}
+	result.PetInfo = make([]model.PetInfo, 0)
+	t := service.NewUserService(c.Info.UserID).PetM(int(data.CatchTime), int(data.Flag))
+	switch data.Flag {
+	case 0:
+		//todo 仓库
+		removeIndex := -1
+		for i, v := range c.Info.PetList {
+			if v.CatchTime == uint32(data.CatchTime) {
+				removeIndex = i
+				break // 只移除第一个匹配值，若需移除所有，可省略 break 继续循环
+			}
 
-	return nil, 0
+		}
+		if removeIndex != -1 {
+			c.Info.PetList = append(c.Info.PetList[:removeIndex], c.Info.PetList[removeIndex+1:]...)
+		}
+		result.FirstPetTime = c.Info.PetList[0].CatchTime //设置首发
+
+	case 1:
+		//todo 背包
+		PetAdd(c, t)
+		result.PetInfo = append(result.PetInfo, t)
+	}
+
+	//service.NewUserService(c.Info.UserID).PetAdd( *r)
+	return result, 0
 }
diff --git a/logic/controller/task.go b/logic/controller/task.go
index deecde73..930f12ed 100644
--- a/logic/controller/task.go
+++ b/logic/controller/task.go
@@ -3,6 +3,8 @@ package controller
 import (
 	"blazing/common/data/socket"
 	"blazing/common/socket/errorcode"
+	"blazing/common/socket/handler"
+	"blazing/logic/service/pet"
 	"blazing/logic/service/task"
 	"blazing/modules/blazing/model"
 	"blazing/modules/blazing/service"
@@ -15,9 +17,9 @@ import (
  */
 func (h Controller) AcceptTask(data *task.AcceptTaskInboundInfo, c *socket.Player) (result *task.AcceptTaskOutboundInfo, err errorcode.ErrorCode) {
 	//isdaliy := false
-	if data.Head.CMD != 2201 { //判断是每日任务
-		//isdaliy = true
-	}
+	// if data.Head.CMD != 2201 { //判断是每日任务
+	// 	//isdaliy = true
+	// }
 
 	if c.Info.TaskList[data.TaskId] == 0 {
 		c.Info.TaskList[data.TaskId] = 1
@@ -32,22 +34,23 @@ func (h Controller) AcceptTask(data *task.AcceptTaskInboundInfo, c *socket.Playe
  * 更新任务步骤
  */
 func (h Controller) AddTaskBuf(data *task.AddTaskBufInboundInfo, c *socket.Player) (result *task.AddTaskBufOutboundInfo, err errorcode.ErrorCode) {
-	isdaliy := false
-	if data.Head.CMD != 2204 { //判断是每日任务
-		isdaliy = true
+	// isdaliy := false
+	// if data.Head.CMD != 2204 { //判断是每日任务
+	// 	isdaliy = true
+	// }
+	result = &task.AddTaskBufOutboundInfo{}
+
+	_, ok := service.NewUserService(c.Info.UserID).TaskInfo(data.TaskId)
+	if ok {
+		service.NewUserService(c.Info.UserID).TaskSet(data.TaskId, model.TaskInfo{
+			Info: data.TaskList,
+		})
+	} else {
+		service.NewUserService(c.Info.UserID).TaskADD(data.TaskId, model.TaskInfo{
+
+			Info: data.TaskList,
+		})
 	}
-	service.NewUserService(c.Info.UserID).TaskExec(func(ttt []model.TaskInfo) []model.TaskInfo {
-		var ttt2 []model.TaskInfo
-		for _, v := range ttt {
-
-			v.TaskInfo = data.TaskList
-
-			ttt2 = append(ttt2, v)
-
-		}
-
-		return ttt2
-	}, isdaliy)
 
 	return &task.AddTaskBufOutboundInfo{}, 0
 }
@@ -93,7 +96,7 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *socket.
 		r := model.GenPetInfo(1, 1, 1, 1, 1, 5)
 		result.CaptureTime = r.CatchTime
 		result.PetTypeId = r.ID
-		service.NewUserService(c.Info.UserID).PetAdd(r.CatchTime, 1, *r)
+		PetAdd(c, *r)
 	}
 	if data.TaskId == 87 { //新手注册任务
 
@@ -113,24 +116,10 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *socket.
  * 获取任务状态
  */
 func (h Controller) Get_Task_Buf(data *task.GetTaskBufInboundInfo, c *socket.Player) (result *task.GetTaskBufOutboundInfo, err errorcode.ErrorCode) {
-	isdaliy := false
-	if data.Head.CMD == 2203 { //判断不是每日任务
-		isdaliy = true
-	}
-
-	service.NewUserService(c.Info.UserID).TaskExec(func(ttt []model.TaskInfo) []model.TaskInfo {
-		var ttt2 = make([]model.TaskInfo, 500)
-		for _, v := range ttt {
-			if data.TaskId == v.TaskID {
-				result = &task.GetTaskBufOutboundInfo{TaskId: data.TaskId, TaskList: v.TaskInfo}
-			}
-
-			return ttt2
-
-		}
-
-		return ttt2
-	}, isdaliy)
+	info, _ := service.NewUserService(c.Info.UserID).TaskInfo(data.TaskId)
+	result = &task.GetTaskBufOutboundInfo{}
+	result.TaskId = data.TaskId
+	result.TaskList = info.Info
 
 	return result, 0
 }
@@ -140,11 +129,22 @@ func (h Controller) Get_Task_Buf(data *task.GetTaskBufInboundInfo, c *socket.Pla
  */
 func (h Controller) Delete_Task(data *task.DeleteTaskInboundInfo, c *socket.Player) (result *task.DeleteTaskOutboundInfo, err errorcode.ErrorCode) {
 
-	if data.Head.CMD == 2205 { //判断不是每日任务
+	// if data.Head.CMD == 2205 { //判断不是每日任务
 
-	} else {
+	// } else {
 
-	}
+	// }
 
 	return &task.DeleteTaskOutboundInfo{}, 0
 }
+
+// 添加精灵
+func PetAdd(c *socket.Player, y model.PetInfo) {
+	c.Info.PetList = append(c.Info.PetList, y)
+
+	service.NewUserService(c.Info.UserID).PetAdd(y)
+	t := handler.NewTomeeHeader(2304, c.Info.UserID)
+	c.SendPack(t.Pack(&pet.PetReleaseOutboundInfo{PetInfo: []model.PetInfo{y}}))
+
+	//return lw.IsLogin
+}
diff --git a/logic/service/fight/battle/node/attack.go b/logic/service/fight/battle/node/attack.go
index d7c95d5a..e280f040 100644
--- a/logic/service/fight/battle/node/attack.go
+++ b/logic/service/fight/battle/node/attack.go
@@ -1,9 +1,11 @@
 package node
-
+ 
 func (this *EffectNode) UseSkill() bool {
 	panic("not implemented") // TODO: Implement
 }
-
+func (this *EffectNode) OnSkillPP() bool {
+	panic("not implemented") // TODO: Implement
+}
 func (this *EffectNode) SkillUseEnd() bool {
 	panic("not implemented") // TODO: Implement
 }
diff --git a/logic/service/fight/fight.go b/logic/service/fight/fight.go
index c8193ce2..1a966ba9 100644
--- a/logic/service/fight/fight.go
+++ b/logic/service/fight/fight.go
@@ -2,6 +2,7 @@ package fight
 
 import (
 	"blazing/common/socket/handler"
+	"blazing/modules/blazing/model"
 )
 
 // 野怪对战包
@@ -62,3 +63,21 @@ type FightPetInfo struct {
 	// byte[]，固定长度6，存储buff等级、攻击、速度等属性
 	BattleLV [6]byte `fieldDesc:"这里实际上应该是6个单字节byte, 内容为buff等级 攻击 速度 特攻 防御 特防 命中等.但具体顺序未知可能需要测试. 具体数值为1-6等级" serialize:"fixedLength=6,type=byteArray"`
 }
+
+// AttackValue 战斗中的攻击数值信息
+type AttackValue struct {
+	UserID     uint64            `json:"userId" fieldDescription:"玩家的米米号 与野怪对战userid = 0"`
+	SkillID    uint64            `json:"skillId" fieldDescription:"使用技能的id"`
+	AttackTime uint64            `json:"attackTime" fieldDescription:"是否击中 如果为0 则miss 如果为1 则击中"`
+	LostHp     uint64            `json:"lostHp" fieldDescription:"我方造成的伤害"`
+	GainHp     uint64            `json:"gainHp" fieldDescription:"我方获得血量"`
+	RemainHp   uint64            `json:"remainHp" fieldDescription:"我方剩余血量"`
+	MaxHp      uint64            `json:"maxHp" fieldDescription:"我方最大血量"`
+	State      uint64            `json:"state" fieldDescription:"固定值0 需要后续测试"`
+	SkillList  []model.SkillInfo `json:"skillList" fieldDescription:"根据精灵的数据插入技能 最多4条 不定长"`
+	IsCritical uint64            `json:"isCritical" fieldDescription:"是否暴击"`
+	Status     [20]byte          `json:"status" fieldDescription:"20个字节 各种状态: 0:\"麻痹\",1:\"中毒\",2:\"烧伤\",4:\"寄生\",5:\"冻伤\",6:\"害怕\",7:\"疲惫\",8:\"睡眠\",9:\"石化\",10:\"混乱\",15:\"冰封\",16:\"流血\""`
+	BattleLv   [6]byte           `json:"battleLv" fieldDescription:"6个单字节byte, 内容为buff等级 攻击 速度 特攻 防御 特防命中等. 但具体顺序未知可能需要测试. 具体数值为1-6等级"`
+	// OwnerMaxShield     uint64            `json:"ownerMaxShield" fieldDescription:"我方最大护盾"`
+	// OwnerCurrentShield uint64            `json:"ownerCurrentShield" fieldDescription:"我方当前护盾"`
+}
diff --git a/logic/service/pet/pet.go b/logic/service/pet/pet.go
index 63b788f5..dd157483 100644
--- a/logic/service/pet/pet.go
+++ b/logic/service/pet/pet.go
@@ -17,14 +17,14 @@ type OutInfo struct {
 
 // PetReleaseOutboundInfo 宠物释放出站消息
 type PetReleaseOutboundInfo struct {
-	HomeEnergy   uint64          `json:"home_energy" fieldDescription:"暂定0" autoCodec:"true" uint:"true"`
-	FirstPetTime uint64          `json:"first_pet_time" fieldDescription:"精灵生成时间" autoCodec:"true" uint:"true"`
+	HomeEnergy   uint32          `json:"home_energy" fieldDescription:"暂定0" autoCodec:"true" uint:"true"`
+	FirstPetTime uint32          `json:"first_pet_time" fieldDescription:"精灵生成时间" autoCodec:"true" uint:"true"`
 	PetInfo      []model.PetInfo `json:"pet_info" fieldDescription:"精灵信息" autoCodec:"true"`
 }
 
 // 放入背包或者加入仓库
 type PetReleaseInboundInfo struct {
 	Head      handler.TomeeHeader `cmd:"2304" struc:"[0]pad"`
-	CatchTime uint64              `json:"catch_time" fieldDescription:"精灵生成时间" autoCodec:"true" uint:"true"`
-	Flag      uint64              `json:"flag" fieldDescription:"0为放入仓库，1为放入背包" autoCodec:"true" uint:"true"`
+	CatchTime uint32              `json:"catch_time" fieldDescription:"精灵生成时间" autoCodec:"true" uint:"true"`
+	Flag      uint32              `json:"flag" fieldDescription:"0为放入仓库，1为放入背包" autoCodec:"true" uint:"true"`
 }
diff --git a/login/internal/cmd/cmd.go b/login/internal/cmd/cmd.go
index 472f39c7..2690a391 100644
--- a/login/internal/cmd/cmd.go
+++ b/login/internal/cmd/cmd.go
@@ -26,6 +26,8 @@ var (
 			}
 
 			s := g.Server()
+
+			s.EnableAdmin()
 			s.SetServerAgent(cool.Config.Name)
 			s.BindHookHandler("/*", ghttp.HookBeforeServe, beforeServeHook)
 			runtime.SetMutexProfileFraction(1) // (非必需)开启对锁调用的跟踪
diff --git a/manifest/config/config.yaml b/manifest/config/config.yaml
index bc96b36a..d241b899 100644
--- a/manifest/config/config.yaml
+++ b/manifest/config/config.yaml
@@ -5,7 +5,10 @@ server:
   openapiPath: "/api.json"
   swaggerPath: "/swagger"
   clientMaxBodySize: 104857600 # 100MB in bytes 100*1024*1024
-
+         # 平滑重启特性
+  graceful:                true # 是否开启平滑重启特性，开启时将会在本地增加10000的本地TCP端口用于进程间通信。默认false
+  gracefulTimeout:         2     # 父进程在平滑重启后多少秒退出，默认2秒。若请求耗时大于该值，可能会导致请求中断
+  gracefulShutdownTimeout: 5     # 关闭Server时如果存在正在执行的HTTP请求，Server等待多少秒才执行强行关闭
 logger:
   level: "all"
   stdout: true
diff --git a/modules/base/model/base_sys_user.go b/modules/base/model/base_sys_user.go
index e0298e95..44132c2d 100644
--- a/modules/base/model/base_sys_user.go
+++ b/modules/base/model/base_sys_user.go
@@ -7,11 +7,11 @@ const TableNameBaseSysUser = "base_sys_user"
 // BaseSysUser mapped from table <base_sys_user>
 type BaseSysUser struct {
 	*cool.Model
-	DepartmentID uint    `gorm:"column:departmentId;type:bigint;index" json:"departmentId"`        // 部门ID
-	Name         *string `gorm:"column:name;type:varchar(255)" json:"name"`                        // 姓名
-	Username     string  `gorm:"column:username;type:varchar(100);not null;Index" json:"username"` // 用户名
-	Password     string  `gorm:"column:password;type:varchar(255);not null" json:"password"`       // 密码
-	PasswordV    *int32  `gorm:"column:passwordV;type:int;not null;default:1" json:"passwordV"`    // 密码版本, 作用是改完密码，让原来的token失效
+	DepartmentID uint `gorm:"column:departmentId;type:bigint;index" json:"departmentId"` // 部门ID
+	//Name         *string `gorm:"column:name;type:varchar(255)" json:"name"`                        // 姓名
+	Username  string `gorm:"column:username;type:varchar(100);not null;Index" json:"username"` // 用户名
+	Password  string `gorm:"column:password;type:varchar(255);not null" json:"password"`       // 密码
+	PasswordV *int32 `gorm:"column:passwordV;type:int;not null;default:1" json:"passwordV"`    // 密码版本, 作用是改完密码，让原来的token失效
 
 	HeadImg *string `gorm:"column:headImg;type:varchar(255)" json:"headImg"` // 头像
 	//Phone        *string `gorm:"column:phone;type:varchar(20);index" json:"phone"`                 // 手机
diff --git a/modules/blazing/model/pet.go b/modules/blazing/model/pet.go
index d2b30862..e91d01f2 100644
--- a/modules/blazing/model/pet.go
+++ b/modules/blazing/model/pet.go
@@ -15,7 +15,11 @@ type Pet struct {
 	PlayerID  uint32 `gorm:"not null;index:idx_pet_by_player_id;comment:'所属玩家ID'" json:"player_id"`
 	InBag     int    `gorm:"not null;comment:'是否在背包中'" json:"in_bag"` //"0为放入仓库，1为放入背包
 	CatchTime uint32 `gorm:"not null;comment:'捕捉时间'" json:"catch_time"`
-	Data      string `gorm:"type:text;not null;comment:'精灵全部数据'" json:"data"`
+	// Owner     uint32 `struc:"skip"` //仅作为存储
+	// FreedTime uint32 `struc:"skip"` //放生时间
+	//是否可交易，这里应该定义在精灵ID里
+	//是否上架
+	Data string `gorm:"type:text;not null;comment:'精灵全部数据'" json:"data"`
 }
 
 // * @param petTypeId 精灵类型ID
@@ -111,22 +115,23 @@ func GenPetInfo(id, individual, natureId, abilityTypeEnum, shinyid, level uint32
 }
 
 // 计算HP面板值（无性格修正）
-func (c *PetInfo) CalculatePetHPPanelSize(base, iv, level, ev uint32) uint32 {
+func (c *PetInfo) CalculatePetHPPanelSize(base, dv, level, ev uint32) uint32 {
 	// 实现具体计算逻辑，示例公式：(基础值 + 个体值) * 等级 / 100 + 等级 + 10 + 努力值/4
-	return (base+iv)*level/100 + level + 10 + ev/4
+	baseValue := (base*2 + ev/4 + 100 + dv) * (level/100 + 10)
+	return uint32(baseValue)
 }
 
 // 计算其他属性面板值（带性格修正）
-func (c *PetInfo) CalculatePetPanelSize(base, iv, level, ev uint32, natureCorrect float64) uint32 {
+func (c *PetInfo) CalculatePetPanelSize(base, dv, level, ev uint32, natureCorrect float64) uint32 {
 	// 实现具体计算逻辑，示例公式：((基础值 + 个体值) * 等级 / 100 + 5 + 努力值/4) * 性格修正
-	baseValue := (base+iv)*level/100 + 5 + ev/4
+
+	baseValue := (base*2 + ev/4 + dv) * (level/100 + 5)
 	return uint32(float64(baseValue) * natureCorrect)
 }
 
 // PetInfo 精灵信息结构（合并后的优化版本）
 type PetInfo struct {
-	Owner     uint32 `struc:"skip"` //仅作为存储
-	freedTime uint32 `struc:"skip"` //放生时间
+
 	// 精灵编号（@UInt long → uint32）
 	ID uint32 `fieldDesc:"精灵编号" `
 
diff --git a/modules/blazing/model/task.go b/modules/blazing/model/task.go
index 78db57c9..169471af 100644
--- a/modules/blazing/model/task.go
+++ b/modules/blazing/model/task.go
@@ -11,6 +11,7 @@ const TableNameTask = "task"
 type Task struct {
 	*cool.Model
 	PlayerID uint64 `gorm:"not null;index:idx_task_by_player_id;comment:'所属玩家ID'" json:"player_id"`
+	TaskID   uint32 `gorm:"not null;comment:'任务ID'" json:"task_id"`
 	Data     string `gorm:"type:text;not null;comment:'全部数据'" json:"data"`
 }
 
@@ -18,8 +19,8 @@ type Task struct {
 type TaskInfo struct {
 	// TaskInfo 任务步骤信息，对应Java的@ArraySerialize(FIXED_LENGTH=20)注解
 	// struc:"[20]byte" 确保二进制序列化时固定20字节长度，json标签指定JSON字段名
-	TaskID   uint32   `json:"task_id"` //区分是每日任务还是常规任务,常规为0,每日为1
-	TaskInfo []uint32 `struc:"[20]byte" json:"task_info"`
+	//TaskID   uint32   `json:"task_id"` //区分是每日任务还是常规任务,常规为0,每日为1
+	Info []uint32 `struc:"[20]byte" json:"task_info"`
 	//LastResetTime time.Time `gorm:"not null;comment:'上次重置时间（UTC）'" json:"last_reset_time"` //这里是每天重置
 	// Status 任务整体状态：0-未接受，1-已接受，2-已完成未领取，3-已完成已领取
 	// json标签指定JSON字段名，与业务状态说明保持一致
diff --git a/modules/blazing/service/pet.go b/modules/blazing/service/pet.go
index 4ca6426d..cdaae5ca 100644
--- a/modules/blazing/service/pet.go
+++ b/modules/blazing/service/pet.go
@@ -47,15 +47,26 @@ func (s *UserService) PetExec(ctime uint32, t func(uint32, model.PetInfo) model.
 	m1.Save(player)
 
 }
-func (s *UserService) PetAdd(ctime uint32, inbag int, y model.PetInfo) {
+func (s *UserService) PetAdd(y model.PetInfo) {
 
 	m1 := cool.DBM(s.pet.Model).Where("player_id", s.userid)
 	var player model.Pet
 	player.PlayerID = s.userid
-	player.CatchTime = ctime
-	player.InBag = inbag
+	player.CatchTime = y.CatchTime
+	player.InBag = 1
 	tmp, _ := json.Marshal(y)
 	player.Data = string(tmp)
 	m1.Insert(player)
 
 }
+func (s *UserService) PetM(ctime, type1 int) model.PetInfo {
+
+	m1 := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("catch_time", ctime)
+	var player model.Pet
+	player.InBag = type1
+	m1.Update(player)
+	var tt model.PetInfo
+	json.Unmarshal([]byte(player.Data), &tt)
+	return tt
+
+}
diff --git a/modules/blazing/service/reg.go b/modules/blazing/service/reg.go
index 29531ad2..8054c551 100644
--- a/modules/blazing/service/reg.go
+++ b/modules/blazing/service/reg.go
@@ -45,12 +45,12 @@ func (s *UserService) Reg(nick string, color uint32) {
 	}
 
 	t.Data = string(t22)
-	_, err = cool.DBM(s.reg.Model).Data(t).FieldsEx("id").Insert()
+	_, err = cool.DBM(s.reg.Model).Data(t).Insert()
 	if err != nil {
 		glog.Error(context.Background(), err)
 		return
 	}
-	go s.InitTask()
+	//go s.InitTask()
 }
 
 func (s *UserService) Person() (ret *model.PlayerInfo) {
diff --git a/modules/blazing/service/task.go b/modules/blazing/service/task.go
index 2a73866d..62212e0d 100644
--- a/modules/blazing/service/task.go
+++ b/modules/blazing/service/task.go
@@ -35,30 +35,62 @@ func Exec[T cool.UserModel, F any](userid uint32, s *cool.Service, processFunc f
 	return false
 }
 
-func (s *UserService) InitTask() {
+// func (s *UserService) InitTask() {
 
-	tt := model.NewTask()
-	tt.PlayerID = uint64(s.userid)
+// 	tt := model.NewTask()
+// 	tt.PlayerID = uint64(s.userid)
 
-	var ggg []model.TaskInfo
+// 	var ggg []model.TaskInfo
 
-	for i := 0; i < 500; i++ {
-		ggg = append(ggg, model.TaskInfo{
-			TaskID:   (uint32(i)),
-			TaskInfo: make([]uint32, 0),
-		})
+// 	for i := 0; i < 500; i++ {
+// 		ggg = append(ggg, model.TaskInfo{
+// 			//TaskID:   (uint32(i)),
+// 			TaskIinnfo: make([]uint32, 0),
+// 		})
 
+// 	}
+// 	ffgg, _ := json.Marshal(ggg)
+// 	tt.Data = string(ffgg)
+// 	_, err := cool.DBM(s.task.Model).Data(tt).FieldsEx("id").Insert()
+// 	if err != nil {
+// 		panic(err)
+// 	}
+// 	//panic(err)
+
+// }
+
+// 获取任务信息
+func (s *UserService) TaskInfo(id uint32) (ret model.TaskInfo, ok bool) {
+	var gg model.Task
+	m1 := cool.DBM(s.task.Model).Where("player_id", s.userid)
+	m1.Scan(&gg)
+
+	if gg.TaskID == 0 {
+
+		return ret, false
 	}
-	ffgg, _ := json.Marshal(ggg)
-	tt.Data = string(ffgg)
-	_, err := cool.DBM(s.task.Model).Data(tt).FieldsEx("id").Insert()
-	if err != nil {
-		panic(err)
-	}
-	//panic(err)
+	json.Unmarshal([]byte(gg.Data), &ret)
+	return ret, true
+}
+func (s *UserService) TaskSet(id uint32, ret model.TaskInfo) {
+	var gg model.Task
+
+	tt, _ := json.Marshal(&ret)
+	gg.Data = string(tt)
+	//gg.TaskID = id
+	cool.DBM(s.task.Model).Where("player_id", s.userid).Where("task_id", id).Update(gg)
 
 }
-func (s *UserService) TaskExec(t func([]model.TaskInfo) []model.TaskInfo, isdaliy bool) (ret bool) {
+func (s *UserService) TaskADD(id uint32, ret model.TaskInfo) {
+	var gg model.Task
+
+	tt, _ := json.Marshal(&ret)
+	gg.Data = string(tt)
+	gg.TaskID = id
+	cool.DBM(s.task.Model).Where("player_id", s.userid).Insert()
+
+}
+func (s *UserService) TaskExec(t func([]model.TaskInfo) []model.TaskInfo) (ret bool) {
 
 	//待实现检测是否为每日任务
 	// if isdaliy {