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

修复战斗

Browse Source
This commit is contained in:
1
2025-11-15 22:17:43 +00:00
parent 4a4806fd82
commit 88cd1affe4
38 changed files with 708 additions and 847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
common/utils/task_test.go
View File

@@ -1,91 +0,0 @@
package utils
import (
"fmt"
"sync"
"testing"
"github.com/badu/bus"
)
func Test_event(b *testing.T) {
topic := bus.NewTopic[*Task]() //直接注册到用户
for i := 0; i < 1; i++ {
isdone := false
t := topic.Sub(func(v *Task) { //用户初始化时注册里程碑
if v.done { //如果任务完成
isdone = true
fmt.Println(v.id, "任务完成")
return
}
if v.cfunc != nil {
v.cont = v.cfunc(v.cont) //增加计数
}
if v.cont > 5 { //如果计数达到,标记任务完成
v.done = true
}
fmt.Println(v.id, "当前任务计数", v.cont, "是否完成", v.done)
})
if isdone { //如果任务完成,取消注册
t.Cancel()
}
}
task1 := &Task{id: 1, cfunc: func(t uint32) uint32 { //满足任务1后推定
//fmt.Println(1, "当前任务计数", t)
//实现自定义逻辑
//增加用户计数
//增加服务器总计数
return t + 1
}}
topic.Pub(task1)
topic.Pub(task1)
topic.Pub(&Task{id: 2, done: true})
topic.Pub(task1) //发送事件
task1.Complete()
fmt.Println("当前任务状态", task1.IsDone())
}
type TaskTree struct {
AllTasks []*Task //任务集合
mu sync.Mutex
}
// Various event types
const EventA = 0x01
type Task struct {
id uint32
cfunc func(uint32) uint32
cont uint32
done bool
}
func (e *Task) IsDone() bool {
return e.done
}
func (e *Task) Complete() {
e.done = true
}
func (e *Task) EventID() string {
return "YourInterestingEventName"
}
// Event type for testing purposes
type Event struct {
Data string
type1 uint32
}
// Type returns the event type
func (ev Event) Type() uint32 {
return ev.type1
}

15
logic/controller/fight_boss.go
View File

