admin/bl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(service): 重构物品、宠物和任务服务，统一使用EX模型和回调函数处理数据操作

Browse Source
This commit is contained in:
1
2025-09-23 15:01:52 +00:00
parent 1ee43e1319
commit 9c5cfa151a
12 changed files with 100 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
logic/controller/item.go
View File

@@ -12,14 +12,15 @@ func (h Controller) UserItemList(data *item.ItemListInboundInfo, c *player.Playe
result = &item.ItemListOutboundInfo{}
result.ItemList = make([]model.SingleItemInfo, 0)
re := c.Service.ItemCheak()
for _, v := range re {
if int32(v.ItemId) >= int32(data.Param1) && int32(v.ItemId) <= int32(data.Param2) {
v.LeftTime = 360000
result.ItemList = append(result.ItemList, v)
c.Service.Item(func(m map[uint32]model.SingleItemInfo) bool {
for _, v := range m {
if int32(v.ItemId) >= int32(data.Param1) && int32(v.ItemId) <= int32(data.Param2) {
v.LeftTime = 360000
result.ItemList = append(result.ItemList, v)
}
}
}
return false
})
return result, 0
}

13
logic/controller/login.go
View File

@@ -48,16 +48,15 @@ func (h *Controller) Login(data *user.MAIN_LOGIN_IN, c *player.Conn) (result *us
//每天login时候检查重置时间，然后把电池，任务，挖矿重置
//挖矿需要单独存，因为防止多开挖矿
t.Info.TimeToday = 0 //重置电池
go func() {
defer func() {
for i := 400; i < 500; i++ { //每日任务区段
t.Info.TaskList[i] = 0 //重置每日任务
_, ok := t.Service.TaskInfo((uint32(i)))
if ok {
t.Service.TaskSet((uint32(i)), model.TaskInfo{
Info: []uint32{},
})
}
t.Service.Task((uint32(i)), func(te *model.TaskEX) bool {
te.Data = make([]uint32, 0)
return true
})
}
for i := 400; i < 50; i++ { //每日任务区段
t.Info.DailyResArr[i] = 0 //重置每日任务

16
logic/controller/pet.go
View File

@@ -30,7 +30,7 @@ func (h *Controller) GetPetInfo(
if result == nil {
result = &pet.OutInfo{
PetInfo: c.Service.GetPetInfo(data.CatchTime),
PetInfo: c.Service.PetInfo_One(data.CatchTime).Data,
}
}
@@ -44,7 +44,7 @@ func (h *Controller) GetPetList(
err errorcode.ErrorCode) { //这个时候player应该是空的
result = &pet.GetPetListOutboundInfo{}
tt := c.Service.GetPetList(0) //获得未放生的精灵
tt := c.Service.PetInfo(0) //获得未放生的精灵
result.ShortInfoList = make([]pet.PetShortInfo, len(tt))
for i, v := range tt {
@@ -66,7 +66,10 @@ func (h *Controller) PetRelease(
result = &pet.PetReleaseOutboundInfo{}
result.Flag = uint32(data.Flag)
t := c.Service.PetM(int(data.CatchTime), int(data.Flag))
c.Service.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) {
t.InBag = int(data.Flag)
})
switch data.Flag {
case 0:
@@ -84,8 +87,11 @@ func (h *Controller) PetRelease(
case 1:
//todo 背包
c.Info.PetList = append(c.Info.PetList, t)
result.PetInfo = t
c.Service.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) {
c.Info.PetList = append(c.Info.PetList, t.Data)
result.PetInfo = t.Data
})
}
if len(c.Info.PetList) > 0 {

25
logic/controller/task.go
View File

@@ -36,17 +36,10 @@ func (h Controller) AddTaskBuf(data *task.AddTaskBufInboundInfo, c *player.Playe
// }
result = &task.AddTaskBufOutboundInfo{}
_, ok := c.Service.TaskInfo(data.TaskId)
if ok {
c.Service.TaskSet(data.TaskId, model.TaskInfo{
Info: data.TaskList,
})
} else {
c.Service.TaskADD(data.TaskId, model.TaskInfo{
Info: data.TaskList,
})
}
c.Service.Task(data.TaskId, func(te *model.TaskEX) bool {
te.Data = data.TaskList
return true
})
return &task.AddTaskBufOutboundInfo{}, 0
}
@@ -72,7 +65,7 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
result.ItemList = append(result.ItemList, task.ItemInfo{ItemId: 500001, ItemCount: 1})
result.ItemList = append(result.ItemList, task.ItemInfo{ItemId: 500502, ItemCount: 1})
result.ItemList = append(result.ItemList, task.ItemInfo{ItemId: 500503, ItemCount: 1})
}
if data.TaskId == 86 { //新手注册任务
var petid int
@@ -115,10 +108,12 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
* 获取任务状态
*/
func (h Controller) Get_Task_Buf(data *task.GetTaskBufInboundInfo, c *player.Player) (result *task.GetTaskBufOutboundInfo, err errorcode.ErrorCode) {
info, _ := c.Service.TaskInfo(data.TaskId)
result = &task.GetTaskBufOutboundInfo{}
result.TaskId = data.TaskId
result.TaskList = info.Info
c.Service.Task(data.TaskId, func(te *model.TaskEX)bool {
result.TaskId = te.TaskID
result.TaskList = te.Data
return false
})
return result, 0
}

197
modules/blazing/model/boss.go
View File

@@ -1,197 +0,0 @@
package model
import (
"blazing/cool"
"encoding/json"
)
// ------------------------------
// 1. BOSS主表结构（核心ID与关联）
// ------------------------------
const TableNameBoss = "boss"
// Boss 主表仅存储核心索引和JSON数据
type Boss struct {
*cool.Model
PlanetID int32 `gorm:"not null;index:idx_boss_planet;comment:'所属星球/地图ID'" json:"planet_id"`
BossID int32 `gorm:"not null;comment:'BOSS序号（同星球内唯一）'" json:"boss_id"`
Data string `gorm:"type:text;not null;comment:'BOSS详细数据(JSON格式)'" json:"data"`
Galaxy string `gorm:"type:varchar(50);comment:'所属星系（如帕诺星系）'" json:"galaxy"`
}
// 联合唯一索引：确保星球+BOSS序号唯一
func (b *Boss) Indexes() map[string]string {
return map[string]string{
"idx_planet_boss_unique": "planet_id,boss_id",
}
}
// TableName 定义表名
func (*Boss) TableName() string {
return TableNameBoss
}
// GroupName 定义分组名
func (*Boss) GroupName() string {
return "default"
}
// GroupName 定义分组名
func (s *Boss) GetData() string {
return s.Data
}
// NewBoss 创建新的BOSS主表实例
func NewBoss() *Boss {
return &Boss{
Model: cool.NewModel(),
}
}
// ------------------------------
// 2. BOSS详细数据结构（JSON存储）
// ------------------------------
// BossData 封装BOSS所有详细属性，用于JSON序列化
type BossData struct {
// 基础信息
EncyclopediaID int32 `json:"encyclopedia_id"` // BOSS图鉴ID
Desc string `json:"desc"` // BOSS名称描述
Level int32 `json:"level"` // 等级
Capturable bool `json:"capturable"` // 是否可捕捉
// 战斗属性
MaxHP int32 `json:"max_hp"` // 最大血量(-1使用默认公式)
Attack int32 `json:"attack"` // 攻击属性
Defense int32 `json:"defense"` // 防御属性
SpecialAttack int32 `json:"special_attack"` // 特攻属性
SpecialDefense int32 `json:"special_defense"` // 特防属性
Speed int32 `json:"speed"` // 速度属性
Definitely int32 `json:"definitely"` // 必定命中率(默认5)
Dodge int32 `json:"dodge"` // 闪避率(默认5)
Stat string `json:"stat"` // 开局属性变化(攻击,特攻,防御,特防,速度,命中)
// 技能列表
Skills []BossSkill `json:"skills"`
// 免疫效果
ImmunityEffectIDs []int32 `json:"immunity_effect_ids"` // 免疫效果ID列表
ImmunityBuffNames []string `json:"immunity_buff_names"` // 免疫Buff名称列表
// 特殊Buff
SpecialBuffs []SpecialBuff `json:"special_buffs"`
}
// BossSkill 技能详情结构
type BossSkill struct {
ID int32 `json:"id"` // 技能ID
Desc string `json:"desc"` // 技能描述
InfinityPP bool `json:"infinity_pp"` // 是否PP无限
}
// SpecialBuff 特殊Buff结构
type SpecialBuff struct {
Value string `json:"value"` // Buff标识(如boss://map314-boss0)
Params string `json:"params"` // 附加参数(空格分隔)
}
// ------------------------------
// 3. JSON序列化/反序列化工具方法
// ------------------------------
// ToJSON 将BossData转为JSON字符串
func (d *BossData) ToJSON() (string, error) {
data, err := json.Marshal(d)
if err != nil {
return "", err
}
return string(data), nil
}
// ParseBossData 从JSON字符串解析BossData
func ParseBossData(jsonStr string) (*BossData, error) {
var data BossData
if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
return nil, err
}
return &data, nil
}
// ------------------------------
// 4. 表初始化
// ------------------------------
func init() {
// 创建BOSS主表
cool.CreateTable(&Boss{})
}
// ------------------------------
// 5. 使用示例
// ------------------------------
/*
// 存储BOSS数据示例
func ExampleSaveBoss() {
// 1. 构建详细数据
skills := []BossSkill{
{ID: 10001, Desc: "撞击", InfinityPP: true},
{ID: 20020, Desc: "毒粉", InfinityPP: true},
}
immunityEffects := []int32{7, 36}
immunityBuffs := []string{"condition://brun", "condition://poison"}
specialBuffs := []SpecialBuff{
{Value: "boss://map59-boss0", Params: ""},
}
bossData := &BossData{
EncyclopediaID: 347,
Desc: "远古鱼龙",
Level: 100,
Capturable: false,
MaxHP: 3000,
Attack: 280,
SpecialAttack: 417,
Defense: 350,
SpecialDefense: 317,
Speed: 264,
Definitely: 45,
Stat: "0 0 0 0 0 0",
Skills: skills,
ImmunityEffectIDs: immunityEffects,
ImmunityBuffNames: immunityBuffs,
SpecialBuffs: specialBuffs,
}
// 2. 序列化为JSON
dataJSON, _ := bossData.ToJSON()
// 3. 存储到主表
boss := NewBoss()
boss.PlanetID = 59
boss.BossID = 0
boss.Galaxy = "卡兰星系"
boss.Data = dataJSON
// 实际项目中使用GORM保存
// db.Create(boss)
}
// 查询BOSS数据示例
func ExampleGetBoss() {
// 1. 从数据库查询主表
var boss Boss
// db.Where("planet_id = ? AND boss_id = ?", 59, 0).First(&boss)
// 2. 解析JSON数据
bossData, _ := ParseBossData(boss.Data)
// 3. 使用数据
println("BOSS名称:", bossData.Desc)
println("等级:", bossData.Level)
println("技能数量:", len(bossData.Skills))
}
*/

4
modules/blazing/model/cycle.go
View File

@@ -1,4 +0,0 @@
package model
// /这里实现周期性任务，比如每日任务，每周任务，每月任务，每年任务，一次性任务
type PeriodType int

7
modules/blazing/model/item.go
View File

@@ -10,8 +10,13 @@ const TableNamePlayerBagItem = "player_bag_item"
type Item struct {
*cool.Model
PlayerID uint64 `gorm:"not null;index:idx_player_bag_item_by_player_id;comment:'所属玩家ID'" json:"player_id"`
Data string `gorm:"type:text;not null;comment:'全部数据'" json:"data"`
Data string ` gorm:"type:text;not null;comment:'全部数据'" json:"data"`
}
type ItemEX struct {
Item
Data map[uint32]SingleItemInfo `orm:"data" json:"data"`
}
type SingleItemInfo struct {
// 物品Id，
ItemId uint32 `json:"itemId"`

5
modules/blazing/model/pet.go
View File

@@ -55,6 +55,11 @@ type Pet struct {
//是否上架
Data string `gorm:"type:text;not null;comment:'精灵全部数据'" json:"data"`
}
type PetEX struct {
Pet
Data PetInfo `orm:"data" json:"data"`
}
func LastFourElements[T any](s []T) []T {
n := len(s)

10
modules/blazing/model/task.go
View File

@@ -15,12 +15,10 @@ type Task struct {
Data string `gorm:"type:text;not null;comment:'全部数据'" json:"data"`
}
// TaskInfo 单个任务的详细信息，包含任务步骤状态和整体状态
type TaskInfo struct {
// TaskInfo 任务步骤信息，
// struc:"[20]byte" 确保二进制序列化时固定20字节长度，json标签指定JSON字段名
//TaskID uint32 `json:"task_id"` //区分是每日任务还是常规任务,常规为0,每日为1
Info []uint32 `struc:"[20]byte" json:"task_info"`
// TaskEX 单个任务的详细信息，包含任务步骤状态和整体状态
type TaskEX struct {
Task
Data []uint32 `struc:"[20]byte" orm:"data" json:"data"`
//LastResetTime time.Time `gorm:"not null;comment:'上次重置时间（UTC）'" json:"last_reset_time"` //这里是每天重置
// Status 任务整体状态：0-未接受，1-已接受，2-已完成未领取，3-已完成已领取
// json标签指定JSON字段名，与业务状态说明保持一致

74
modules/blazing/service/item.go
View File

@@ -3,47 +3,17 @@ package service
import (
"blazing/cool"
"blazing/modules/blazing/model"
"encoding/json"
)
func (s *UserService) ItemExec(t func([]model.SingleItemInfo) []model.SingleItemInfo) {
//todo待测试
var player model.Item
m1 := cool.DBM(s.info.Model).Where("player_id", s.userid)
m1.Scan(&player)
var tt []model.SingleItemInfo
json.Unmarshal([]byte(player.Data), &tt)
t(tt)
tmep, _ := json.Marshal(tt)
player.Data = string(tmep)
m1.Save(player)
}
func (s *UserService) ItemCheak() map[uint32]model.SingleItemInfo {
func (s *UserService) Item(t func(map[uint32]model.SingleItemInfo) bool) {
//todo待测试
var player model.Item
var player model.ItemEX
m1 := cool.DBM(s.item.Model).Where("player_id", s.userid)
var rer map[uint32]model.SingleItemInfo
m1.Scan(&player)
json.Unmarshal([]byte(player.Data), &rer)
//return gjson.Parse(player.Data)
return rer
}
func (s *UserService) ItemAdd(t []model.SingleItemInfo) {
//todo待测试
var player model.Item
m1 := cool.DBM(s.item.Model).Where("player_id", s.userid)
var rer map[uint32]model.SingleItemInfo
rer = make(map[uint32]model.SingleItemInfo)
m1.Scan(&player)
json.Unmarshal([]byte(player.Data), &rer)
player.PlayerID = uint64(s.userid)
if len(rer) == 0 {
fff, _ := json.Marshal(rer)
player.Data = string(fff)
err := m1.Scan(&player)
if err != nil {
player.Data = make(map[uint32]model.SingleItemInfo)
_, err := m1.Insert(player)
if err != nil {
panic(err)
@@ -51,24 +21,28 @@ func (s *UserService) ItemAdd(t []model.SingleItemInfo) {
}
for _, v := range t {
tt, ok := rer[v.ItemId]
if ok {
tt.ItemCnt += v.ItemCnt
rer[v.ItemId] = tt
} else {
rer[v.ItemId] = v
}
if !t(player.Data) {
return
}
fff, _ := json.Marshal(rer)
player.Data = string(fff)
_, err := m1.Update(player)
_, err = m1.Update(player)
if err != nil {
panic(err)
}
//return gjson.Parse(player.Data)
}
func (s *UserService) ItemAdd(t []model.SingleItemInfo) {
s.Item(func(rer map[uint32]model.SingleItemInfo) bool {
for _, v := range t {
tt, ok := rer[v.ItemId]
if ok {
tt.ItemCnt += v.ItemCnt
rer[v.ItemId] = tt
} else {
rer[v.ItemId] = v
}
}
return true
})
}

65
modules/blazing/service/pet.go
View File

@@ -3,73 +3,42 @@ package service
import (
"blazing/cool"
"blazing/modules/blazing/model"
"encoding/json"
)
// 获取精灵信息 0是仓库,1是背包,2是放生
func (s *UserService) GetPetList(flag int) (ret []model.PetInfo) {
ret = make([]model.PetInfo, 0)
m := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("in_bag", flag)
var tt []model.Pet
m.Scan(&tt)
for _, v := range tt {
var ret11 model.PetInfo
json.Unmarshal([]byte(v.Data), &ret11)
ret = append(ret, ret11)
func (s *UserService) PetInfo(flag int) []model.PetEX {
var tt []model.PetEX
err := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("in_bag", flag).Scan(&tt)
if err != nil {
return []model.PetEX{}
}
return
return tt
}
func (s *UserService) GetPetInfo(cachetime uint32) (ret model.PetInfo) {
func (s *UserService) PetInfo_One_exec(cachetime uint32, t func(*model.PetEX)) {
m := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("catch_time", cachetime)
var tt model.Pet
var tt model.PetEX
m.Scan(&tt)
json.Unmarshal([]byte(tt.Data), &ret)
return
t(&tt)
m.Update(tt)
}
func (s *UserService) PetExec(ctime uint32, t func(uint32, model.PetInfo) model.PetInfo) {
//todo待测试
var player model.Pet
m1 := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("catch_time", ctime)
m1.Scan(&player)
var tt model.PetInfo
json.Unmarshal([]byte(player.Data), &tt)
t(player.CatchTime, tt)
tmep, _ := json.Marshal(tt)
player.Data = string(tmep)
m1.Save(player)
func (s *UserService) PetInfo_One(cachetime uint32) model.PetEX {
m := cool.DBM(s.pet.Model).Where("player_id", s.userid).Where("catch_time", cachetime)
var tt model.PetEX
m.Scan(&tt)
return tt
}
func (s *UserService) PetAdd(y model.PetInfo) {
m1 := cool.DBM(s.pet.Model).Where("player_id", s.userid)
var player model.Pet
var player model.PetEX
player.PlayerID = s.userid
player.CatchTime = y.CatchTime
player.InBag = 0
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
m1.Scan(&player)
player.InBag = type1
var tt model.PetInfo
json.Unmarshal([]byte(player.Data), &tt)
m1.Update(player)
return tt
}

150
modules/blazing/service/task.go
View File

@@ -35,108 +35,24 @@ func Exec[T cool.UserModel, F any](userid uint32, s *cool.Service, processFunc f
return false
}
// func (s *UserService) InitTask() {
// tt := model.NewTask()
// tt.PlayerID = uint64(s.userid)
// var ggg []model.TaskInfo
// 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
func (s *UserService) Task(id uint32, t func(*model.TaskEX) bool) {
var gg model.TaskEX
m1 := cool.DBM(s.task.Model).
Where("player_id", s.userid).
Where("task_id", id)
m1.Scan(&gg)
if gg.TaskID == 0 {
return ret, false
err := m1.Scan(&gg)
tre := t(&gg)
if !tre { //不需要更新
return
}
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) TaskReset() {
var gg model.Task
tt, _ := json.Marshal(&model.TaskInfo{})
gg.Data = string(tt)
//gg.TaskID = id
cool.DBM(s.task.Model).Where("player_id", s.userid).Update(gg)
}
func (s *UserService) TaskADD(id uint32, ret model.TaskInfo) {
var gg model.Task
tt, _ := json.Marshal(&ret)
gg.Data = string(tt)
gg.TaskID = id
gg.PlayerID = uint64(s.userid)
_, err := cool.DBM(s.task.Model).Data(gg).Where("player_id", s.userid).Insert()
if err != nil {
panic(err)
m1.Insert(gg)
} else {
m1.Update(gg)
}
}
func (s *UserService) TaskExec(t func([]model.TaskInfo) []model.TaskInfo) (ret bool) {
//待实现检测是否为每日任务
// if isdaliy {
// Exec[*model.Task](s.userid, s.task, func(tt []model.TaskInfo) []model.TaskInfo {
// var ttt = make([]model.TaskInfo, 500)
// //先重置每日
// for k, v := range tt {
// if k > 400 && !IsToday(v.LastResetTime) { //判断是每日任务
// v.Status = 0 //重置+自动接受每日任务
// v.LastResetTime = time.Now()
// }
// ttt = append(ttt, v)
// }
// return ttt
// })
// }
return Exec[*model.Task](s.userid, s.task, t)
// m := cool.DBM(s.task.Model).Where("player_id", s.userid)
// var tt model.Task
// m.Scan(&tt)
// var ttt map[uint32]model.TaskInfo
// json.Unmarshal([]byte(tt.Data), &ttt)
// ret = t(ttt)
// t1, _ := json.Marshal(&ttt)
// tt.Data = string(t1)
// m.Save(&tt) //退出时保存
// return
}
// IsToday 判断给定时间是否是今天
func IsToday(t time.Time) bool {
@@ -148,51 +64,3 @@ func IsToday(t time.Time) bool {
t.Month() == now.Month() &&
t.Day() == now.Day()
}
// /**
// * 完成任务
// */
// func (s *TaskService) CompleteTask(task uint32) bool {
// return s.Exec(func(ttt map[uint32]model.TaskInfo) bool {
// if conditions, ok := ttt[task]; ok {
// conditions.Status = 3
// ttt[task] = conditions
// }
// return false
// })
// }
// /**
// * 校验任务是否已经完成
// */
// func (s *TaskService) CheckTaskCompleted(task uint32) bool {
// return s.Exec(func(ttt map[uint32]model.TaskInfo) bool {
// if conditions, ok := ttt[task]; ok {
// return conditions.Status == 3
// }
// return false
// })
// }
// func (s *UserService) GenTask() [500]byte {
// ret := [500]byte{}
// Exec[*model.Task](s.userid, s.task, func(tt []model.TaskInfo) []model.TaskInfo {
// //先重置每日
// for _, v := range tt {
// ret[v.TaskID] = v.Status
// }
// return tt
// })
// return ret
// }