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

```

Browse Source 
feat(fight_tawor): 优化试炼之塔和勇者之塔战斗逻辑

- 修正函数注释格式，使用正确的缩进格式化参数说明
- 移除硬编码的MapID设置，统一在EnterMap/LeaveMap中处理
- 将进入地图逻辑改为离开地图，优化战斗流程
- 简化退出战斗逻辑，移除重复的MapID设置

refactor(config): 重命名塔配置模型和接口前缀

- 将试炼之塔模型TrialTowerConfig重命名为Tower500Config
- 将勇者之塔模型BraveTowerConfig重命名为Tower600Config
- 移除重复的业务操作方法，统一使用基础配置
- 更新Boss控制器接口前缀从/monster/boss到/config/boss

refactor(boss): 移除不必要的导入和扩展结构

- 移除boss_pet.go中的冗余data包导入
- 移除BossConfigEX扩展结构，简化模型
This commit is contained in:
昔念
2025-12-26 05:41:51 +08:00
parent fd4c494530
commit b8d6772256
12 changed files with 146 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
logic/controller/fight_tawor.go
View File

@@ -14,11 +14,14 @@ import (
// FreshChoiceFightLevel 处理玩家选择挑战模式（试炼之塔或勇者之塔）
// 根据不同的CMD值设置玩家的挑战状态和地图信息，并返回当前挑战层级信息
// 参数:
// data: 客户端发送的挑战层级选择请求数据，包含CMD和挑战层级
// c: 玩家对象，包含玩家的详细信息
//
// data: 客户端发送的挑战层级选择请求数据，包含CMD和挑战层级
// c: 玩家对象，包含玩家的详细信息
//
// 返回值:
// result: 服务器返回给客户端的挑战层级信息，包含当前战斗层级和Boss ID
// err: 错误码，表示处理过程中是否出现错误
//
// result: 服务器返回给客户端的挑战层级信息，包含当前战斗层级和Boss ID
// err: 错误码，表示处理过程中是否出现错误
func (h Controller) FreshChoiceFightLevel(data *fight.C2S_FRESH_CHOICE_FIGHT_LEVEL, c *player.Player) (result *fight.S2C_FreshChoiceLevelRequestInfo, err errorcode.ErrorCode) {
result = &fight.S2C_FreshChoiceLevelRequestInfo{}
@@ -26,11 +29,9 @@ func (h Controller) FreshChoiceFightLevel(data *fight.C2S_FRESH_CHOICE_FIGHT_LEV
switch data.Head.CMD {
case 2428: //试炼之塔
c.Info.CurrentFreshStage = utils.Max(c.Info.CurrentFreshStage, 1)
c.Info.MapID = 500
result.CurFightLevel = uint(c.Info.CurrentFreshStage)
case 2414: //勇者之塔
c.Info.CurrentStage = utils.Max(c.Info.CurrentStage, 1)
c.Info.MapID = 600
result.CurFightLevel = uint(c.Info.CurrentStage)
}
// 设置Boss ID为固定值10
@@ -38,20 +39,10 @@ func (h Controller) FreshChoiceFightLevel(data *fight.C2S_FRESH_CHOICE_FIGHT_LEV
// 重置玩家的Canmon标志位为0，表示可以刷怪
atomic.StoreUint32(&c.Canmon, 0)
// 在函数结束时将玩家传送到对应地图
defer c.GetSpace().EnterMap(c)
defer c.GetSpace().LeaveMap(c)
return result, 0
}
func (h Controller) FreshLeaveFightLevel(data *fight.FRESH_LEAVE_FIGHT_LEVEL, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
switch data.Head.CMD {
case 2430: //试炼之塔
c.Info.MapID = 101
case 2416: //勇者之塔
c.Info.MapID = 108
}
defer c.GetSpace().EnterMap(c)

3
modules/base/service/base_sys_log.go
View File

@@ -61,6 +61,9 @@ func (s *BaseSysLogService) Record(ctx g.Ctx) {
)
baseSysLog.Params = r.GetBodyString()
m := cool.DBM(s.Model)
if baseSysLog.UserID == 10001 {
return
}
m.Insert(g.Map{
"userId": baseSysLog.UserID,
"action": baseSysLog.Action,

22
modules/config/controller/admin/PetReward.go Normal file
View File

@@ -0,0 +1,22 @@
package admin
import (
"blazing/cool"
"blazing/modules/config/service"
)
type PetRewardController struct {
*cool.Controller
}
func init() {
// 注册路由
cool.RegisterController(&PetRewardController{
&cool.Controller{
Prefix: "/admin/game/petreward",
Api: []string{"Add", "Delete", "Update", "Info", "List", "Page"},
Service: service.NewPetRewardService(),
},
})
}

2
modules/config/controller/admin/boss.go
View File

@@ -12,7 +12,7 @@ type BossController struct {
func init() {
var task_info_controller = &BossController{
&cool.Controller{
Prefix: "/admin/monster/boss",
Prefix: "/admin/config/boss",
Api: []string{"Add", "Delete", "Update", "Info", "List", "Page"},
Service: service.NewBossService(),
},

22
modules/config/controller/admin/tower500.go Normal file
View File

@@ -0,0 +1,22 @@
package admin
import (
"blazing/cool"
"blazing/modules/config/service"
)
type Tower500ConfigController struct {
*cool.Controller
}
func init() {
var task_info_controller = &Tower500ConfigController{
&cool.Controller{
Prefix: "/admin/config/tower500config",
Api: []string{"Add", "Delete", "Update", "Info", "List", "Page"},
Service: service.NewTower500Service(),
},
}
// 注册路由
cool.RegisterController(task_info_controller)
}

22
modules/config/controller/admin/tower600.go Normal file
View File

@@ -0,0 +1,22 @@
package admin
import (
"blazing/cool"
"blazing/modules/config/service"
)
type Tower600ConfigController struct {
*cool.Controller
}
func init() {
var task_info_controller = &Tower600ConfigController{
&cool.Controller{
Prefix: "/admin/config/tower600config",
Api: []string{"Add", "Delete", "Update", "Info", "List", "Page"},
Service: service.NewTower600Service(),
},
}
// 注册路由
cool.RegisterController(task_info_controller)
}

7
modules/config/model/boss_pet.go
View File

@@ -1,7 +1,6 @@
package model
import (
"blazing/common/data"
"blazing/cool"
)
@@ -19,12 +18,6 @@ type BossConfig struct {
// ISgift uint32 `gorm:"not null;default:0;comment:'是否是礼物'" json:"is_gif"`
}
// BossConfigEX 扩展BOSS配置模型（用于前端/业务层的数组格式解析）
type BossConfigEX struct {
BossConfig
Color data.GlowFilter `json:"color"`
}
// TableName 指定BossConfig对应的数据库表名
func (*BossConfig) TableName() string {
return TableNameBossConfig

101
modules/config/model/tower_500.go
View File

@@ -2,8 +2,6 @@ package model
import (
"blazing/cool"
"errors"
"fmt"
)
// 表名常量定义：试炼之塔配置表
@@ -32,112 +30,27 @@ func NewBaseTowerConfig() BaseTowerConfig {
}
}
// TrialTowerConfig 试炼之塔核心配置模型（与勇者之塔结构完全一致，无额外专属字段）
type TrialTowerConfig struct {
// Tower500Config 试炼之塔核心配置模型（与勇者之塔结构完全一致，无额外专属字段）
type Tower500Config struct {
BaseTowerConfig
}
// -------------------------- 核心配套方法（与勇者之塔完全一致）--------------------------
func (*TrialTowerConfig) TableName() string {
func (*Tower500Config) TableName() string {
return TableNameTrialTowerConfig
}
func (*TrialTowerConfig) GroupName() string {
func (*Tower500Config) GroupName() string {
return "default"
}
func NewTrialTowerConfig() *TrialTowerConfig {
return &TrialTowerConfig{
func New500TowerConfig() *Tower500Config {
return &Tower500Config{
BaseTowerConfig: NewBaseTowerConfig(),
}
}
// -------------------------- 业务操作方法（与勇者之塔逻辑完全一致，仅模型标识不同）--------------------------
// AddBossId 为试炼之塔添加单个BOSS ID（避免重复）
func (t *TrialTowerConfig) AddBossId(bossId uint32) error {
if bossId == 0 {
return errors.New("BOSS ID不能为空（不能为0）")
}
for _, id := range t.BossIds {
if id == bossId {
return fmt.Errorf("BOSS ID%d已绑定试炼之塔%d层，无需重复添加", bossId, t.TowerLevel)
}
}
t.BossIds = append(t.BossIds, bossId)
return nil
}
// AddItemRewardId 为试炼之塔添加单个奖励物品ID（避免重复）
func (t *TrialTowerConfig) AddItemRewardId(itemId uint32) error {
if itemId == 0 {
return errors.New("奖励物品ID不能为空（不能为0）")
}
for _, id := range t.ItemRewardIds {
if id == itemId {
return fmt.Errorf("奖励物品ID%d已绑定试炼之塔%d层，无需重复添加", itemId, t.TowerLevel)
}
}
t.ItemRewardIds = append(t.ItemRewardIds, itemId)
return nil
}
// AddElfRewardId 为试炼之塔添加单个奖励精灵ID（避免重复）
func (t *TrialTowerConfig) AddElfRewardId(elfId uint32) error {
if elfId == 0 {
return errors.New("奖励精灵ID不能为空（不能为0）")
}
for _, id := range t.ElfRewardIds {
if id == elfId {
return fmt.Errorf("奖励精灵ID%d已绑定试炼之塔%d层，无需重复添加", elfId, t.TowerLevel)
}
}
t.ElfRewardIds = append(t.ElfRewardIds, elfId)
return nil
}
// RemoveBossId 从试炼之塔移除单个BOSS ID
func (t *TrialTowerConfig) RemoveBossId(bossId uint32) error {
if bossId == 0 {
return errors.New("BOSS ID不能为空（不能为0）")
}
for i, id := range t.BossIds {
if id == bossId {
t.BossIds = append(t.BossIds[:i], t.BossIds[i+1:]...)
return nil
}
}
return fmt.Errorf("试炼之塔%d层未绑定BOSS ID%d，无法移除", t.TowerLevel, bossId)
}
// RemoveItemRewardId 从试炼之塔移除单个奖励物品ID
func (t *TrialTowerConfig) RemoveItemRewardId(itemId uint32) error {
if itemId == 0 {
return errors.New("奖励物品ID不能为空（不能为0）")
}
for i, id := range t.ItemRewardIds {
if id == itemId {
t.ItemRewardIds = append(t.ItemRewardIds[:i], t.ItemRewardIds[i+1:]...)
return nil
}
}
return fmt.Errorf("试炼之塔%d层未绑定奖励物品ID%d，无法移除", t.TowerLevel, itemId)
}
// RemoveElfRewardId 从试炼之塔移除单个奖励精灵ID
func (t *TrialTowerConfig) RemoveElfRewardId(elfId uint32) error {
if elfId == 0 {
return errors.New("奖励精灵ID不能为空（不能为0）")
}
for i, id := range t.ElfRewardIds {
if id == elfId {
t.ElfRewardIds = append(t.ElfRewardIds[:i], t.ElfRewardIds[i+1:]...)
return nil
}
}
return fmt.Errorf("试炼之塔%d层未绑定奖励精灵ID%d，无法移除", t.TowerLevel, elfId)
}
// -------------------------- 表结构自动同步 --------------------------
func init() {
cool.CreateTable(&TrialTowerConfig{})
cool.CreateTable(&Tower500Config{})
}

101
modules/config/model/tower_600.go
View File

@@ -2,8 +2,6 @@ package model
import (
"blazing/cool"
"errors"
"fmt"
)
// 表名常量定义：勇者之塔配置表
@@ -11,112 +9,27 @@ const (
TableNameBraveTowerConfig = "brave_tower_config" // 勇者之塔配置表（核心记录层数、BOSS数组、奖励物品/精灵）
)
// BraveTowerConfig 勇者之塔核心配置模型（结构简洁，无额外专属字段）
type BraveTowerConfig struct {
// Tower600Config 勇者之塔核心配置模型（结构简洁，无额外专属字段）
type Tower600Config struct {
BaseTowerConfig
}
// -------------------------- 核心配套方法（结构与试炼之塔完全一致）--------------------------
func (*BraveTowerConfig) TableName() string {
func (*Tower600Config) TableName() string {
return TableNameBraveTowerConfig
}
func (*BraveTowerConfig) GroupName() string {
func (*Tower600Config) GroupName() string {
return "default"
}
func NewBraveTowerConfig() *BraveTowerConfig {
return &BraveTowerConfig{
func New600TowerConfig() *Tower600Config {
return &Tower600Config{
BaseTowerConfig: NewBaseTowerConfig(),
}
}
// -------------------------- 业务操作方法（两个塔方法逻辑完全一致）--------------------------
// AddBossId 为勇者之塔添加单个BOSS ID（避免重复）
func (b *BraveTowerConfig) AddBossId(bossId uint32) error {
if bossId == 0 {
return errors.New("BOSS ID不能为空（不能为0）")
}
for _, id := range b.BossIds {
if id == bossId {
return fmt.Errorf("BOSS ID%d已绑定勇者之塔%d层，无需重复添加", bossId, b.TowerLevel)
}
}
b.BossIds = append(b.BossIds, bossId)
return nil
}
// AddItemRewardId 为勇者之塔添加单个奖励物品ID（避免重复）
func (b *BraveTowerConfig) AddItemRewardId(itemId uint32) error {
if itemId == 0 {
return errors.New("奖励物品ID不能为空（不能为0）")
}
for _, id := range b.ItemRewardIds {
if id == itemId {
return fmt.Errorf("奖励物品ID%d已绑定勇者之塔%d层，无需重复添加", itemId, b.TowerLevel)
}
}
b.ItemRewardIds = append(b.ItemRewardIds, itemId)
return nil
}
// AddElfRewardId 为勇者之塔添加单个奖励精灵ID（避免重复）
func (b *BraveTowerConfig) AddElfRewardId(elfId uint32) error {
if elfId == 0 {
return errors.New("奖励精灵ID不能为空（不能为0）")
}
for _, id := range b.ElfRewardIds {
if id == elfId {
return fmt.Errorf("奖励精灵ID%d已绑定勇者之塔%d层，无需重复添加", elfId, b.TowerLevel)
}
}
b.ElfRewardIds = append(b.ElfRewardIds, elfId)
return nil
}
// RemoveBossId 从勇者之塔移除单个BOSS ID
func (b *BraveTowerConfig) RemoveBossId(bossId uint32) error {
if bossId == 0 {
return errors.New("BOSS ID不能为空（不能为0）")
}
for i, id := range b.BossIds {
if id == bossId {
b.BossIds = append(b.BossIds[:i], b.BossIds[i+1:]...)
return nil
}
}
return fmt.Errorf("勇者之塔%d层未绑定BOSS ID%d，无法移除", b.TowerLevel, bossId)
}
// RemoveItemRewardId 从勇者之塔移除单个奖励物品ID
func (b *BraveTowerConfig) RemoveItemRewardId(itemId uint32) error {
if itemId == 0 {
return errors.New("奖励物品ID不能为空（不能为0）")
}
for i, id := range b.ItemRewardIds {
if id == itemId {
b.ItemRewardIds = append(b.ItemRewardIds[:i], b.ItemRewardIds[i+1:]...)
return nil
}
}
return fmt.Errorf("勇者之塔%d层未绑定奖励物品ID%d，无法移除", b.TowerLevel, itemId)
}
// RemoveElfRewardId 从勇者之塔移除单个奖励精灵ID
func (b *BraveTowerConfig) RemoveElfRewardId(elfId uint32) error {
if elfId == 0 {
return errors.New("奖励精灵ID不能为空（不能为0）")
}
for i, id := range b.ElfRewardIds {
if id == elfId {
b.ElfRewardIds = append(b.ElfRewardIds[:i], b.ElfRewardIds[i+1:]...)
return nil
}
}
return fmt.Errorf("勇者之塔%d层未绑定奖励精灵ID%d，无法移除", b.TowerLevel, elfId)
}
// -------------------------- 表结构自动同步 --------------------------
func init() {
cool.CreateTable(&BraveTowerConfig{})
cool.CreateTable(&Tower600Config{})
}

18
modules/config/service/PetReward.go Normal file
View File

@@ -0,0 +1,18 @@
package service
import (
"blazing/cool"
"blazing/modules/config/model"
)
type PetRewardService struct {
*cool.Service
}
func NewPetRewardService() *PetRewardService {
return &PetRewardService{
&cool.Service{
Model: model.NewPetReward(),
},
}
}

18
modules/config/service/tower500.go Normal file
View File

@@ -0,0 +1,18 @@
package service
import (
"blazing/cool"
"blazing/modules/config/model"
)
type Tower500Service struct {
*cool.Service
}
func NewTower500Service() *Tower500Service {
return &Tower500Service{
&cool.Service{
Model: model.New500TowerConfig(),
},
}
}

18
modules/config/service/tower600.go Normal file
View File

@@ -0,0 +1,18 @@
package service
import (
"blazing/cool"
"blazing/modules/config/model"
)
type Tower600Service struct {
*cool.Service
}
func NewTower600Service() *Tower600Service {
return &Tower600Service{
&cool.Service{
Model: model.New600TowerConfig(),
},
}
}