@@ -3,8 +3,10 @@ package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/fight"
"blazing/logic/service/fight/info"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
@@ -20,7 +22,18 @@ func (h Controller) PlayerFightBoss(data *fight.ChallengeBossInboundInfo, c *pla
var petid int
var mo *model.PetInfo
moinfo := &model.PlayerInfo{}
// 新手任务2（选择不同精灵）
// <Map ID="8" Name="机械舱" InitX="456" InitY="143">
// <Bosses>
// <Boss TaskID="4" AppearTime="0 23" BossVisible="0" >
// <BossMon MonID="1 4 7" Hp="10" Lv="2" />
// </Boss>
// <Boss AppearTime="0 23" BossVisible="0" >
// <!--boss for task 526 -->
// <BossMon MonID="506" Hp="55" Lv="18" NewSeIdxs="80 157 158" />
// </Boss>
// </Bosses>
// </Map>
if c.Info.MapID == 515 && data.BossId == 0 { //说明是新手,随机生成
switch c.Info.PetList[0].ID {

1
logic/controller/fight_leitai.go
View File

@@ -2,6 +2,7 @@ package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/fight"
"blazing/logic/service/fight/info"
"blazing/logic/service/player"

1
logic/controller/fight_pvp_king.go
View File

@@ -2,6 +2,7 @@ package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/fight"
"blazing/logic/service/fight/info"
"blazing/logic/service/player"

1
logic/controller/fight_pvp_withplayer.go
View File

@@ -2,6 +2,7 @@ package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/fight"
"blazing/logic/service/fight/info"
"blazing/logic/service/player"

18
logic/controller/login.go
View File

@@ -8,10 +8,8 @@ import (
"blazing/common/socket/errorcode"
"blazing/logic/service/common"
"blazing/logic/service/user"
"blazing/logic/service/maps"
"blazing/logic/service/player"
"blazing/logic/service/space"
blservice "blazing/modules/blazing/service"
@@ -19,7 +17,6 @@ import (
"time"
"github.com/gogf/gf/v2/os/gtime"
"github.com/jinzhu/copier"
"github.com/panjf2000/gnet/v2"
)
@@ -99,19 +96,8 @@ func (h *Controller) Login(data *user.MAIN_LOGIN_IN, c gnet.Conn) (result *user.
result = user.NewOutInfo() //设置登录消息
result.PlayerInfo = *t.Info
defer func() {
tt := maps.NewOutInfo()
copier.CopyWithOption(tt, t.Info, copier.Option{DeepCopy: true})
//copier.Copy(t.Info, tt)
t1 := player.NewTomeeHeader(2001, t.Info.UserID)
space.GetSpace(t.Info.MapID).User.Range(func(playerID uint32, player common.PlayerI) bool {
player.SendPack(t1.Pack(tt))
return false
})
space.GetSpace(t.Info.MapID).User.Store(t.Info.UserID, t)
}()
go space.GetSpace(t.Info.MapID).EnterMap(t)
return result, 0

24
logic/controller/map.go
View File

@@ -6,24 +6,24 @@ import (
"blazing/logic/service/common"
"blazing/logic/service/maphot"
"blazing/logic/service/maps"
"blazing/logic/service/maps/info"
"blazing/logic/service/player"
"blazing/logic/service/space"
"github.com/jinzhu/copier"
)
func (h *Controller) MapEnter(data *maps.InInfo, c *player.Player) (result *maps.OutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
func (h *Controller) MapEnter(data *maps.InInfo, c *player.Player) (result *info.OutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
c.Info.MapID = data.MapId //登录地图
space.GetSpace(c.Info.MapID).User.Store(c.Info.UserID, c) //添加玩家
result = maps.NewOutInfo()
result = info.NewOutInfo()
c.Info.Pos = data.Point
copier.Copy(result, c.Info)
data.Broadcast(c.Info.MapID, *result) //同步广播
return nil, -1
go space.GetSpace(c.Info.MapID).EnterMap(c) //玩家进入地图
return result, -1
}
func (h Controller) MapHot(data *maphot.InInfo, c *player.Player) (result *maphot.OutInfo, err errorcode.ErrorCode) {
@@ -34,23 +34,23 @@ func (h Controller) MapHot(data *maphot.InInfo, c *player.Player) (result *mapho
return
}
func (h *Controller) MapLeave(data *maps.LeaveMapInboundInfo, c *player.Player) (result *space.LeaveMapOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
func (h *Controller) MapLeave(data *maps.LeaveMapInboundInfo, c *player.Player) (result *info.LeaveMapOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
//result = &maps.LeaveMapOutboundInfo{UserID: c.GetUserID()}
c.Canmon = false
c.Changemap = true //可以刷怪
data.Broadcast(c.Info.MapID, space.LeaveMapOutboundInfo{UserID: c.Info.UserID}) //同步广播
space.GetSpace(c.Info.MapID).User.Delete(c.Info.UserID)
c.Changemap = true //可以刷怪
//data.Broadcast(c.Info.MapID, info.LeaveMapOutboundInfo{UserID: c.Info.UserID}) //同步广播
go space.GetSpace(c.Info.MapID).LeaveMap(c) //玩家离开地图
// 如果有正在运行的刷怪协程，发送停止信号
c.Info.MapID = 0 // 重置当前地图
return nil, -1
return &info.LeaveMapOutboundInfo{UserID: c.Info.UserID}, -1
}
func (h *Controller) MapList(data *maps.ListMapPlayerInboundInfo, c *player.Player) (result *maps.ListMapPlayerOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
result = &maps.ListMapPlayerOutboundInfo{}
result.Player = make([]maps.OutInfo, 0)
result.Player = make([]info.OutInfo, 0)
space.GetSpace(c.Info.MapID).User.Range(func(playerID uint32, player common.PlayerI) bool {
result1 := maps.NewOutInfo()
result1 := info.NewOutInfo()
copier.CopyWithOption(result1, player.GetInfo(), copier.Option{DeepCopy: true})
result.Player = append(result.Player, *result1)
result.Player = LastFourElements(result.Player)

520
logic/controller/task.go
View File

@@ -6,6 +6,8 @@ import (
"blazing/logic/service/player"
"blazing/logic/service/task"
"blazing/modules/blazing/model"
"github.com/jinzhu/copier"
)
/**
@@ -59,507 +61,31 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
}
c.Info.TaskList[data.TaskId-1] = 3
result = &task.CompleteTaskOutboundInfo{}
result.ItemList = make([]task.ItemInfo, 0)
result.TaskId = data.TaskId
// 根据任务ID和选择分支（OutState）处理奖励
switch data.TaskId {
// 新手任务1
case 85:
// out_id=1（默认分支）的奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 100027, ItemCount: 1}, // 新手帽（默认数量1）
task.ItemInfo{ItemId: 100028, ItemCount: 1}, // 新手腰带
task.ItemInfo{ItemId: 500001, ItemCount: 1}, // 精灵仓库
task.ItemInfo{ItemId: 500502, ItemCount: 1}, // 精灵恢复仓
//task.ItemInfo{ItemId: 500503, ItemCount: 1}, // 分子转化仪
)
// 新手任务2（选择不同精灵）
case 86:
var petType int
// 根据out_id（data.OutState）选择宠物类型
switch data.OutState {
case 1:
petType = 1 // 布布种子
case 2:
petType = 7 // 小火猴
case 3:
petType = 4 // 伊优
default:
// 默认给布布种子（或日志告警）
petType = 1
// log.Printf("任务86未知分支out_id=%d，默认奖励布布种子", data.OutState)
}
// 生成宠物（pet_dv=31，锁个体）
r := c.GenPetInfo(petType, 31, -1, 0, 0, 50)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 新手任务3
case 87:
// out_id=1的奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 300001, ItemCount: 5}, // 普通胶囊x5
task.ItemInfo{ItemId: 300011, ItemCount: 5}, // 初级体力药剂x3
)
// 新手任务4
case 88:
// out_id=1的奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 1, ItemCount: 50000}, // 赛尔豆x50000
task.ItemInfo{ItemId: 3, ItemCount: 50000}, // 累积经验x50000
task.ItemInfo{ItemId: 5, ItemCount: 20}, // 金豆x20
task.ItemInfo{ItemId: 300650, ItemCount: 3}, // 全能学习力遗忘器x3
task.ItemInfo{ItemId: 300651, ItemCount: 6}, // 全能学习力注入器x6
)
// 克洛斯星的皮皮
case 90:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 经验x1000
)
// 西塔的珍贵回忆
case 8:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 500510, ItemCount: 1}, // 记忆晶体x1
)
// 进入神秘通道
case 9:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 100059, ItemCount: 1}, // 电能锯子x1
)
// 神秘通道拼图（无奖励物品）
case 10:
// 无物品奖励，无需处理
// 精灵广场拿石头（无奖励物品）
case 12:
// 无物品奖励，无需处理
// 先锋队招募
case 19:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 积累经验x3000
)
// 新船员的考验
case 25:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 400501, ItemCount: 10}, // 神奇扭蛋牌x10
)
// 遗迹中的精灵信号（奖励奇塔）
case 28:
// out_id=1，宠物类型102（奇塔）
r := c.GenPetInfo(102, 31, -1, 0, 0, 5) // pet_dv默认-1（随机个体）
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 帕诺星系星球测绘
case 37:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
task.ItemInfo{ItemId: 700452, ItemCount: 1}, // 中型智慧芯片x1
task.ItemInfo{ItemId: 100178, ItemCount: 1}, // 勘察头盔x1
task.ItemInfo{ItemId: 100179, ItemCount: 1}, // 勘察护腕x1
task.ItemInfo{ItemId: 100180, ItemCount: 1}, // 勘察腰带x1
task.ItemInfo{ItemId: 100181, ItemCount: 1}, // 勘察军靴x1
)
// 时空之门（奖励迪卢卡）
case 40:
// out_id=1，宠物类型139（迪卢卡）
r := c.GenPetInfo(139, 31, -1, 0, 0, 5)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 突围磁风暴
case 47:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 5000}, // 累积经验x5000
task.ItemInfo{ItemId: 1, ItemCount: 5000}, // 赛尔豆x5000
task.ItemInfo{ItemId: 500585, ItemCount: 1}, // 磁力光束枪台x1
)
// 神秘失踪的爱丽丝
case 48:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
task.ItemInfo{ItemId: 700452, ItemCount: 2}, // 中型智慧芯片x2
)
// 密林中的托尼（奖励托尼+物品）
case 49:
// 1. 奖励宠物：托尼（类型158）
r := c.GenPetInfo(158, 31, -1, 0, 0, 5)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 2. 奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 700452, ItemCount: 2}, // 中型智慧芯片x2
)
// 谁偷走了雪球能源？
case 52:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 400021, ItemCount: 10}, // 雪球能源x10
task.ItemInfo{ItemId: 100254, ItemCount: 1}, // 斯诺纪念x1
)
// 米鲁族的两个小不点
case 54:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 5000}, // 累积经验x5000
task.ItemInfo{ItemId: 400021, ItemCount: 10}, // 雪球能源x10
)
// 米鲁族食王选拔赛
case 57:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 斯诺岩洞的不解之谜
case 58:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
task.ItemInfo{ItemId: 400021, ItemCount: 10}, // 雪球能源x10
)
// 新型试作机SR-01同步调试
case 63:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 铸造斯诺冰冠
case 64:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
task.ItemInfo{ItemId: 400021, ItemCount: 10}, // 雪球能源x10
)
// 露希欧星勘察
case 65:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 合金强化试验
case 66:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 资料室的神秘事件
case 68:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 宇宙遭遇站
case 69:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 船体紧急修复
case 70:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 赛尔号大整修（奖励TOE+物品）
case 71:
// 1. 奖励宠物：TOE（类型213）
r := c.GenPetInfo(213, 31, -1, 0, 0, 5)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 2. 奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 累积经验x1000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 船长搜救任务
case 72:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 秘制改良机SR-02
case 73:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 100303, ItemCount: 1}, // SR-02铠甲x1
task.ItemInfo{ItemId: 400055, ItemCount: 30}, // 变形能量块x30
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
)
// 露希欧星历险
case 74:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 积累经验x3000
)
// 哈莫的童年片段一
case 75:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 100324, ItemCount: 1}, // 龙之纪念x1
)
// 寻找哈莫雷特的族人
case 79:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 3000}, // 累积经验x3000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
)
// 重铸贾斯丁站长
case 80:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 3000}, // 赛尔豆x3000
)
// 守候宿命的追随者
case 81:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 累积经验x1000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 光暗之迷
case 83:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 累积经验x1000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 星球改造计划
case 84:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
)
// 试炼之塔的磨练
case 89:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 500}, // 累积经验x500
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 月光下的约定
case 91:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
task.ItemInfo{ItemId: 400124, ItemCount: 1}, // 艾贝多芬的精元x1
)
// 站长归来（奖励尼布+物品）
case 92:
// 1. 奖励宠物：尼布（类型95）
r := c.GenPetInfo(95, 31, -1, 0, 0, 5)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 2. 奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
)
// 云霄星的新来客
case 93:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 累积经验x1000
task.ItemInfo{ItemId: 1, ItemCount: 500}, // 赛尔豆x500
)
// 初识星球能源
case 94:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 500}, // 累积经验x500
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 宇宙中的黑色旋涡（两个奖励分支）
case 95:
switch data.OutState {
case 1: // 分支1：刺蜂套装
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 4000}, // 累积经验x4000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
task.ItemInfo{ItemId: 100346, ItemCount: 1}, // 刺蜂重盔x1
task.ItemInfo{ItemId: 100347, ItemCount: 1}, // 刺蜂护肩x1
task.ItemInfo{ItemId: 100348, ItemCount: 1}, // 刺蜂腰带x1
task.ItemInfo{ItemId: 100349, ItemCount: 1}, // 刺蜂滚轮x1
)
case 2: // 分支2：锡蝶套装
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 4000}, // 累积经验x4000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
task.ItemInfo{ItemId: 100350, ItemCount: 1}, // 锡蝶重盔x1
task.ItemInfo{ItemId: 100351, ItemCount: 1}, // 锡蝶护肩x1
task.ItemInfo{ItemId: 100352, ItemCount: 1}, // 锡蝶腰带x1
task.ItemInfo{ItemId: 100353, ItemCount: 1}, // 锡蝶滚轮x1
)
default:
// 默认给分支1奖励
// log.Printf("任务95未知分支out_id=%d，默认奖励刺蜂套装", data.OutState)
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 4000},
task.ItemInfo{ItemId: 1, ItemCount: 2000},
task.ItemInfo{ItemId: 100346, ItemCount: 1},
task.ItemInfo{ItemId: 100347, ItemCount: 1},
task.ItemInfo{ItemId: 100348, ItemCount: 1},
task.ItemInfo{ItemId: 100349, ItemCount: 1},
)
}
// 旅途中的伙伴
case 96:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 500}, // 累积经验x500
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 我是音乐小麦霸
case 97:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 1000}, // 累积经验x1000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 尼布守卫战
case 98:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 1000}, // 赛尔豆x1000
)
// 寻找迷失的心（奖励史空+物品）
case 133:
// 1. 奖励宠物：史空（类型381）
r := c.GenPetInfo(381, 31, -1, 0, 0, 5)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
// 2. 奖励物品
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 2000}, // 累积经验x2000
task.ItemInfo{ItemId: 1, ItemCount: 2000}, // 赛尔豆x2000
)
// 教官考核
case 201:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 100062, ItemCount: 1}, // 教官指挥棒x1
)
// 领取谱尼真身（需校验物品，奖励谱尼精元）
case 300:
// 注意：此处省略“check节点”的物品校验逻辑（需先检查玩家背包是否有7个裂片）
// 实际业务中需先校验，通过后再发奖励
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 400150, ItemCount: 1}, // 谱尼的精元x1
)
// 每日任务之毛毛
case 401:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x2000
)
// 每日任务之小火猴
case 402:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x20000
)
// 每日任务之布布种子
case 403:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x20000
)
// 每日任务之依优
case 404:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x20000
)
// 每日任务之比比鼠
case 405:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x2000
)
// 每日任务之幽浮
case 406:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x2000
)
// 每日任务之利牙鱼
case 407:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 3, ItemCount: 20000}, // 积累经验x2000
)
// 每日任务之谱尼扭蛋牌
case 462:
result.ItemList = append(result.ItemList,
task.ItemInfo{ItemId: 400501, ItemCount: 5}, // 神奇扭蛋牌x5
)
default:
// 未定义的任务ID，可添加日志
// log.Printf("未处理的任务ID: %d", data.TaskId)
result = &task.CompleteTaskOutboundInfo{
TaskId: data.TaskId,
ItemList: make([]task.ItemInfo, 0),
}
//提交任务
//task.Tasktopic.Pub(*data)
tt := task.Get_Task_Info(*data)
result.ItemList = tt.ItemList
if tt.PetTypeId != 0 {
r := c.GenPetInfo(int(tt.PetTypeId), 31, -1, 0, 0, 50)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.PetAdd(*r)
}
var ttt []model.SingleItemInfo
for _, v := range result.ItemList {
ttt = append(ttt, model.SingleItemInfo{ItemId: v.ItemId, ItemCnt: v.ItemCount})
}
r := c.ItemAdd(ttt...)
tempItemList := make([]task.ItemInfo, 0)
for _, v := range result.ItemList {
for _, v1 := range r {
if v1.ItemId == v.ItemId {
tempItemList = append(tempItemList, task.ItemInfo{ItemId: v.ItemId, ItemCount: v.ItemCount})
}
}
copier.Copy(ttt, result.ItemList)
}
result.ItemList = tempItemList //临时变量为了防止报错的时候返回数据没问题
return result, 0
copier.Copy(result.ItemList, c.ItemAdd(ttt...))
return result, -1 //通过PUB/SUB回包
}
/**

3
logic/service/common/playeri.go
View File

@@ -2,6 +2,7 @@ package common
import (
"blazing/logic/service/fight/info"
maps "blazing/logic/service/maps/info"
"blazing/modules/blazing/model"
)
@@ -19,4 +20,6 @@ type PlayerI interface {
SendUsePetItemInfo(info.UsePetIteminfo)
SendLoadPercent(info.LoadPercentOutboundInfo)
SetFightC(FightI)
SendLeaveMapInfo(b maps.LeaveMapOutboundInfo)
SendEnterMapInfo(b maps.OutInfo)
}

1
logic/service/fight/action.go
View File

@@ -3,6 +3,7 @@ package fight
import (
"blazing/common/data/xmlres"
"blazing/cool"
"blazing/logic/service/common"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"

1
logic/service/fight/cmd.go
View File

@@ -3,6 +3,7 @@ package fight
import (
_ "blazing/logic/service/fight/effect"
"blazing/logic/service/fight/info"
"blazing/logic/service/player"
)

4
logic/service/fight/effect/EffectDefeatTrigger.go
View File

@@ -107,7 +107,7 @@ func (e *EffectDefeatTrigger) triggerHealSelfOnDefeat(at info.AttackValue) {
}
// triggerReduceNextHPOnDefeat：击败对方后，减少对方下次出战精灵最大体力的1/n（对应Effect67）
func (e *EffectDefeatTrigger) triggerReduceNextHPOnDefeat(at info.AttackValue) {
func (e *EffectDefeatTrigger) triggerReduceNextHPOnDefeat(_ info.AttackValue) {
// 计算伤害量：对方下只精灵最大体力 / n（n=SideEffectArgs[0]）
nextMaxHP := e.Ctx().Opp.CurrentPet.Info.MaxHp // 假设CurrentPet为下次出战精灵
damageAmount := decimal.NewFromInt(int64(nextMaxHP)).Div(decimal.NewFromInt(int64(e.SideEffectArgs[0])))
@@ -123,7 +123,7 @@ func (e *EffectDefeatTrigger) triggerReduceNextHPOnDefeat(at info.AttackValue) {
// SideEffectArgs[0] = m（触发概率，如30=30%）
// SideEffectArgs[1] = XX等级类型（如1=攻击等级，对应info.LevelType枚举）
// SideEffectArgs[2] = n（提升的等级值，如1=+1级）
func (e *EffectDefeatTrigger) triggerLevelUpOnDefeat(at info.AttackValue) {
func (e *EffectDefeatTrigger) triggerLevelUpOnDefeat(_ info.AttackValue) {
// 1. 检查参数是否足够
if len(e.SideEffectArgs) < 3 {
return

1
logic/service/fight/effect/effect_35.go
View File

@@ -13,7 +13,6 @@ type Effect35 struct {
}
func (e *Effect35) Skill_Hit() bool {
s
if e.Ctx().SkillEntity == nil {
return true

1
logic/service/fight/fightc.go
View File

@@ -2,6 +2,7 @@ package fight
import (
"blazing/common/utils"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"

1
logic/service/fight/input.go
View File

@@ -2,6 +2,7 @@ package fight
import (
"blazing/cool"
"blazing/logic/service/common"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"

4
logic/service/fight/input/ctx.go
View File

@@ -1,8 +1,6 @@
package input
import (
"blazing/logic/service/fight/info"
)
import "blazing/logic/service/fight/info"
type Ctx struct {
Our *Input //施加方

1
logic/service/fight/input/effect.go
View File

@@ -3,6 +3,7 @@ package input
import (
"blazing/common/utils"
"blazing/logic/service/fight/info"
"fmt"
"blazing/modules/blazing/model"

1
logic/service/fight/input/fight.go
View File

@@ -4,6 +4,7 @@ import (
element "blazing/common/data/Element"
"blazing/common/data/xmlres"
"blazing/common/utils"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"math/rand"

1
logic/service/fight/input/prop.go
View File

@@ -3,6 +3,7 @@ package input
import (
"blazing/common/utils"
"blazing/logic/service/fight/info"
"fmt"
)

1
logic/service/fight/loop.go
View File

@@ -2,6 +2,7 @@ package fight
import (
"blazing/common/data/xmlres"
"blazing/logic/service/common"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"

135
logic/service/maps/info/info.go Normal file
View File

@@ -0,0 +1,135 @@
package info
import (
"blazing/modules/blazing/model"
"github.com/creasty/defaults"
)
// 这里存储星球的map
//var planetmap utils.SyncMap[] //= space.NewSyncMap()
// PeopleInfo PeopleInfo类，实现OutboundMessage接口
type OutInfo struct {
UserID uint32 `struc:"uint32" fieldDesc:"米米号" json:"user_id"`
// 16字节昵称
Nick string `struc:"[16]byte" fieldDesc:"16字节昵称" json:"nick"`
// 机器人人物颜色 00 rgb
Color uint32 `struc:"uint32" fieldDesc:"机器人人物颜色 00 rgb" json:"color"`
// 固定值0
Texture uint32 `struc:"uint32" fieldDesc:"固定值0" json:"texture"`
// 暂时不明建议先给固定值0
Vip uint16 ` json:"vip"`
// 暂时不明建议先给固定值15
Viped uint16 ` default:"15" json:"viped"`
// 暂时不明建议先给固定值1
VipStage uint32 `struc:"uint32" fieldDesc:"暂时不明建议先给固定值1" json:"vip_stage"`
// 人物状态 =0 步行 !=0 飞行
ActionType uint32 `struc:"uint32" fieldDesc:"人物状态 =0 步行 !=0 飞行" json:"action_type"`
// 上线的地图id
Pos model.Pos `fieldDesc:"上线的地图id" json:"pos"`
// 动作, 大于10000时为蹲下
Action uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"action"`
// 动作, 默认情况下为2, 蹲下为3
Direction uint32 `struc:"uint32" default:"2" fieldDesc:"暂时不明给2" json:"direction"`
// 变形套装ID
ChangeShape uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"change_shape"`
// 暂时不明给0
SpiritTime uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"spirit_time"`
// 暂时不明给0
SpiritID uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"spirit_id"`
// 宠物 ID 暂时无法测试，给 0
PetDV uint32 `struc:"uint32" fieldDesc:"宠物ID暂时无法测试, 给0" json:"pet_dv"`
// 宠物闪光暂时无法测试，给 0
PetShiny uint32 `struc:"uint32" fieldDesc:"宠物闪光暂时无法测试, 给0" json:"pet_shiny"`
// 宠物皮肤暂时无法测试，给 0
PetSkin uint32 `struc:"uint32" fieldDesc:"宠物皮肤暂时无法测试, 给0" json:"pet_skin"`
// 填充字符
Reserved uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved"`
// 填充字符
Reserved1 uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved1"`
// 填充字符
Reserved2 uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved2"`
// 暂时不明给0
FightFlag uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"fight_flag"`
// 教官ID
TeacherID uint32 `struc:"uint32" fieldDesc:"教官ID" json:"teacher_id"`
// 学员ID
StudentID uint32 `struc:"uint32" fieldDesc:"学员ID" json:"student_id"`
// nono状态 固定值-1
NonoState uint32 `struc:"uint32" default:"0xFFFFFFFF" fieldDesc:"nono状态 固定值-1" json:"nono_state"`
// nono颜色 00 FF FF FF
NonoColor uint32 `struc:"uint32" fieldDesc:"nono颜色 00 FF FF FF" json:"nono_color"`
// 是不是超能nono 固定值1
SuperNono uint32 `struc:"uint32" default:"1" fieldDesc:"是不是超能nono 固定值1" json:"super_nono"`
// 暂时不明给0
PlayerForm uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"player_form"`
// 暂时不明给0
TransTime uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"trans_time"`
// 暂时不明给0
TeamID uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_id"`
// 暂时不明给0
TeamCoreCount uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_core_count"`
// 暂时不明给0
TeamIsShow uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_is_show"`
// 暂时不明给0
LogoBg uint16 `json:"logo_bg"`
// 暂时不明给0
LogoIcon uint16 ` json:"logo_icon"`
// 暂时不明给0
LogoColor uint16 `json:"logo_color"`
// 暂时不明给0
TxtColor uint16 `json:"txt_color"`
// 4字节
LogoWord [4]byte `struc:"[4]byte" fieldDesc:"4字节" json:"logo_word"`
ClothesLen uint32 `struc:"sizeof=Clothes" fieldDesc:"穿戴装备的信息" json:"clothes_len"`
// 穿戴装备的信息
Clothes []model.PeopleItemInfo `fieldDesc:"穿戴装备的信息" json:"clothes"`
}
func NewOutInfo() *OutInfo {
l := &OutInfo{}
// 自动填充 struct tag 里的 default 值
if err := defaults.Set(l); err != nil {
panic(err) // 方便发现 default 设置错误
}
return l
}
type LeaveMapOutboundInfo struct {
// 米米号
UserID uint32 `struc:"uint32" fieldDesc:"米米号" json:"user_id"`
}

143
logic/service/maps/mapin.go
View File

@@ -1,15 +1,15 @@
package maps
import (
"blazing/logic/service/common"
"blazing/logic/service/player"
"blazing/logic/service/space"
"blazing/modules/blazing/model"
"github.com/creasty/defaults"
)
type LeaveMapInboundInfo struct {
Head player.TomeeHeader `cmd:"2002" struc:"[0]pad"` //切换地图
}
type InInfo struct {
Head player.TomeeHeader `cmd:"2001" struc:"[0]pad"` //切换地图
// 地图类型
@@ -22,138 +22,3 @@ type InInfo struct {
// Reverse2: 暂定 占位字符2
//Reverse2 string `struc:"[2]byte"`
}
func (t *InInfo) Broadcast(mapid uint32, o OutInfo) {
space.GetSpace(mapid).User.Range(func(k uint32, v common.PlayerI) (stop bool) {
t.Head.Result = 0
v.SendPack(t.Head.Pack(&o))
return false
})
}
// 这里存储星球的map
//var planetmap utils.SyncMap[] //= space.NewSyncMap()
// PeopleInfo PeopleInfo类，实现OutboundMessage接口
type OutInfo struct {
UserID uint32 `struc:"uint32" fieldDesc:"米米号" json:"user_id"`
// 16字节昵称
Nick string `struc:"[16]byte" fieldDesc:"16字节昵称" json:"nick"`
// 机器人人物颜色 00 rgb
Color uint32 `struc:"uint32" fieldDesc:"机器人人物颜色 00 rgb" json:"color"`
// 固定值0
Texture uint32 `struc:"uint32" fieldDesc:"固定值0" json:"texture"`
// 暂时不明建议先给固定值0
Vip uint16 ` json:"vip"`
// 暂时不明建议先给固定值15
Viped uint16 ` default:"15" json:"viped"`
// 暂时不明建议先给固定值1
VipStage uint32 `struc:"uint32" fieldDesc:"暂时不明建议先给固定值1" json:"vip_stage"`
// 人物状态 =0 步行 !=0 飞行
ActionType uint32 `struc:"uint32" fieldDesc:"人物状态 =0 步行 !=0 飞行" json:"action_type"`
// 上线的地图id
Pos model.Pos `fieldDesc:"上线的地图id" json:"pos"`
// 动作, 大于10000时为蹲下
Action uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"action"`
// 动作, 默认情况下为2, 蹲下为3
Direction uint32 `struc:"uint32" default:"2" fieldDesc:"暂时不明给2" json:"direction"`
// 变形套装ID
ChangeShape uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"change_shape"`
// 暂时不明给0
SpiritTime uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"spirit_time"`
// 暂时不明给0
SpiritID uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"spirit_id"`
// 宠物 ID 暂时无法测试，给 0
PetDV uint32 `struc:"uint32" fieldDesc:"宠物ID暂时无法测试, 给0" json:"pet_dv"`
// 宠物闪光暂时无法测试，给 0
PetShiny uint32 `struc:"uint32" fieldDesc:"宠物闪光暂时无法测试, 给0" json:"pet_shiny"`
// 宠物皮肤暂时无法测试，给 0
PetSkin uint32 `struc:"uint32" fieldDesc:"宠物皮肤暂时无法测试, 给0" json:"pet_skin"`
// 填充字符
Reserved uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved"`
// 填充字符
Reserved1 uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved1"`
// 填充字符
Reserved2 uint32 `struc:"uint32" fieldDesc:"填充字符" json:"reserved2"`
// 暂时不明给0
FightFlag uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"fight_flag"`
// 教官ID
TeacherID uint32 `struc:"uint32" fieldDesc:"教官ID" json:"teacher_id"`
// 学员ID
StudentID uint32 `struc:"uint32" fieldDesc:"学员ID" json:"student_id"`
// nono状态 固定值-1
NonoState uint32 `struc:"uint32" default:"0xFFFFFFFF" fieldDesc:"nono状态 固定值-1" json:"nono_state"`
// nono颜色 00 FF FF FF
NonoColor uint32 `struc:"uint32" fieldDesc:"nono颜色 00 FF FF FF" json:"nono_color"`
// 是不是超能nono 固定值1
SuperNono uint32 `struc:"uint32" default:"1" fieldDesc:"是不是超能nono 固定值1" json:"super_nono"`
// 暂时不明给0
PlayerForm uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"player_form"`
// 暂时不明给0
TransTime uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"trans_time"`
// 暂时不明给0
TeamID uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_id"`
// 暂时不明给0
TeamCoreCount uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_core_count"`
// 暂时不明给0
TeamIsShow uint32 `struc:"uint32" fieldDesc:"暂时不明给0" json:"team_is_show"`
// 暂时不明给0
LogoBg uint16 `json:"logo_bg"`
// 暂时不明给0
LogoIcon uint16 ` json:"logo_icon"`
// 暂时不明给0
LogoColor uint16 `json:"logo_color"`
// 暂时不明给0
TxtColor uint16 `json:"txt_color"`
// 4字节
LogoWord [4]byte `struc:"[4]byte" fieldDesc:"4字节" json:"logo_word"`
ClothesLen uint32 `struc:"sizeof=Clothes" fieldDesc:"穿戴装备的信息" json:"clothes_len"`
// 穿戴装备的信息
Clothes []model.PeopleItemInfo `fieldDesc:"穿戴装备的信息" json:"clothes"`
}
func NewOutInfo() *OutInfo {
l := &OutInfo{}
// 自动填充 struct tag 里的 default 值
if err := defaults.Set(l); err != nil {
panic(err) // 方便发现 default 设置错误
}
return l
}

7
logic/service/maps/maplist.go
View File

@@ -1,6 +1,9 @@
package maps
import "blazing/logic/service/player"
import (
"blazing/logic/service/maps/info"
"blazing/logic/service/player"
)
type ListMapPlayerInboundInfo struct {
Head player.TomeeHeader `cmd:"2003" struc:"[0]pad"` //切换地图
@@ -10,5 +13,5 @@ type ListMapPlayerOutboundInfo struct {
PlayersLen uint32 `struc:"sizeof=Player" json:"player_len"`
// 穿戴装备的信息
Player []OutInfo ` json:"player"`
Player []info.OutInfo ` json:"player"`
}

21
logic/service/maps/mapout.go
View File

@@ -1,21 +0,0 @@
package maps
import (
"blazing/logic/service/common"
"blazing/logic/service/player"
"blazing/logic/service/space"
)
type LeaveMapInboundInfo struct {
Head player.TomeeHeader `cmd:"2002" struc:"[0]pad"` //切换地图
}
func (t *LeaveMapInboundInfo) Broadcast(mapid uint32, o space.LeaveMapOutboundInfo) {
space.GetSpace(mapid).User.Range(func(playerID uint32, player common.PlayerI) bool {
t.Head.Result = 0
player.SendPack(t.Head.Pack(&o))
return false
})
}

6
logic/service/player/ai.go
View File

@@ -2,6 +2,7 @@ package player
import (
"blazing/logic/service/fight/info"
maps "blazing/logic/service/maps/info"
"blazing/modules/blazing/model"
)
@@ -16,7 +17,12 @@ func (f *AI_player) SendPack(b []byte) error {
return nil
}
func (p *AI_player) SendLeaveMapInfo(b maps.LeaveMapOutboundInfo) {
}
func (p *AI_player) SendEnterMapInfo(b maps.OutInfo) {
}
func (f *AI_player) SendReadyToFightInfo(gg info.FightStartOutboundInfo) {
//fmt.Println(gg)

18
logic/service/player/base.go
View File

@@ -39,12 +39,12 @@ func (f *baseplayer) GetPlayerCaptureContext() *info.PlayerCaptureContext {
return f.PlayerCaptureContext
}
// 计算整数的二进制1的个数（Integer.bitCount）
func bitsCount(n int) int {
count := 0
for n > 0 {
count += n & 1
n >>= 1
}
return count
}
// // 计算整数的二进制1的个数（Integer.bitCount）
// func bitsCount(n int) int {
// count := 0
// for n > 0 {
// count += n & 1
// n >>= 1
// }
// return count
// }

12
logic/service/player/cmd.go
View File

@@ -2,6 +2,7 @@ package player
import (
"blazing/logic/service/fight/info"
maps "blazing/logic/service/maps/info"
)
func (p *Player) SendAttackValue(b info.AttackValueS) {
@@ -10,7 +11,18 @@ func (p *Player) SendAttackValue(b info.AttackValueS) {
p.SendPack(t1.Pack(&b)) //准备包由各自发,因为协议不一样
}
func (p *Player) SendLeaveMapInfo(b maps.LeaveMapOutboundInfo) {
t1 := NewTomeeHeader(2002, p.Info.UserID)
p.SendPack(t1.Pack(&b)) //准备包由各自发,因为协议不一样
}
func (p *Player) SendEnterMapInfo(b maps.OutInfo) {
t1 := NewTomeeHeader(2001, p.Info.UserID)
p.SendPack(t1.Pack(&b)) //准备包由各自发,因为协议不一样
}
func (p *Player) SendChangePet(b info.ChangePetInfo) {
t1 := NewTomeeHeader(2407, p.Info.UserID)

2
logic/service/player/fight.go
View File

@@ -2,8 +2,8 @@ package player
import (
"blazing/logic/service/common"
"blazing/logic/service/fight/info"
"blazing/logic/service/space"
)

29
logic/service/player/pack.go
View File

@@ -4,6 +4,7 @@ import (
"blazing/common/socket/errorcode"
"blazing/common/utils/bytearray"
"blazing/cool"
"encoding/binary"
"sync"
"context"
@@ -236,17 +237,23 @@ func (h *ClientData) OnEvent(v []byte) {
}
}()
header := TomeeHeader{}
tempdata := bytearray.CreateByteArray(v)
header.Len, _ = tempdata.ReadUInt32()
header.Version, _ = tempdata.ReadByte()
header.CMD, _ = tempdata.ReadUInt32()
//header.CMD = cmd.EnumCommandID(_CMD)
header.UserID, _ = tempdata.ReadUInt32()
header.Result, _ = tempdata.ReadUInt32()
header.Data = XORDecrypt(tempdata.BytesAvailable(), "CWF")
var header TomeeHeader
// 解析Len（0-3字节）
header.Len = binary.BigEndian.Uint32(v[0:4])
// 解析Version（第4字节）
header.Version = v[4]
// 解析CMD（5-8字节）
header.CMD = binary.BigEndian.Uint32(v[5:9])
// 解析UserID（9-12字节）
header.UserID = binary.BigEndian.Uint32(v[9:13])
// 解析Result（13-16字节）
header.Result = binary.BigEndian.Uint32(v[13:17])
// 解析数据部分（17字节之后）
if len(v) > 17 {
header.Data = XORDecrypt(v[17:], "CWF")
} else {
header.Data = []byte{} // 数据部分为空时显式初始化
}
if header.CMD > 1001 {
if h.Conn.Context().(*ClientData).Player == nil {
cool.Loger.Error(context.TODO(), header.UserID, "账号未注册")

32
logic/service/player/player.go
View File

@@ -5,14 +5,10 @@ import (
"blazing/common/socket/errorcode"
"blazing/common/utils"
"blazing/cool"
"blazing/logic/service/fight/info"
"math/rand"
"strings"
"blazing/logic/service/common"
"blazing/logic/service/fight/info"
"blazing/logic/service/space"
"blazing/modules/blazing/model"
blservice "blazing/modules/blazing/service"
"context"
@@ -220,7 +216,7 @@ func replaceOneNumber(original [3]int) ([3]int, int, int) {
return newNumbers, removedNum, newNum
}
// 添加物品
// 添加物品 返回成功添加的物品
func (p *Player) ItemAdd(t ...model.SingleItemInfo) (result []model.SingleItemInfo) {
var ttt []model.SingleItemInfo
for _, v := range t {
@@ -298,27 +294,3 @@ func (p *Player) Cheak(b error) {
}
}
func LeaveMap(c common.PlayerI) {
if c == nil {
return
}
if c.GetInfo() == nil {
return
}
if c.GetInfo().MapID == 0 {
return
}
t := NewTomeeHeader(2002, c.GetInfo().UserID)
space.GetSpace(c.GetInfo().MapID).UP_ARENA(c, 0) //退出擂台
space.GetSpace(c.GetInfo().MapID).User.Range(func(k uint32, v common.PlayerI) (stop bool) {
if k != c.GetInfo().UserID {
v.SendPack(t.Pack(&space.LeaveMapOutboundInfo{UserID: c.GetInfo().UserID}))
}
return false
})
space.GetSpace(c.GetInfo().MapID).User.Delete(c.GetInfo().UserID)
}

9
logic/service/player/save.go
View File

@@ -3,7 +3,9 @@ package player
import (
"blazing/common/data/share"
"blazing/cool"
"blazing/logic/service/fight/info"
"blazing/logic/service/space"
"context"
"time"
)
@@ -45,7 +47,8 @@ func (p *Player) Save() {
p.Info.OnlineTime = (newtime - uint32(p.Logintime)) / 60 //每次退出时候保存已经在线的分钟数
p.Service.Save(p.Info)
LeaveMap(p)
space.GetSpace(p.Info.MapID).LeaveMap(p)
p.StopChan.Stop() //停止刷怪
p.IsLogin = false
@@ -67,8 +70,8 @@ func (lw *Player) CompleteLogin() {
lw.Info.MapID = 1
}
if lw.IsNewPlayer() { //重置新手地图
lw.Info.MapID = 515
if lw.IsNewPlayer() { //重置新手地图，放到机械仓
lw.Info.MapID = 8
}
lw.IsLogin = true
}

4
logic/service/player/wscodec.go
View File

@@ -109,7 +109,7 @@ func (w *WsCodec) Decode(c gnet.Conn) (outs []wsutil.Message, err error) {
logging.Errorf("Error reading message! %v", err)
return nil, err
}
if messages == nil || len(messages) <= 0 { //没有读到完整数据 不处理
if len(messages) <= 0 { //没有读到完整数据 不处理
return
}
for _, message := range messages {
@@ -188,4 +188,4 @@ func (w *WsCodec) readWsMessages() (messages []wsutil.Message, err error) {
}
msgBuf.curHeader = nil
}
}
}

1
logic/service/space/arena.go
View File

@@ -1 +0,0 @@
package space

45
logic/service/space/in_out.go Normal file
View File

@@ -0,0 +1,45 @@
package space
import (
"blazing/logic/service/common"
"blazing/logic/service/maps/info"
"github.com/jinzhu/copier"
)
func (s *Space) LeaveMap(c common.PlayerI) {
if c == nil {
return
}
if c.GetInfo() == nil {
return
}
if c.GetInfo().MapID == 0 {
return
}
s.UP_ARENA(c, 0) //退出擂台
s.User.Range(func(k uint32, v common.PlayerI) (stop bool) {
if k != c.GetInfo().UserID {
v.SendLeaveMapInfo(info.LeaveMapOutboundInfo{UserID: c.GetInfo().UserID})
}
return false
})
s.User.Delete(c.GetInfo().UserID)
}
func (s *Space) EnterMap(c common.PlayerI) {
out := info.NewOutInfo()
copier.CopyWithOption(out, c.GetInfo(), copier.Option{DeepCopy: true})
s.User.Range(func(k uint32, v common.PlayerI) (stop bool) {
v.SendEnterMapInfo(*out)
return false
})
s.User.Store(c.GetInfo().UserID, c)
}

5
logic/service/space/space.go
View File

@@ -3,6 +3,7 @@ package space
import (
"blazing/common/data/xmlres"
"blazing/common/utils"
"blazing/logic/service/common"
"blazing/logic/service/fight/info"
@@ -124,7 +125,3 @@ func GetSpace(id uint32) *Space {
}
var planetmap = &utils.SyncMap[uint32, *Space]{} //玩家数据
type LeaveMapOutboundInfo struct {
// 米米号
UserID uint32 `struc:"uint32" fieldDesc:"米米号" json:"user_id"`
}

2
logic/service/task/CompleteTask.go
View File

@@ -5,7 +5,7 @@ import "blazing/logic/service/player"
type CompleteTaskInboundInfo struct {
Head player.TomeeHeader `cmd:"2202|2233" struc:"[0]pad"`
TaskId uint32 `json:"taskId" description:"任务ID"` // 任务ID，
OutState uint32 `json:"outState" 分支"` // 当前状态，1表示完成任务，
OutState uint32 `json:"outState" ` // 当前状态，1表示完成任务，
}
type CompleteTaskOutboundInfo struct {
TaskId uint32 `json:"taskId" description:"任务ID"` // 任务ID，

347
logic/service/task/list.go Normal file
View File

@@ -0,0 +1,347 @@
package task
import (
"sync"
"github.com/badu/bus"
)
// RegisterTask 注册任务奖励
// 参数：任务ID、分支(OutState)、物品列表、精灵类型(0=无)
func RegisterTask(taskID uint32, outState uint32, items []ItemInfo, petType uint32) {
if _, ok := TaskResultMap[taskID]; !ok {
TaskResultMap[taskID] = make(map[uint32]TaskResult)
}
TaskResultMap[taskID][outState] = TaskResult{
ItemList: items,
PetTypeId: petType,
}
}
func init() {
// -------------------------- 新手任务 --------------------------
RegisterTask(85, 1, []ItemInfo{ // 新手任务1（默认分支1）
{100027, 1}, // 新手帽
{100028, 1}, // 新手腰带
{500001, 1}, // 精灵仓库
{500502, 1}, // 精灵恢复仓
}, 0)
RegisterTask(86, 1, []ItemInfo{}, 1) // 新手任务2（分支1：布布种子）
RegisterTask(86, 2, []ItemInfo{}, 7) // 新手任务2（分支2：小火猴）
RegisterTask(86, 3, []ItemInfo{}, 4) // 新手任务2（分支3：伊优）
RegisterTask(86, 0, []ItemInfo{}, 1) // 新手任务2（默认分支：布布种子）
RegisterTask(87, 0, []ItemInfo{ // 新手任务3（默认分支）
{300001, 5}, // 普通胶囊x5
{300011, 3}, // 初级体力药剂x3
}, 0)
RegisterTask(88, 0, []ItemInfo{ // 新手任务4（默认分支）
{1, 50000}, // 赛尔豆x50000
{3, 50000}, // 累积经验x50000
{5, 20}, // 金豆x20
{300650, 3}, // 全能学习力遗忘器x3
{300651, 6}, // 全能学习力注入器x6
}, 0)
// -------------------------- 普通任务（无精灵奖励） --------------------------
RegisterTask(90, 0, []ItemInfo{ // 克洛斯星的皮皮
{1, 1000}, // 赛尔豆x1000
{3, 1000}, // 经验x1000
}, 0)
RegisterTask(8, 0, []ItemInfo{{500510, 1}}, 0) // 西塔的珍贵回忆（记忆晶体x1）
RegisterTask(9, 0, []ItemInfo{{100059, 1}}, 0) // 进入神秘通道（电能锯子x1）
RegisterTask(10, 0, []ItemInfo{}, 0) // 神秘通道拼图（无奖励）
RegisterTask(12, 0, []ItemInfo{}, 0) // 精灵广场拿石头（无奖励）
RegisterTask(19, 0, []ItemInfo{{3, 3000}}, 0) // 先锋队招募（积累经验x3000）
RegisterTask(25, 0, []ItemInfo{{400501, 10}}, 0) // 新船员的考验（神奇扭蛋牌x10）
RegisterTask(37, 0, []ItemInfo{ // 帕诺星系星球测绘
{1, 3000}, // 赛尔豆x3000
{700452, 1}, // 中型智慧芯片x1
{100178, 1}, // 勘察头盔x1
{100179, 1}, // 勘察护腕x1
{100180, 1}, // 勘察腰带x1
{100181, 1}, // 勘察军靴x1
}, 0)
RegisterTask(47, 0, []ItemInfo{ // 突围磁风暴
{3, 5000}, // 累积经验x5000
{1, 5000}, // 赛尔豆x5000
{500585, 1}, // 磁力光束枪台x1
}, 0)
RegisterTask(48, 0, []ItemInfo{ // 神秘失踪的爱丽丝
{3, 3000}, // 累积经验x3000
{1, 2000}, // 赛尔豆x2000
{700452, 2}, // 中型智慧芯片x2
}, 0)
RegisterTask(52, 0, []ItemInfo{ // 谁偷走了雪球能源？
{3, 3000}, // 累积经验x3000
{400021, 10}, // 雪球能源x10
{100254, 1}, // 斯诺纪念x1
}, 0)
RegisterTask(54, 0, []ItemInfo{ // 米鲁族的两个小不点
{3, 5000}, // 累积经验x5000
{400021, 10}, // 雪球能源x10
}, 0)
RegisterTask(57, 0, []ItemInfo{ // 米鲁族食王选拔赛
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(58, 0, []ItemInfo{ // 斯诺岩洞的不解之谜
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
{400021, 10}, // 雪球能源x10
}, 0)
RegisterTask(63, 0, []ItemInfo{ // 新型试作机SR-01同步调试
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(64, 0, []ItemInfo{ // 铸造斯诺冰冠
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
{400021, 10}, // 雪球能源x10
}, 0)
RegisterTask(65, 0, []ItemInfo{ // 露希欧星勘察
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(66, 0, []ItemInfo{ // 合金强化试验
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(68, 0, []ItemInfo{ // 资料室的神秘事件
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(69, 0, []ItemInfo{ // 宇宙遭遇站
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(70, 0, []ItemInfo{ // 船体紧急修复
{3, 3000}, // 累积经验x3000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(72, 0, []ItemInfo{ // 船长搜救任务
{3, 2000}, // 累积经验x2000
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(73, 0, []ItemInfo{ // 秘制改良机SR-02
{100303, 1}, // SR-02铠甲x1
{400055, 30}, // 变形能量块x30
{3, 3000}, // 累积经验x3000
}, 0)
RegisterTask(74, 0, []ItemInfo{{3, 3000}}, 0) // 露希欧星历险（积累经验x3000）
RegisterTask(75, 0, []ItemInfo{ // 哈莫的童年片段一
{3, 3000}, // 累积经验x3000
{100324, 1}, // 龙之纪念x1
}, 0)
RegisterTask(79, 0, []ItemInfo{ // 寻找哈莫雷特的族人
{3, 3000}, // 累积经验x3000
{1, 2000}, // 赛尔豆x2000
}, 0)
RegisterTask(80, 0, []ItemInfo{ // 重铸贾斯丁站长
{3, 2000}, // 累积经验x2000
{1, 3000}, // 赛尔豆x3000
}, 0)
RegisterTask(81, 0, []ItemInfo{ // 守候宿命的追随者
{3, 1000}, // 累积经验x1000
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(83, 0, []ItemInfo{ // 光暗之迷
{3, 1000}, // 累积经验x1000
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(84, 0, []ItemInfo{ // 星球改造计划
{3, 2000}, // 累积经验x2000
{1, 2000}, // 赛尔豆x2000
}, 0)
RegisterTask(89, 0, []ItemInfo{ // 试炼之塔的磨练
{3, 500}, // 累积经验x500
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(91, 0, []ItemInfo{ // 月光下的约定
{3, 2000}, // 累积经验x2000
{1, 2000}, // 赛尔豆x2000
}, 0)
RegisterTask(93, 0, []ItemInfo{ // 云霄星的新来客
{3, 1000}, // 累积经验x1000
{1, 500}, // 赛尔豆x500
}, 0)
RegisterTask(94, 0, []ItemInfo{ // 初识星球能源
{3, 500}, // 累积经验x500
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(96, 0, []ItemInfo{ // 旅途中的伙伴
{3, 500}, // 累积经验x500
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(97, 0, []ItemInfo{ // 我是音乐小麦霸
{3, 1000}, // 累积经验x1000
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(98, 0, []ItemInfo{ // 尼布守卫战
{3, 2000}, // 累积经验x2000
{1, 1000}, // 赛尔豆x1000
}, 0)
RegisterTask(201, 0, []ItemInfo{{100062, 1}}, 0) // 教官考核（教官指挥棒x1）
RegisterTask(300, 0, []ItemInfo{{400150, 1}}, 0) // 领取谱尼真身（谱尼的精元x1）
// -------------------------- 带精灵奖励的任务 --------------------------
RegisterTask(28, 0, []ItemInfo{}, 102) // 遗迹中的精灵信号（奇塔，类型102）
RegisterTask(40, 0, []ItemInfo{}, 139) // 时空之门（迪卢卡，类型139）
RegisterTask(49, 0, []ItemInfo{ // 密林中的托尼（托尼+物品）
{700452, 2}, // 中型智慧芯片x2
}, 158) // 托尼（类型158）
RegisterTask(71, 0, []ItemInfo{ // 赛尔号大整修（TOE+物品）
{3, 1000}, // 累积经验x1000
{1, 1000}, // 赛尔豆x1000
}, 213) // TOE（类型213）
RegisterTask(92, 0, []ItemInfo{ // 站长归来（尼布+物品）
{3, 2000}, // 累积经验x2000
{1, 2000}, // 赛尔豆x2000
}, 95) // 尼布（类型95）
RegisterTask(133, 0, []ItemInfo{ // 寻找迷失的心（史空+物品）
{3, 2000}, // 累积经验x2000
{1, 2000}, // 赛尔豆x2000
}, 381) // 史空（类型381）
// -------------------------- 多分支任务 --------------------------
RegisterTask(95, 1, []ItemInfo{ // 宇宙中的黑色旋涡（分支1：刺蜂套装）
{3, 4000}, // 累积经验x4000
{1, 2000}, // 赛尔豆x2000
{100346, 1}, // 刺蜂重盔x1
{100347, 1}, // 刺蜂护肩x1
{100348, 1}, // 刺蜂腰带x1
{100349, 1}, // 刺蜂滚轮x1
}, 0)
RegisterTask(95, 2, []ItemInfo{ // 宇宙中的黑色旋涡（分支2：锡蝶套装）
{3, 4000}, // 累积经验x4000
{1, 2000}, // 赛尔豆x2000
{100350, 1}, // 锡蝶重盔x1
{100351, 1}, // 锡蝶护肩x1
{100352, 1}, // 锡蝶腰带x1
{100353, 1}, // 锡蝶滚轮x1
}, 0)
}
// 任务触发里程碑
var Tasktopic = bus.NewTopic[CompleteTaskInboundInfo]() //直接注册到用户
// func Test_event(b *testing.T) {
// topic := bus.NewTopic[*Task]() //直接注册到用户
// for i := 0; i < 1; i++ {
// isdone := false
// t := topic.Sub(func(v *Task) { //用户初始化时注册里程碑
// if v.done { //如果任务完成
// isdone = true
// fmt.Println(v.id, "任务完成")
// return
// }
// // if v.cfunc != nil {
// // v.cont = v.cfunc(v.cont) //增加计数
// // }
// if v.cont > 5 { //如果计数达到,标记任务完成
// v.done = true
// }
// fmt.Println(v.id, "当前任务计数", v.cont, "是否完成", v.done)
// })
// if isdone { //如果任务完成,取消注册
// t.Cancel()
// }
// }
// // task1 := &Task{id: 1, cfunc: func(t uint32) uint32 { //满足任务1后推定
// // //fmt.Println(1, "当前任务计数", t)
// // //实现自定义逻辑
// // //增加用户计数
// // //增加服务器总计数
// // return t + 1
// // }}
// topic.Pub(task1)
// topic.Pub(task1)
// topic.Pub(&Task{id: 2, done: true})
// topic.Pub(task1) //发送事件
// task1.Complete()
// fmt.Println("当前任务状态", task1.IsDone())
// }
type TaskTree struct {
AllTasks []*Task //任务集合
mu sync.Mutex
}
// Various event types
const EventA = 0x01
type Task struct {
id uint32
//cfunc func(uint32) uint32
cont uint32
done bool
}
func (e *Task) IsDone() bool {
return e.done
}
func (e *Task) Complete() {
e.done = true
}
func (e *Task) EventID() string {
return "Task"
}
// Event type for testing purposes
type Event struct {
Data string
type1 uint32
}
// Type returns the event type
func (ev Event) Type() uint32 {
return ev.type1
}

46
logic/service/task/list_daily.go Normal file
View File

@@ -0,0 +1,46 @@
package task
type TaskResult struct {
PetTypeId uint32 `json:"petTypeId" description:"发放的精灵ID"` // 发放的精灵ID，
ItemList []ItemInfo `json:"itemList" description:"发放物品的数组"` // 发放物品的数组，
}
var TaskResultMap = make(map[uint32]map[uint32]TaskResult)
func Get_Task_Info(v CompleteTaskInboundInfo) *TaskResult {
t, ok := TaskResultMap[v.TaskId][v.OutState]
if ok {
return &t
}
return nil
}
func init() {
// 定义通用奖励：经验奖励（ItemId:3，数量20000）
expReward := []ItemInfo{{ItemId: 3, ItemCount: 20000}}
// 定义扭蛋牌奖励（ItemId:400501，数量5）
eggReward := []ItemInfo{{ItemId: 400501, ItemCount: 5}}
// 批量初始化任务ID 401-407（奖励均为经验）
for taskID := 401; taskID <= 407; taskID++ {
// 为每个任务ID初始化内层map
TaskResultMap[uint32(taskID)] = make(map[uint32]TaskResult)
// 设置状态0对应的奖励（与401格式一致）
TaskResultMap[uint32(taskID)][0] = TaskResult{
ItemList: expReward,
}
}
// 单独初始化任务462（奖励为扭蛋牌）
TaskResultMap[462] = make(map[uint32]TaskResult)
TaskResultMap[462][0] = TaskResult{
ItemList: eggReward,
}
// 后续若有其他任务，按相同格式添加即可
// 例如：
// TaskResultMap[xxx] = make(map[uint32]TaskResult)
// TaskResultMap[xxx][0] = TaskResult{ItemList: ...}
}