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

```

Browse Source 
refactor(controller): 重构控制器函数命名和代码注释

- 重命名 EGG 函数为 EggGamePlay，更新宠物生成逻辑
- 重命名 Leiyi 函数为 GetLeiyiTrainStatus
- 重命名 Cacthpet 函数为 CatchPet，添加详细函数注释
- 为 ArenaSetOwner、ArenaFightOwner、ArenaGetInfo、ArenaUpfight、ArenaOwnerAcce
  等擂台相关函数添加注释前缀
- 重命名 PETKing 函数为 PetKing
- 重命名 FRESH_CHOICE_FIGHT_LEVEL 函数为 FreshChoiceFightLevel，添加详细参数说明
- 重命名 BuyMItem 函数为 BuyMultipleItems
- 重命名 ITEM_S
This commit is contained in:
昔念
2025-12-24 19:03:11 +08:00
parent 9baca27033
commit 502d497dce
32 changed files with 533 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
logic/controller/action_egg.go
View File

@@ -7,10 +7,10 @@ import (
"blazing/modules/blazing/model" "blazing/modules/blazing/model"
) )
func (h Controller) EGG(data *egg.C2S_EGG_GAME_PLAY, c *player.Player) (result *egg.S2C_EGG_GAME_PLAY, err errorcode.ErrorCode) { func (h Controller) EggGamePlay(data *egg.C2S_EGG_GAME_PLAY, c *player.Player) (result *egg.S2C_EGG_GAME_PLAY, err errorcode.ErrorCode) {
r := model.GenPetInfo(1, -1, -1, -1, 0, nil) newPet := model.GenPetInfo(1, -1, -1, -1, 1, nil)
c.Service.Pet.PetAdd(r) c.Service.Pet.PetAdd(newPet)
result = &egg.S2C_EGG_GAME_PLAY{HadTime: r.CatchTime, ListInfo: []model.ItemInfo{}, PetID: r.ID} result = &egg.S2C_EGG_GAME_PLAY{HadTime: newPet.CatchTime, ListInfo: []model.ItemInfo{}, PetID: newPet.ID}
return return

2
logic/controller/activce_leiyi.go
View File

@@ -6,7 +6,7 @@ import (
"blazing/logic/service/player" "blazing/logic/service/player"
) )
func (h Controller) Leiyi(data *leiyi.C2s_LEIYI_TRAIN_GET_STATUS, c *player.Player) (result *leiyi.S2C_LEIYI_TRAIN_GET_STATUS, err errorcode.ErrorCode) { func (h Controller) GetLeiyiTrainStatus(data *leiyi.C2s_LEIYI_TRAIN_GET_STATUS, c *player.Player) (result *leiyi.S2C_LEIYI_TRAIN_GET_STATUS, err errorcode.ErrorCode) {
result = &leiyi.S2C_LEIYI_TRAIN_GET_STATUS{} result = &leiyi.S2C_LEIYI_TRAIN_GET_STATUS{}
for i := 0; i < 6; i++ { for i := 0; i < 6; i++ {

7
logic/controller/active_xiyou_in1.go
View File

@@ -8,8 +8,11 @@ import (
"github.com/gogf/gf/v2/util/grand" "github.com/gogf/gf/v2/util/grand"
) )
// Cacthpet 传送仓抓稀有 // CatchPet 传送仓抓稀有宠物
func (h Controller) Cacthpet(data *pet.C2S_9756, c *player.Player) (result *pet.S2C_9756, err errorcode.ErrorCode) { // data: 空输入结构
// c: 当前玩家对象
// 返回: 捕捉结果（消耗的EV值）和错误码
func (h Controller) CatchPet(data *pet.C2S_9756, c *player.Player) (result *pet.S2C_9756, err errorcode.ErrorCode) {
result = &pet.S2C_9756{ result = &pet.S2C_9756{
UseEV: uint32(grand.N(1, 13)), UseEV: uint32(grand.N(1, 13)),
} }

12
logic/controller/fight_leitai.go
View File

@@ -15,7 +15,7 @@ import (
// 如果星际擂台上无人,站到星际擂台的包 // 如果星际擂台上无人,站到星际擂台的包
// 前端到后端无数据内容 空包 // 前端到后端无数据内容 空包
// 后端到前端无数据内容 空包 // 后端到前端无数据内容 空包
// 都需要通过2419包广播更新擂台状态 // ArenaSetOwner 都需要通过2419包广播更新擂台状态
func (h Controller) ArenaSetOwner(data *fight.ARENA_SET_OWENR, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ArenaSetOwner(data *fight.ARENA_SET_OWENR, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if !c.CanFight() { if !c.CanFight() {
@@ -37,7 +37,7 @@ func (h Controller) ArenaSetOwner(data *fight.ARENA_SET_OWENR, c *player.Player)
// 前端到后端无数据内容 空包 // 前端到后端无数据内容 空包
// 后端到前端无数据内容 空包 // 后端到前端无数据内容 空包
// 还是后端主动发送2503的包给双方前端后 等待前端加载完毕 主动发送2404包通知后端开始战斗 // 还是后端主动发送2503的包给双方前端后 等待前端加载完毕 主动发送2404包通知后端开始战斗
// 并不会通知对方是否接受挑战。只要有人挑战就直接进入对战 // ArenaFightOwner 并不会通知对方是否接受挑战。只要有人挑战就直接进入对战
func (h Controller) ArenaFightOwner(data *fight.ARENA_FIGHT_OWENR, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ArenaFightOwner(data *fight.ARENA_FIGHT_OWENR, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if !c.CanFight() { if !c.CanFight() {
@@ -107,7 +107,7 @@ func (h Controller) ArenaFightOwner(data *fight.ARENA_FIGHT_OWENR, c *player.Pla
// ArenaGetInfo 获取星际擂台信息的包 进入空间站地图前端会发送请求包 或者 有人站到星际擂台上后 广播回包 // ArenaGetInfo 获取星际擂台信息的包 进入空间站地图前端会发送请求包 或者 有人站到星际擂台上后 广播回包
// 前端到后端无数据内容 // 前端到后端无数据内容
// 后端到前端 // ArenaGetInfo 后端到前端
func (h Controller) ArenaGetInfo(data *fight.ARENA_GET_INFO, c *player.Player) (result *space.ARENA, err errorcode.ErrorCode) { func (h Controller) ArenaGetInfo(data *fight.ARENA_GET_INFO, c *player.Player) (result *space.ARENA, err errorcode.ErrorCode) {
result = &c.GetSpace().Owner result = &c.GetSpace().Owner
@@ -117,7 +117,7 @@ func (h Controller) ArenaGetInfo(data *fight.ARENA_GET_INFO, c *player.Player) (
// ArenaUpfight 放弃擂台挑战的包 // ArenaUpfight 放弃擂台挑战的包
// 前端到后端无数据内容 // 前端到后端无数据内容
// 后端到前端无数据内容 // 后端到前端无数据内容
// 都需要通过2419包广播更新擂台状态 // ArenaUpfight 都需要通过2419包广播更新擂台状态
func (h Controller) ArenaUpfight(data *fight.ARENA_UPFIGHT, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ArenaUpfight(data *fight.ARENA_UPFIGHT, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
//原子操作，修改擂台状态 //原子操作，修改擂台状态
if atomic.LoadUint32(&c.GetSpace().Owner.UserID) != c.GetInfo().UserID { //说明已经有人了 if atomic.LoadUint32(&c.GetSpace().Owner.UserID) != c.GetInfo().UserID { //说明已经有人了
@@ -139,7 +139,7 @@ func (h Controller) ArenaUpfight(data *fight.ARENA_UPFIGHT, c *player.Player) (r
// 前端到后端无数据内容 // 前端到后端无数据内容
// 后端到前端无数据内容 // 后端到前端无数据内容
// public static const ARENA_OWENR_OUT:uint = 2423; // public static const ARENA_OWENR_OUT:uint = 2423;
// 此包不清楚具体怎么触发 但已知此包为后端主动发送。不清楚什么情况下回用到 // ArenaOwnerAcce 此包不清楚具体怎么触发 但已知此包为后端主动发送。不清楚什么情况下回用到
func (h Controller) ArenaOwnerAcce(data *fight.ARENA_OWENR_ACCE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ArenaOwnerAcce(data *fight.ARENA_OWENR_ACCE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
s := c.GetSpace() s := c.GetSpace()
@@ -155,4 +155,4 @@ func (h Controller) ArenaOwnerAcce(data *fight.ARENA_OWENR_ACCE, c *player.Playe
c.SendPackCmd(2419, &c.GetSpace().Owner) c.SendPackCmd(2419, &c.GetSpace().Owner)
return nil, -1 return nil, -1
} }

2
logic/controller/fight_pvp_king.go
View File

@@ -34,7 +34,7 @@ func (h Controller) PetMelee(data *fight.StartPetWarInboundInfo, c *player.Playe
return return
} }
func (h Controller) PETKing(data *fight.PetKingJoinInboundInfo, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) PetKing(data *fight.PetKingJoinInboundInfo, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
c.Fightinfo.Status = info.BattleMode.PET_TOPLEVEL c.Fightinfo.Status = info.BattleMode.PET_TOPLEVEL

13
logic/controller/fight_tawor.go
View File

@@ -11,7 +11,15 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
func (h Controller) FRESH_CHOICE_FIGHT_LEVEL(data *fight.C2S_FRESH_CHOICE_FIGHT_LEVEL, c *player.Player) (result *fight.S2C_FreshChoiceLevelRequestInfo, err errorcode.ErrorCode) { // FreshChoiceFightLevel 处理玩家选择挑战模式（试炼之塔或勇者之塔）
// 根据不同的CMD值设置玩家的挑战状态和地图信息，并返回当前挑战层级信息
// 参数:
// data: 客户端发送的挑战层级选择请求数据，包含CMD和挑战层级
// c: 玩家对象，包含玩家的详细信息
// 返回值:
// 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{} result = &fight.S2C_FreshChoiceLevelRequestInfo{}
@@ -25,8 +33,11 @@ func (h Controller) FRESH_CHOICE_FIGHT_LEVEL(data *fight.C2S_FRESH_CHOICE_FIGHT_
c.Info.MapID = 600 c.Info.MapID = 600
result.CurFightLevel = uint(c.Info.CurrentStage) result.CurFightLevel = uint(c.Info.CurrentStage)
} }
// 设置Boss ID为固定值10
result.BossId = []uint32{10} result.BossId = []uint32{10}
// 重置玩家的Canmon标志位为0，表示可以刷怪
atomic.StoreUint32(&c.Canmon, 0) atomic.StoreUint32(&c.Canmon, 0)
// 在函数结束时将玩家传送到对应地图
defer c.GetSpace().EnterMap(c) defer c.GetSpace().EnterMap(c)
return result, 0 return result, 0
} }

4
logic/controller/item_buy.go
View File

@@ -53,8 +53,8 @@ func (h Controller) BuyItem(data *item.BuyInboundInfo, c *player.Player) (result
return &item.BuyOutboundInfo{Coins: c.Info.Coins}, 0 return &item.BuyOutboundInfo{Coins: c.Info.Coins}, 0
} }
// BuyMItem 批量购买道具 // BuyMultipleItems 批量购买道具
func (h Controller) BuyMItem(data *item.BuyMultiInboundInfo, c *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) { func (h Controller) BuyMultipleItems(data *item.BuyMultiInboundInfo, c *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) {
for _, itemID := range data.ItemIds { for _, itemID := range data.ItemIds {
itemInfo, exists := xmlres.ItemsMAP[int(itemID)] itemInfo, exists := xmlres.ItemsMAP[int(itemID)]
if !exists { if !exists {

12
logic/controller/item_sale.go
View File

@@ -10,14 +10,18 @@ import (
"github.com/gogf/gf/v2/util/gconv" "github.com/gogf/gf/v2/util/gconv"
) )
func (h Controller) ITEM_SALE(data *item.C2S_ITEM_SALE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { // ItemSale 出售道具
// data: 包含道具ID和数量的输入信息
// c: 当前玩家对象
// 返回: 空结果和错误码
func (h Controller) ItemSale(data *item.C2S_ITEM_SALE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if c.Service.Item.CheakItem(data.ItemId) < data.Amount { if c.Service.Item.CheakItem(data.ItemId) < data.Amount {
return nil, errorcode.ErrorCodes.ErrSystemError return nil, errorcode.ErrorCodes.ErrSystemError
} }
if xmlres.ItemsMAP[int(data.ItemId)].SellPrice != 0 { itemConfig := xmlres.ItemsMAP[int(data.ItemId)]
c.Info.Coins += uint32(int64(data.Amount) * int64(xmlres.ItemsMAP[int(data.ItemId)].SellPrice)) if itemConfig.SellPrice != 0 {
c.Info.Coins += uint32(int64(data.Amount) * int64(itemConfig.SellPrice))
} }
c.Service.Item.UPDATE(data.ItemId, -gconv.Int(data.Amount)) c.Service.Item.UPDATE(data.ItemId, -gconv.Int(data.Amount))
return result, 0 return result, 0

74
logic/controller/item_use.go
View File

@@ -10,28 +10,34 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
func (h Controller) UserItemList(data *item.ItemListInboundInfo, c *player.Player) (result *item.ItemListOutboundInfo, err errorcode.ErrorCode) { // GetUserItemList 获取用户道具列表
// data: 包含分页参数的输入信息
// c: 当前玩家对象
// 返回: 道具列表和错误码
func (h Controller) GetUserItemList(data *item.ItemListInboundInfo, c *player.Player) (result *item.ItemListOutboundInfo, err errorcode.ErrorCode) {
result = &item.ItemListOutboundInfo{} result = &item.ItemListOutboundInfo{}
result.ItemList = make([]model.SingleItemInfo, 0) result.ItemList = make([]model.SingleItemInfo, 0)
item := c.Service.Item.Get(data.Param1, data.Param2) items := c.Service.Item.Get(data.Param1, data.Param2)
for _, v := range item { for _, itemData := range items {
var vv model.SingleItemInfo var itemInfo model.SingleItemInfo
vv.ItemId = v.ItemId itemInfo.ItemId = itemData.ItemId
vv.ItemCnt = v.ItemCnt itemInfo.ItemCnt = itemData.ItemCnt
vv.LeftTime = 360000 itemInfo.LeftTime = 360000
if vv.ItemCnt != 0 { if itemInfo.ItemCnt != 0 {
result.ItemList = append(result.ItemList, vv) result.ItemList = append(result.ItemList, itemInfo)
} }
} }
return result, 0 return result, 0
} }
func (h Controller) ItemUsePet(data *item.C2S_USE_PET_ITEM_OUT_OF_FIGHT, c *player.Player) (result *item.S2C_USE_PET_ITEM_OUT_OF_FIGHT, err errorcode.ErrorCode) {
_, onpet, ok := c.FindPet(data.CatchTime) // UsePetItemOutOfFight 战斗外使用宠物道具
if !ok { // data: 包含道具ID和宠物捕获时间的输入信息
// c: 当前玩家对象
// 返回: 使用后的宠物信息和错误码
func (h Controller) UsePetItemOutOfFight(data *item.C2S_USE_PET_ITEM_OUT_OF_FIGHT, c *player.Player) (result *item.S2C_USE_PET_ITEM_OUT_OF_FIGHT, err errorcode.ErrorCode) {
_, currentPet, found := c.FindPet(data.CatchTime)
if !found {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
@@ -40,48 +46,50 @@ func (h Controller) ItemUsePet(data *item.C2S_USE_PET_ITEM_OUT_OF_FIGHT, c *play
} }
if data.ItemID == 300036 { if data.ItemID == 300036 {
//神经元需要特殊处理 // 神经元需要特殊处理
if currentPet.OldCatchTime == 0 {
if onpet.OldCatchTime == 0 {
return nil, errorcode.ErrorCodes.ErrSystemError return nil, errorcode.ErrorCodes.ErrSystemError
} }
oldpetc := onpet.CatchTime oldPetCatchTime := currentPet.CatchTime
oldpet := c.Service.Pet.PetInfo_One_Unscoped(onpet.OldCatchTime) oldPet := c.Service.Pet.PetInfo_One_Unscoped(currentPet.OldCatchTime)
copier.CopyWithOption(onpet, oldpet.Data, copier.Option{DeepCopy: true}) copier.CopyWithOption(currentPet, oldPet.Data, copier.Option{DeepCopy: true})
onpet.CatchTime = oldpetc currentPet.CatchTime = oldPetCatchTime
onpet.EffectInfo = oldpet.Data.EffectInfo currentPet.EffectInfo = oldPet.Data.EffectInfo
} else { } else {
hd := item.PetItemRegistry.GetHandler(data.ItemID) handler := item.PetItemRegistry.GetHandler(data.ItemID)
if hd == nil { if handler == nil {
return nil, errorcode.ErrorCodes.ErrSystemError return nil, errorcode.ErrorCodes.ErrSystemError
} }
r := hd(data.ItemID, onpet) success := handler(data.ItemID, currentPet)
if !r { if !success {
return nil, errorcode.ErrorCodes.ErrSystemError return nil, errorcode.ErrorCodes.ErrSystemError
} }
} }
c.Service.Item.UPDATE(data.ItemID, -1) c.Service.Item.UPDATE(data.ItemID, -1)
result = &item.S2C_USE_PET_ITEM_OUT_OF_FIGHT{} result = &item.S2C_USE_PET_ITEM_OUT_OF_FIGHT{}
onpet.CalculatePetPane(false) currentPet.CalculatePetPane(false)
copier.Copy(&result, onpet) copier.Copy(&result, currentPet)
return result, 0 return result, 0
} }
// ResetNature 重置宠物性格
// data: 包含道具ID和宠物捕获时间的输入信息
// c: 当前玩家对象
// 返回: 无数据和错误码
func (h Controller) ResetNature(data *item.C2S_PET_RESET_NATURE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ResetNature(data *item.C2S_PET_RESET_NATURE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if c.Service.Item.CheakItem(data.ItemId) <= 0 { if c.Service.Item.CheakItem(data.ItemId) <= 0 {
return nil, errorcode.ErrorCodes.ErrSystemError return nil, errorcode.ErrorCodes.ErrSystemError
} }
_, onpet, ok := c.FindPet(data.CatchTime) _, currentPet, found := c.FindPet(data.CatchTime)
if !ok { if !found {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
onpet.Nature = data.Nature currentPet.Nature = data.Nature
onpet.CalculatePetPane(false) currentPet.CalculatePetPane(false)
c.Service.Item.UPDATE(data.ItemId, -1) c.Service.Item.UPDATE(data.ItemId, -1)
return result, 0 return result, 0
} }

4
logic/controller/login_getserver.go
View File

@@ -20,8 +20,8 @@ func fetchData() (any, error) {
return ServerList, nil return ServerList, nil
} }
// 处理命令: 105 // GetServerOnline 处理命令: 105
func (h *Controller) COMMEND_ONLINE(data *user.SidInfo, c gnet.Conn) (result *rpc.CommendSvrInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) GetServerOnline(data *user.SidInfo, c gnet.Conn) (result *rpc.CommendSvrInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
result = rpc.NewInInfo() result = rpc.NewInInfo()
if service.NewBaseSysUserService().GetPerson(data.Head.UserID).Debug == 1 { if service.NewBaseSysUserService().GetPerson(data.Head.UserID).Debug == 1 {

33
logic/controller/login_main.go
View File

@@ -18,48 +18,47 @@ import (
"github.com/panjf2000/gnet/v2" "github.com/panjf2000/gnet/v2"
) )
// 处理命令: 1001 // Login 处理命令: 1001
func (h *Controller) Login(data *user.MAIN_LOGIN_IN, c gnet.Conn) (result *user.LoginMSInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) Login(data *user.MAIN_LOGIN_IN, c gnet.Conn) (result *user.LoginMSInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
tt := data.CheakSession() isSessionValid := data.CheakSession()
if !tt { if !isSessionValid {
defer c.Close() defer c.Close()
return return
} }
err1 := h.RPCClient.Kick(data.Head.UserID) //先踢人 kickErr := h.RPCClient.Kick(data.Head.UserID) //先踢人
if err1 != nil { if kickErr != nil {
fmt.Println("踢人失败", err) fmt.Println("踢人失败", err)
} }
cool.Loger.Info(context.TODO(), "踢人请求完成，继续登录流程") cool.Loger.Info(context.TODO(), "踢人请求完成，继续登录流程")
share.ShareManager.SetUserOnline(data.Head.UserID, h.Port) //设置用户登录服务器 share.ShareManager.SetUserOnline(data.Head.UserID, h.Port) //设置用户登录服务器
t := player.GetPlayer(c, data.Head.UserID) currentPlayer := player.GetPlayer(c, data.Head.UserID)
if t == nil { if currentPlayer == nil {
cool.Loger.Error(context.Background(), "获取玩家失败", data.Head.UserID) cool.Loger.Error(context.Background(), "获取玩家失败", data.Head.UserID)
defer c.Close() defer c.Close()
return return
} }
t.Service = blservice.NewUserService(data.Head.UserID) currentPlayer.Service = blservice.NewUserService(data.Head.UserID)
t.Info = t.Service.Info.Personself() currentPlayer.Info = currentPlayer.Service.Info.Personself()
if t.Info == nil { if currentPlayer.Info == nil {
defer c.Close() defer c.Close()
return return
} }
t.Info.UserID = data.Head.UserID currentPlayer.Info.UserID = data.Head.UserID
t.Logintime = uint32(time.Now().Unix()) //保存时间戳 currentPlayer.Logintime = uint32(time.Now().Unix()) //保存时间戳
t.CompleteLogin() //通知客户端登录成功 currentPlayer.CompleteLogin() //通知客户端登录成功
result = user.NewOutInfo() //设置登录消息 result = user.NewOutInfo() //设置登录消息
result.PlayerInfo = *t.Info result.PlayerInfo = *currentPlayer.Info
defer space.GetSpace(t.Info.MapID).EnterMap(t) defer space.GetSpace(currentPlayer.Info.MapID).EnterMap(currentPlayer)
return result, 0 return result, 0

10
logic/controller/map.go
View File

@@ -15,7 +15,7 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
func (h *Controller) MapEnter(data *space.InInfo, c *player.Player) (result *info.OutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) EnterMap(data *space.InInfo, c *player.Player) (result *info.OutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
c.Info.MapID = data.MapId //登录地图 c.Info.MapID = data.MapId //登录地图
c.GetSpace().User.Store(c.Info.UserID, c) //添加玩家 c.GetSpace().User.Store(c.Info.UserID, c) //添加玩家
@@ -28,7 +28,7 @@ func (h *Controller) MapEnter(data *space.InInfo, c *player.Player) (result *inf
return result, 0 return result, 0
} }
func (h Controller) MapHot(data *maphot.InInfo, c *player.Player) (result *maphot.OutInfo, err errorcode.ErrorCode) { func (h Controller) GetMapHot(data *maphot.InInfo, c *player.Player) (result *maphot.OutInfo, err errorcode.ErrorCode) {
result = &maphot.OutInfo{ result = &maphot.OutInfo{
@@ -37,7 +37,7 @@ func (h Controller) MapHot(data *maphot.InInfo, c *player.Player) (result *mapho
return return
} }
func (h *Controller) MapLeave(data *space.LeaveMapInboundInfo, c *player.Player) (result *info.LeaveMapOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) LeaveMap(data *space.LeaveMapInboundInfo, c *player.Player) (result *info.LeaveMapOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
atomic.StoreUint32(&c.Canmon, 0) atomic.StoreUint32(&c.Canmon, 0)
//data.Broadcast(c.Info.MapID, info.LeaveMapOutboundInfo{UserID: c.Info.UserID}) //同步广播 //data.Broadcast(c.Info.MapID, info.LeaveMapOutboundInfo{UserID: c.Info.UserID}) //同步广播
@@ -51,7 +51,7 @@ func (h *Controller) MapLeave(data *space.LeaveMapInboundInfo, c *player.Player)
//c.Info.MapID = 0 // 重置当前地图 //c.Info.MapID = 0 // 重置当前地图
return return
} }
func (h *Controller) MapList(data *space.ListMapPlayerInboundInfo, c *player.Player) (result *info.ListMapPlayerOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) GetMapPlayerList(data *space.ListMapPlayerInboundInfo, c *player.Player) (result *info.ListMapPlayerOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
atomic.StoreUint32(&c.Canmon, 2) atomic.StoreUint32(&c.Canmon, 2)
c.MapNPC.Reset(5 * time.Second) c.MapNPC.Reset(5 * time.Second)
result = &info.ListMapPlayerOutboundInfo{ result = &info.ListMapPlayerOutboundInfo{
@@ -60,7 +60,7 @@ func (h *Controller) MapList(data *space.ListMapPlayerInboundInfo, c *player.Pla
return return
} }
func (h *Controller) Attack_Boss(data *space.AttackBossInboundInfo, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) AttackBoss(data *space.AttackBossInboundInfo, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
if atomic.LoadInt32(&c.GetSpace().MapBossInfo.Hp) > 0 { if atomic.LoadInt32(&c.GetSpace().MapBossInfo.Hp) > 0 {
atomic.AddInt32(&c.GetSpace().MapBossInfo.Hp, -1) atomic.AddInt32(&c.GetSpace().MapBossInfo.Hp, -1)

4
logic/controller/nono.go
View File

@@ -8,7 +8,7 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
func (h *Controller) NonoFollowOrHome(data *nono.NonoFollowOrHomeInInfo, c *player.Player) (result *nono.NonoFollowOutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h Controller) NonoFollowOrHome(data *nono.NonoFollowOrHomeInInfo, c *player.Player) (result *nono.NonoFollowOutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
c.Info.NONO.Flag = data.Flag c.Info.NONO.Flag = data.Flag
result = &nono.NonoFollowOutInfo{ result = &nono.NonoFollowOutInfo{
@@ -23,7 +23,7 @@ func (h *Controller) NonoFollowOrHome(data *nono.NonoFollowOrHomeInInfo, c *play
return return
} }
// 获取nono信息 // GetNonoInfo 获取nono信息
func (h *Controller) GetNonoInfo(data *nono.NonoInboundInfo, c *player.Player) (result *nono.NonoOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 func (h *Controller) GetNonoInfo(data *nono.NonoInboundInfo, c *player.Player) (result *nono.NonoOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
result = &nono.NonoOutboundInfo{} result = &nono.NonoOutboundInfo{}

2
logic/controller/pet_COLLECT.go
View File

@@ -6,7 +6,7 @@ import (
"blazing/logic/service/player" "blazing/logic/service/player"
) )
func (h *Controller) IS_COLLECT( func (h Controller) IsCollect(
data *pet.C2S_IS_COLLECT, c *player.Player) (result *pet.S2C_IS_COLLECT, err errorcode.ErrorCode) { //这个时候player应该是空的 data *pet.C2S_IS_COLLECT, c *player.Player) (result *pet.S2C_IS_COLLECT, err errorcode.ErrorCode) { //这个时候player应该是空的
result = &pet.S2C_IS_COLLECT{ result = &pet.S2C_IS_COLLECT{
ID: data.Type, ID: data.Type,

39
logic/controller/pet_ev.go
View File

@@ -8,41 +8,44 @@ import (
"github.com/samber/lo" "github.com/samber/lo"
) )
func (h Controller) PetEVdiy(data *pet.PetEV, c *player.Player) (result *pet.S2C_50001, err errorcode.ErrorCode) { // PetEVDiy 自定义分配宠物努力值（EV）
_, onpet, ok := c.FindPet(data.CacthTime) // data: 包含宠物捕获时间和EV分配数据的输入信息
if !ok { // c: 当前玩家对象
// 返回: 分配结果和错误码
func (h Controller) PetEVDiy(data *pet.PetEV, c *player.Player) (result *pet.S2C_50001, err errorcode.ErrorCode) {
_, currentPet, found := c.FindPet(data.CacthTime)
if !found {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
//分配超过510的数据 // 分配超过510的数据
if lo.Sum(data.EVs[:]) > 510 { if lo.Sum(data.EVs[:]) > 510 {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
for i, v := range data.EVs { for i, evValue := range data.EVs {
// 分配超过255的数据
//分配超过255的数据 if evValue > 255 {
if v > 255 {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
//分配比之前点数少的 // 分配比之前点数少的
if v < onpet.Ev[i] { if evValue < currentPet.Ev[i] {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
} }
if lo.Sum(data.EVs[:]) < lo.Sum(onpet.Ev[:]) { if lo.Sum(data.EVs[:]) < lo.Sum(currentPet.Ev[:]) {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
USEEV1 := lo.Sum(data.EVs[:]) - lo.Sum(onpet.Ev[:]) usedEV := lo.Sum(data.EVs[:]) - lo.Sum(currentPet.Ev[:])
//加的比池子还多 // 加的比池子还多
if USEEV1 > c.Info.EVPool { if usedEV > c.Info.EVPool {
return nil, errorcode.ErrorCodes.Err10401 return nil, errorcode.ErrorCodes.Err10401
} }
onpet.Ev = data.EVs currentPet.Ev = data.EVs
onpet.CalculatePetPane(false) currentPet.CalculatePetPane(false)
c.Info.EVPool -= USEEV1 c.Info.EVPool -= usedEV
result = &pet.S2C_50001{} result = &pet.S2C_50001{}
result.UseEV = USEEV1 result.UseEV = usedEV
return result, 0 return result, 0
} }

146
logic/controller/pet_info.go
View File

@@ -12,96 +12,96 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
// 获取精灵信息 // GetPetInfo 获取精灵信息
func (h *Controller) GetPetInfo( // data: 包含精灵捕获时间的输入信息
// c: 当前玩家对象
// 返回: 精灵信息和错误码
func (h Controller) GetPetInfo(
data *pet.InInfo, data *pet.InInfo,
c *player.Player) (result *pet.OutInfo, c *player.Player) (result *pet.OutInfo,
err errorcode.ErrorCode) { //这个时候player应该是空的 err errorcode.ErrorCode) {
_, tet, ok := c.FindPet(data.CatchTime) _, petInfo, found := c.FindPet(data.CatchTime)
if ok { if found {
result = &pet.OutInfo{ result = &pet.OutInfo{
PetInfo: *tet, PetInfo: *petInfo,
} }
return result, 0 return result, 0
} else {
result = &pet.OutInfo{
PetInfo: c.Service.Pet.PetInfo_One(data.CatchTime).Data,
}
} }
result = &pet.OutInfo{
PetInfo: c.Service.Pet.PetInfo_One(data.CatchTime).Data,
}
return result, 0 return result, 0
} }
// 获取仓库列表 // GetPetList 获取仓库列表
func (h *Controller) GetPetList( // data: 空输入结构
// c: 当前玩家对象
// 返回: 精灵列表和错误码
func (h Controller) GetPetList(
data *pet.GetPetListInboundEmpty, data *pet.GetPetListInboundEmpty,
c *player.Player) (result *pet.GetPetListOutboundInfo, c *player.Player) (result *pet.GetPetListOutboundInfo,
err errorcode.ErrorCode) { //这个时候player应该是空的 err errorcode.ErrorCode) {
result = &pet.GetPetListOutboundInfo{} result = &pet.GetPetListOutboundInfo{}
tt := c.Service.Pet.PetInfo(0) //获得未放生的精灵 petList := c.Service.Pet.PetInfo(0) // 获取未放生的精灵
result.ShortInfoList = make([]pet.PetShortInfo, len(tt)) result.ShortInfoList = make([]pet.PetShortInfo, len(petList))
for i, v := range tt { for i, petItem := range petList {
copier.Copy(&result.ShortInfoList[i], &petItem.Data)
copier.Copy(&result.ShortInfoList[i], &v.Data)
} }
return result, 0 return result, 0
} }
// 获取放生列表 // GetPetReleaseList 获取放生列表
func (h *Controller) PET_ROWEI_LIST( // data: 空输入结构
// c: 当前玩家对象
// 返回: 放生精灵列表和错误码
func (h Controller) GetPetReleaseList(
data *pet.GetPetListFreeInboundEmpty, data *pet.GetPetListFreeInboundEmpty,
c *player.Player) (result *pet.GetPetListOutboundInfo, c *player.Player) (result *pet.GetPetListOutboundInfo,
err errorcode.ErrorCode) { //这个时候player应该是空的 err errorcode.ErrorCode) {
result = &pet.GetPetListOutboundInfo{} result = &pet.GetPetListOutboundInfo{}
tt := c.Service.Pet.PetInfo(1) //获得未放生的精灵 petList := c.Service.Pet.PetInfo(1) // 获取已放生的精灵
result.ShortInfoList = make([]pet.PetShortInfo, len(tt)) result.ShortInfoList = make([]pet.PetShortInfo, len(petList))
for i, v := range tt { for i, petItem := range petList {
copier.Copy(&result.ShortInfoList[i], &petItem.Data)
copier.Copy(&result.ShortInfoList[i], &v.Data)
} }
return result, 0 return result, 0
} }
// 放生包 // PetReleaseToWarehouse 将精灵从仓库包中放生
func (h *Controller) PET_ROWEI( // data: 包含精灵ID和捕获时间的输入信息
data *pet.PET_ROWEI, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 // c: 当前玩家对象
// 返回: 无数据和错误码
c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) { func (h Controller) PetReleaseToWarehouse(
data *pet.PET_ROWEI, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
_, _, ok := c.FindPet(data.CatchTime) c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(pet *model.PetEX) {
r := xmlres.PetMAP[int(data.ID)].FreeForbidden _, _, inBag := c.FindPet(data.CatchTime)
//如果背包没找到,再放入背包 freeForbidden := xmlres.PetMAP[int(data.ID)].FreeForbidden
if !ok && t.CatchTime != 0 && r == 0 { // 如果背包没找到,再放入背包
t.Free = 1 if !inBag && pet.CatchTime != 0 && freeForbidden == 0 {
pet.Free = 1
} else { } else {
err = errorcode.ErrorCodes.ErrCannotReleaseNonWarehouse err = errorcode.ErrorCodes.ErrCannotReleaseNonWarehouse
} }
}) })
return nil, err return nil, err
} }
// 领回包 // PetRetrieveFromWarehouse 领回包
func (h *Controller) PET_RETRIEVE( func (h Controller) PetRetrieveFromWarehouse(
data *pet.PET_RETRIEVE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 data *pet.PET_RETRIEVE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) { c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(pet *model.PetEX) {
_, _, ok := c.FindPet(data.CatchTime) _, _, ok := c.FindPet(data.CatchTime)
//如果背包没找到,再放入背包 //如果背包没找到,再放入背包
if !ok && t.CatchTime != 0 { if !ok && pet.CatchTime != 0 {
t.Free = 0 pet.Free = 0
} }
}) })
@@ -110,8 +110,8 @@ func (h *Controller) PET_RETRIEVE(
} }
// 精灵背包仓库切换 // TogglePetBagWarehouse 精灵背包仓库切换
func (h *Controller) PetRelease( func (h Controller) TogglePetBagWarehouse(
data *pet.PetReleaseInboundInfo, data *pet.PetReleaseInboundInfo,
c *player.Player) ( c *player.Player) (
result *pet.PetReleaseOutboundInfo, result *pet.PetReleaseOutboundInfo,
@@ -128,10 +128,10 @@ func (h *Controller) PetRelease(
switch data.Flag { switch data.Flag {
case 0: case 0:
index, v, ok := c.FindPet(data.CatchTime) index, pet, ok := c.FindPet(data.CatchTime)
if ok { if ok {
c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) { c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(petData *model.PetEX) {
t.Data = *v petData.Data = *pet
//t.InBag = 0 //t.InBag = 0
}) })
@@ -142,15 +142,15 @@ func (h *Controller) PetRelease(
case 1: case 1:
if len(c.Info.PetList) < 6 { if len(c.Info.PetList) < 6 {
//todo 背包 //todo 背包
c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) { c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(petData *model.PetEX) {
_, _, ok := c.FindPet(data.CatchTime) _, _, ok := c.FindPet(data.CatchTime)
//如果背包没找到,再放入背包 //如果背包没找到,再放入背包
if !ok && t.CatchTime != 0 { if !ok && petData.CatchTime != 0 {
//t.InBag = 1 //t.InBag = 1
c.Info.PetList = append(c.Info.PetList, t.Data) c.Info.PetList = append(c.Info.PetList, petData.Data)
result.PetInfo = t.Data result.PetInfo = petData.Data
} }
}) })
@@ -165,14 +165,14 @@ func (h *Controller) PetRelease(
return result, 0 return result, 0
} }
// 精灵展示 // PlayerShowPet 精灵展示
func (h *Controller) PlayerShowPet( func (h Controller) PlayerShowPet(
data *pet.PetShowInboundInfo, c *player.Player) (result *pet.PetShowOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 data *pet.PetShowInboundInfo, c *player.Player) (result *pet.PetShowOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
result = &pet.PetShowOutboundInfo{} result = &pet.PetShowOutboundInfo{}
_, onpet, ok := c.FindPet(data.CatchTime) _, currentPet, ok := c.FindPet(data.CatchTime)
if ok { if ok {
copier.Copy(&result, onpet) copier.Copy(&result, currentPet)
result.Flag = data.Flag result.Flag = data.Flag
result.UserID = data.Head.UserID result.UserID = data.Head.UserID
defer c.GetSpace().Broadcast(c, data.Head.CMD, result) defer c.GetSpace().Broadcast(c, data.Head.CMD, result)
@@ -181,16 +181,16 @@ func (h *Controller) PlayerShowPet(
} }
// 单体治疗 // PetOneCure 单体治疗
func (h *Controller) PetOneCure( func (h Controller) PetOneCure(
data *pet.PetOneCureInboundInfo, c *player.Player) (result *pet.PetOneCureOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 data *pet.PetOneCureInboundInfo, c *player.Player) (result *pet.PetOneCureOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
if c.GetSpace().Owner.UserID == c.Info.UserID { if c.GetSpace().Owner.UserID == c.Info.UserID {
return result, errorcode.ErrorCodes.ErrChampionCannotHeal return result, errorcode.ErrorCodes.ErrChampionCannotHeal
} }
_, onpet, ok := c.FindPet(data.CatchTime) _, currentPet, ok := c.FindPet(data.CatchTime)
if ok { if ok {
defer onpet.Cure() defer currentPet.Cure()
} }
@@ -200,8 +200,8 @@ func (h *Controller) PetOneCure(
} }
// 精灵首发 // PetFirst 精灵首发
func (h *Controller) PetFirst( func (h Controller) PetFirst(
data *pet.PetDefaultInboundInfo, c *player.Player) (result *pet.PetDefaultOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的 data *pet.PetDefaultInboundInfo, c *player.Player) (result *pet.PetDefaultOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
//擂台住不能换精灵 //擂台住不能换精灵
if c.GetSpace().Owner.UserID == c.Info.UserID { if c.GetSpace().Owner.UserID == c.Info.UserID {
@@ -226,10 +226,10 @@ func (h *Controller) PetFirst(
// 返回：索引、元素指针、是否找到 // 返回：索引、元素指针、是否找到
func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player) (result *pet.PetSetExpOutboundInfo, err errorcode.ErrorCode) { func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player) (result *pet.PetSetExpOutboundInfo, err errorcode.ErrorCode) {
_, onpet, ok := c.FindPet(data.CatchTime) _, currentPet, ok := c.FindPet(data.CatchTime)
if ok && onpet.Level < 100 { if ok && currentPet.Level < 100 {
c.AddPetExp(onpet, data.Exp) c.AddPetExp(currentPet, data.Exp)
return &pet.PetSetExpOutboundInfo{ return &pet.PetSetExpOutboundInfo{
Exp: c.Info.ExpPool, Exp: c.Info.ExpPool,
}, 0 }, 0
@@ -240,8 +240,8 @@ func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player)
}, errorcode.ErrorCodes.ErrSystemError }, errorcode.ErrorCodes.ErrSystemError
} }
// 精灵图鉴 // GetPetBargeList 精灵图鉴
func (h Controller) PetBargeList(data *pet.PetBargeListInboundInfo, c *player.Player) (result *pet.PetBargeListOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetPetBargeList(data *pet.PetBargeListInboundInfo, c *player.Player) (result *pet.PetBargeListOutboundInfo, err errorcode.ErrorCode) {
return &pet.PetBargeListOutboundInfo{ return &pet.PetBargeListOutboundInfo{
PetBargeList: make([]pet.PetBargeListInfo, 0), PetBargeList: make([]pet.PetBargeListInfo, 0),

20
logic/controller/pet_skill.go
View File

@@ -20,13 +20,13 @@ func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (re
c.Info.Coins -= setSkillCost c.Info.Coins -= setSkillCost
_, onpet, ok := c.FindPet(data.CatchTime) _, currentPet, ok := c.FindPet(data.CatchTime)
if !ok { if !ok {
return nil, errorcode.ErrorCodes.ErrSystemBusy return nil, errorcode.ErrorCodes.ErrSystemBusy
} }
// 检查要替换的技能是否已存在 // 检查要替换的技能是否已存在
_, _, exists := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { _, _, exists := utils.FindWithIndex(currentPet.SkillList, func(item model.SkillInfo) bool {
return item.ID == data.ReplaceSkill return item.ID == data.ReplaceSkill
}) })
if exists { if exists {
@@ -34,12 +34,12 @@ func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (re
} }
// 查找要学习的技能并替换 // 查找要学习的技能并替换
_, hasSkill, ok := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { _, targetSkill, ok := utils.FindWithIndex(currentPet.SkillList, func(item model.SkillInfo) bool {
return item.ID == data.HasSkill return item.ID == data.HasSkill
}) })
if ok { if ok {
hasSkill.ID = data.ReplaceSkill targetSkill.ID = data.ReplaceSkill
hasSkill.PP = uint32(xmlres.SkillMap[int(hasSkill.ID)].MaxPP) targetSkill.PP = uint32(xmlres.SkillMap[int(targetSkill.ID)].MaxPP)
} }
return &pet.ChangeSkillOutInfo{ return &pet.ChangeSkillOutInfo{
@@ -47,8 +47,8 @@ func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (re
}, 0 }, 0
} }
// SkillSort 排序宠物技能，消耗50赛尔豆 // SortPetSkills 排序宠物技能，消耗50赛尔豆
func (h Controller) SkillSort(data *pet.C2S_Skill_Sort, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { func (h Controller) SortPetSkills(data *pet.C2S_Skill_Sort, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
const skillSortCost = 50 const skillSortCost = 50
if !c.UseCoins(skillSortCost) { if !c.UseCoins(skillSortCost) {
@@ -57,18 +57,18 @@ func (h Controller) SkillSort(data *pet.C2S_Skill_Sort, c *player.Player) (resul
c.Info.Coins -= skillSortCost c.Info.Coins -= skillSortCost
_, onpet, ok := c.FindPet(data.CapTm) _, currentPet, ok := c.FindPet(data.CapTm)
if ok { if ok {
var newSkillList []model.SkillInfo var newSkillList []model.SkillInfo
for _, skillID := range data.Skill { for _, skillID := range data.Skill {
_, skill, found := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { _, skill, found := utils.FindWithIndex(currentPet.SkillList, func(item model.SkillInfo) bool {
return item.ID == skillID return item.ID == skillID
}) })
if found { if found {
newSkillList = append(newSkillList, *skill) newSkillList = append(newSkillList, *skill)
} }
} }
onpet.SkillList = newSkillList currentPet.SkillList = newSkillList
} }
return nil, 0 return nil, 0

17
logic/controller/room_buy.go
View File

@@ -7,21 +7,22 @@ import (
"blazing/logic/service/room" "blazing/logic/service/room"
) )
// 购买家具 // BuyFitment 购买基地家具
func (h Controller) BUY_FITMENT(data *room.C2S_BUY_FITMENT, c *player.Player) (result *room.S2C_BUY_FITMENT, err errorcode.ErrorCode) { // data: 包含家具ID和购买数量的输入信息
// c: 当前玩家对象
// 返回: 购买结果和错误码
func (h Controller) BuyFitment(data *room.C2S_BUY_FITMENT, c *player.Player) (result *room.S2C_BUY_FITMENT, err errorcode.ErrorCode) {
result = &room.S2C_BUY_FITMENT{} result = &room.S2C_BUY_FITMENT{}
used := xmlres.ItemsMAP[int(data.ID)].Price * int(data.Count) itemConfig := xmlres.ItemsMAP[int(data.ID)]
totalCost := itemConfig.Price * int(data.Count)
if !c.UseCoins(uint32(used)) { if !c.UseCoins(uint32(totalCost)) {
return nil, errorcode.ErrorCodes.ErrSunDouInsufficient10016 return nil, errorcode.ErrorCodes.ErrSunDouInsufficient10016
} }
c.Service.Room.Add(data.ID, data.Count) c.Service.Room.Add(data.ID, data.Count)
c.Info.Coins -= uint32(used) c.Info.Coins -= uint32(totalCost)
result.ID = data.ID result.ID = data.ID
result.Coins = c.Info.Coins result.Coins = c.Info.Coins
return return
} }

65
logic/controller/room_info.go
View File

@@ -11,60 +11,65 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
// 获取基地物品 // GetFitmentUsing 获取基地展示的家具物品
func (h Controller) OnFitmentUsering(data *room.FitmentUseringInboundInfo, c *player.Player) (result *room.FitmentUseringOutboundInfo, err errorcode.ErrorCode) { // data: 包含目标用户ID的输入信息
// c: 当前玩家对象
// 返回: 基地家具信息和错误码
func (h Controller) GetFitmentUsing(data *room.FitmentUseringInboundInfo, c *player.Player) (result *room.FitmentUseringOutboundInfo, err errorcode.ErrorCode) {
result = &room.FitmentUseringOutboundInfo{UserId: c.Info.UserID, RoomId: data.TargetUserID} result = &room.FitmentUseringOutboundInfo{UserId: c.Info.UserID, RoomId: data.TargetUserID}
result.Fitments = make([]model.FitmentShowInfo, 0) result.Fitments = make([]model.FitmentShowInfo, 0)
result.Fitments = append(result.Fitments, model.FitmentShowInfo{Id: 500001, Status: 1, X: 1, Y: 1, Dir: 1}) result.Fitments = append(result.Fitments, model.FitmentShowInfo{Id: 500001, Status: 1, X: 1, Y: 1, Dir: 1})
r := c.Service.Room.Get(data.TargetUserID) roomInfo := c.Service.Room.Get(data.TargetUserID)
result.Fitments = append(result.Fitments, r.PlacedItems...) result.Fitments = append(result.Fitments, roomInfo.PlacedItems...)
return return
} }
// 获取基地展示精灵 // GetRoomPetShowInfo 获取基地展示的精灵列表
func (h Controller) OnGetRoomPetShowInfo(data *room.PetRoomListInboundInfo, c *player.Player) (result *room.PetRoomListOutboundInfo, err errorcode.ErrorCode) { // data: 包含目标用户ID的输入信息
// c: 当前玩家对象
// 返回: 精灵展示列表和错误码
func (h Controller) GetRoomPetShowInfo(data *room.PetRoomListInboundInfo, c *player.Player) (result *room.PetRoomListOutboundInfo, err errorcode.ErrorCode) {
result = &room.PetRoomListOutboundInfo{} result = &room.PetRoomListOutboundInfo{}
result.Pets = make([]pet.PetShortInfo, 0) result.Pets = make([]pet.PetShortInfo, 0)
r := c.Service.Room.Get(data.TargetUserID) roomInfo := c.Service.Room.Get(data.TargetUserID)
for _, v := range r.ShowPokemon { for _, catchTime := range roomInfo.ShowPokemon {
pet12 := c.Service.Pet.PetInfo_One_ohter(data.TargetUserID, v) petInfo := c.Service.Pet.PetInfo_One_ohter(data.TargetUserID, catchTime)
if pet12.Data.ID == 0 { if petInfo.Data.ID == 0 {
continue continue
} }
var pet1 pet.PetShortInfo var petShortInfo pet.PetShortInfo
copier.Copy(&pet1, &pet12.Data) copier.Copy(&petShortInfo, &petInfo.Data)
if pet12.ID != 0 { if petInfo.ID != 0 {
result.Pets = append(result.Pets, pet1) result.Pets = append(result.Pets, petShortInfo)
} }
} }
return return
} }
// 获取自己房间的家具 // GetAllFurniture 获取玩家的所有家具
func (h Controller) OnGetFitmentAll(data *room.FitmentAllInboundEmpty, c *player.Player) (result *room.FitmentAllOutboundInfo, err errorcode.ErrorCode) { // data: 空输入结构
// c: 当前玩家对象
// 返回: 玩家所有家具列表和错误码
func (h Controller) GetAllFurniture(data *room.FitmentAllInboundEmpty, c *player.Player) (result *room.FitmentAllOutboundInfo, err errorcode.ErrorCode) {
result = &room.FitmentAllOutboundInfo{} result = &room.FitmentAllOutboundInfo{}
result.Fitments = make([]room.FitmentItemInfo, 0) result.Fitments = make([]room.FitmentItemInfo, 0)
r := c.Service.Room.Get(c.Info.UserID) roomData := c.Service.Room.Get(c.Info.UserID)
for itemID, count := range roomData.OwnedItems {
for k, v := range r.OwnedItems { result.Fitments = append(result.Fitments, room.FitmentItemInfo{Id: itemID, AllCount: count, UsedCount: roomData.UserItems[itemID]})
result.Fitments = append(result.Fitments, room.FitmentItemInfo{Id: k, AllCount: v, UsedCount: r.UserItems[k]})
} }
return return
} }
func (h Controller) RoomPetInfo(data *room.C2S_RoomPetInfo, c *player.Player) (result *pet.RoomPetInfo, err errorcode.ErrorCode) {
r := c.Service.Pet.PetInfo_One_ohter(data.UserID, data.CatchTime)
// GetRoomPetInfo 获取玩家跟随精灵的信息
// data: 包含用户ID和精灵捕获时间的输入信息
// c: 当前玩家对象
// 返回: 精灵详细信息和错误码
func (h Controller) GetRoomPetInfo(data *room.C2S_RoomPetInfo, c *player.Player) (result *pet.RoomPetInfo, err errorcode.ErrorCode) {
petInfo := c.Service.Pet.PetInfo_One_ohter(data.UserID, data.CatchTime)
result = &pet.RoomPetInfo{} result = &pet.RoomPetInfo{}
copier.CopyWithOption(result, &r.Data, copier.Option{DeepCopy: true}) copier.CopyWithOption(result, &petInfo.Data, copier.Option{DeepCopy: true})
result.OwnerId = data.UserID result.OwnerId = data.UserID
return return
} }

42
logic/controller/room_set.go
View File

@@ -9,35 +9,37 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
// 基地设置 // SetFitment 设置基地家具摆放
func (h Controller) SET_FITMENT(data *room.SET_FITMENT, c *player.Player) (result *room.NullInfo, err errorcode.ErrorCode) { // data: 包含家具列表的输入信息
// c: 当前玩家对象
// 返回: 空结果和错误码
func (h Controller) SetFitment(data *room.SET_FITMENT, c *player.Player) (result *room.NullInfo, err errorcode.ErrorCode) {
c.Service.Room.Set(data.Fitments) c.Service.Room.Set(data.Fitments)
return return
} }
func (h Controller) SET_Pet(data *room.C2S_PET_ROOM_SHOW, c *player.Player) (result *room.S2C_PET_ROOM_SHOW, err errorcode.ErrorCode) { // SetPet 设置基地展示的精灵
var showpet []uint32 // data: 包含精灵展示列表的输入信息
for _, v := range data.PetShowList { // c: 当前玩家对象
if v.CatchTime != 0 { // 返回: 精灵展示列表和错误码
showpet = append(showpet, v.CatchTime) func (h Controller) SetPet(data *room.C2S_PET_ROOM_SHOW, c *player.Player) (result *room.S2C_PET_ROOM_SHOW, err errorcode.ErrorCode) {
var showPetCatchTimes []uint32
for _, petShowInfo := range data.PetShowList {
if petShowInfo.CatchTime != 0 {
showPetCatchTimes = append(showPetCatchTimes, petShowInfo.CatchTime)
} }
} }
c.Service.Room.Show(showpet) c.Service.Room.Show(showPetCatchTimes)
result = &room.S2C_PET_ROOM_SHOW{} result = &room.S2C_PET_ROOM_SHOW{}
result.PetShowList = make([]pet.PetShortInfo, len(showPetCatchTimes))
result.PetShowList = make([]pet.PetShortInfo, len(showpet)) for _, catchTime := range showPetCatchTimes {
for _, v := range showpet { petInfo := c.Service.Pet.PetInfo_One(catchTime)
r1 := c.Service.Pet.PetInfo_One(v) if petInfo.Data.ID == 0 {
if r1.Data.ID == 0 {
continue continue
} }
var r12 pet.PetShortInfo var petShortInfo pet.PetShortInfo
copier.Copy(&r12, &r1.Data) copier.Copy(&petShortInfo, &petInfo.Data)
result.PetShowList = append(result.PetShowList, r12) result.PetShowList = append(result.PetShowList, petShortInfo)
} }
return return
} }

14
logic/controller/user_action.go
View File

@@ -10,8 +10,8 @@ import (
"blazing/modules/blazing/model" "blazing/modules/blazing/model"
) )
// 射击 // PlayerAim 射击
func (h Controller) Aimat(data *user.AimatInboundInfo, c *player.Player) (result *user.AimatOutboundInfo, err errorcode.ErrorCode) { func (h Controller) PlayerAim(data *user.AimatInboundInfo, c *player.Player) (result *user.AimatOutboundInfo, err errorcode.ErrorCode) {
result = &user.AimatOutboundInfo{ result = &user.AimatOutboundInfo{
ItemId: data.ItemId, ItemId: data.ItemId,
@@ -23,7 +23,7 @@ func (h Controller) Aimat(data *user.AimatInboundInfo, c *player.Player) (result
return return
} }
func (h Controller) Chat(data *user.ChatInboundInfo, c *player.Player) (result *user.ChatOutboundInfo, err errorcode.ErrorCode) { func (h Controller) PlayerChat(data *user.ChatInboundInfo, c *player.Player) (result *user.ChatOutboundInfo, err errorcode.ErrorCode) {
result = &user.ChatOutboundInfo{ result = &user.ChatOutboundInfo{
@@ -92,7 +92,7 @@ func (h Controller) ChangeNONOColor(data *user.ChangeNONOColorInboundInfo, c *pl
c.GetSpace().Broadcast(c, data.Head.CMD, result) c.GetSpace().Broadcast(c, data.Head.CMD, result)
return return
} }
func (h Controller) DANCE_ACTION(data *user.C2SDanceAction, c *player.Player) (result *user.S2CDanceAction, err errorcode.ErrorCode) { func (h Controller) DanceAction(data *user.C2SDanceAction, c *player.Player) (result *user.S2CDanceAction, err errorcode.ErrorCode) {
result = &user.S2CDanceAction{ result = &user.S2CDanceAction{
Type: data.Type, Type: data.Type,
@@ -101,7 +101,7 @@ func (h Controller) DANCE_ACTION(data *user.C2SDanceAction, c *player.Player) (r
c.GetSpace().Broadcast(c, data.Head.CMD, result) c.GetSpace().Broadcast(c, data.Head.CMD, result)
return return
} }
func (h Controller) PEOPLE_TRANSFROM(data *user.C2SPEOPLE_TRANSFROM, c *player.Player) (result *user.S2CPEOPLE_TRANSFROM, err errorcode.ErrorCode) { func (h Controller) PeopleTransform(data *user.C2SPEOPLE_TRANSFROM, c *player.Player) (result *user.S2CPEOPLE_TRANSFROM, err errorcode.ErrorCode) {
result = &user.S2CPEOPLE_TRANSFROM{ result = &user.S2CPEOPLE_TRANSFROM{
SuitID: data.SuitID, SuitID: data.SuitID,
@@ -117,8 +117,8 @@ func (h Controller) ChangePlayerCloth(data *item.ChangePlayerClothInboundInfo, c
ClothList: make([]model.PeopleItemInfo, 0), ClothList: make([]model.PeopleItemInfo, 0),
} }
for _, v := range data.ClothList { for _, clothID := range data.ClothList {
result.ClothList = append(result.ClothList, model.PeopleItemInfo{ID: v, Level: 1}) result.ClothList = append(result.ClothList, model.PeopleItemInfo{ID: clothID, Level: 1})
} }
c.Info.Clothes = result.ClothList c.Info.Clothes = result.ClothList

12
logic/controller/user_create.go
View File

@@ -12,19 +12,19 @@ import (
"github.com/panjf2000/gnet/v2" "github.com/panjf2000/gnet/v2"
) )
// 处理命令: 1001 // CreatePlayer 处理命令: 1001
func (h *Controller) CreatePlayer(data *user.CreatePlayerInboundInfo, c gnet.Conn) (result *user.CreatePlayerOutInfo, err errorcode.ErrorCode) { func (h Controller) CreatePlayer(data *user.CreatePlayerInboundInfo, c gnet.Conn) (result *user.CreatePlayerOutInfo, err errorcode.ErrorCode) {
data.Nickname = strings.Trim(data.Nickname, "\x00") data.Nickname = strings.Trim(data.Nickname, "\x00")
blservice.NewUserService(data.Head.UserID).Info.Reg(cool.Filter.Replace(data.Nickname, '*'), data.Color) blservice.NewUserService(data.Head.UserID).Info.Reg(cool.Filter.Replace(data.Nickname, '*'), data.Color)
return result, 0 return result, 0
} }
func (h *Controller) ChangePlayerName(data *user.ChangePlayerNameInboundInfo, c *player.Player) (result *user.ChangePlayerNameOutboundInfo, err errorcode.ErrorCode) { func (h Controller) ChangePlayerName(data *user.ChangePlayerNameInboundInfo, c *player.Player) (result *user.ChangePlayerNameOutboundInfo, err errorcode.ErrorCode) {
newnice := cool.Filter.Replace(strings.Trim(data.Nickname, "\x00"), '*') newNickname := cool.Filter.Replace(strings.Trim(data.Nickname, "\x00"), '*')
c.Info.Nick = newnice c.Info.Nick = newNickname
result = &user.ChangePlayerNameOutboundInfo{ result = &user.ChangePlayerNameOutboundInfo{
Nickname: newnice, Nickname: newNickname,
UserID: c.Info.UserID, UserID: c.Info.UserID,
} }
c.GetSpace().Broadcast(c, data.Head.CMD, result) c.GetSpace().Broadcast(c, data.Head.CMD, result)

6
logic/controller/user_friend.go
View File

@@ -6,7 +6,11 @@ import (
"blazing/logic/service/player" "blazing/logic/service/player"
) )
func (h Controller) OnSeeOnline(data *friend.SeeOnlineInboundInfo, c *player.Player) (result *friend.SeeOnlineOutboundInfo, err errorcode.ErrorCode) { // GetOnlineFriends 获取在线好友列表
// data: 包含用户ID列表的输入信息
// c: 当前玩家对象
// 返回: 好友在线信息和错误码
func (h Controller) GetOnlineFriends(data *friend.SeeOnlineInboundInfo, c *player.Player) (result *friend.SeeOnlineOutboundInfo, err errorcode.ErrorCode) {
result = &friend.SeeOnlineOutboundInfo{} result = &friend.SeeOnlineOutboundInfo{}
result.Friends = make([]friend.OnlineInfo, 0) result.Friends = make([]friend.OnlineInfo, 0)
return return

12
logic/controller/user_info.go
View File

@@ -12,8 +12,8 @@ import (
// UserSimInfo 根据用户ID获取模拟用户信息 // UserSimInfo 根据用户ID获取模拟用户信息
// data: 包含用户ID的输入信息 // data: 包含用户ID的输入信息
// c: 玩家对象 // c: 玩家对象
// 返回: 模拟用户信息及错误码 // GetUserSimInfo 返回: 模拟用户信息及错误码
func (h Controller) UserSimInfo(data *user.SimUserInfoInboundInfo, c *player.Player) (result *user.SimUserInfoOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetUserSimInfo(data *user.SimUserInfoInboundInfo, c *player.Player) (result *user.SimUserInfoOutboundInfo, err errorcode.ErrorCode) {
ret := &user.SimUserInfoOutboundInfo{} ret := &user.SimUserInfoOutboundInfo{}
copier.Copy(ret, c.Service.Info.Person(data.UserId)) copier.Copy(ret, c.Service.Info.Person(data.UserId))
@@ -23,8 +23,8 @@ func (h Controller) UserSimInfo(data *user.SimUserInfoInboundInfo, c *player.Pla
// UserMoreInfo 获取用户的更多信息。 // UserMoreInfo 获取用户的更多信息。
// data: 包含用户ID的输入信息。 // data: 包含用户ID的输入信息。
// c: 当前玩家对象。 // c: 当前玩家对象。
// 返回: 包含用户更多信息的输出结果和错误码。 // GetUserMoreInfo 返回: 包含用户更多信息的输出结果和错误码。
func (h Controller) UserMoreInfo(data *user.MoreUserInfoInboundInfo, c *player.Player) (result *user.MoreUserInfoOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetUserMoreInfo(data *user.MoreUserInfoInboundInfo, c *player.Player) (result *user.MoreUserInfoOutboundInfo, err errorcode.ErrorCode) {
ret := &user.MoreUserInfoOutboundInfo{} ret := &user.MoreUserInfoOutboundInfo{}
info := c.Service.Info.Person(data.UserId) info := c.Service.Info.Person(data.UserId)
copier.CopyWithOption(ret, info, copier.Option{IgnoreEmpty: true, DeepCopy: true}) copier.CopyWithOption(ret, info, copier.Option{IgnoreEmpty: true, DeepCopy: true})
@@ -33,7 +33,7 @@ func (h Controller) UserMoreInfo(data *user.MoreUserInfoInboundInfo, c *player.P
return ret, 0 return ret, 0
} }
func (h Controller) PlayerGoldCount(data *item.GoldOnlineRemainInboundInfo, c *player.Player) (result *item.GoldOnlineRemainOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetPlayerGoldCount(data *item.GoldOnlineRemainInboundInfo, c *player.Player) (result *item.GoldOnlineRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.GoldOnlineRemainOutboundInfo{ return &item.GoldOnlineRemainOutboundInfo{
@@ -41,7 +41,7 @@ func (h Controller) PlayerGoldCount(data *item.GoldOnlineRemainInboundInfo, c *p
Coin: c.Info.Coins, Coin: c.Info.Coins,
}, 0 }, 0
} }
func (h Controller) PlayerExp(data *item.ExpTotalRemainInboundInfo, c *player.Player) (result *item.ExpTotalRemainOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetPlayerExp(data *item.ExpTotalRemainInboundInfo, c *player.Player) (result *item.ExpTotalRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.ExpTotalRemainOutboundInfo{ return &item.ExpTotalRemainOutboundInfo{

18
logic/controller/user_talk.go
View File

@@ -7,20 +7,20 @@ import (
"blazing/modules/config/service" "blazing/modules/config/service"
) )
func (h Controller) Talk(data *item.TalkCountInboundInfo, c *player.Player) (result *item.TalkCountOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetTalkCount(data *item.TalkCountInboundInfo, c *player.Player) (result *item.TalkCountOutboundInfo, err errorcode.ErrorCode) {
result = &item.TalkCountOutboundInfo{} result = &item.TalkCountOutboundInfo{}
cid, ok := c.Service.Talk.Cheak(c.Info.MapID, int(data.ID)) talkCount, ok := c.Service.Talk.Cheak(c.Info.MapID, int(data.ID))
if !ok { if !ok {
return result, 0 return result, 0
} }
result.GiftCount = uint32(cid) result.GiftCount = uint32(talkCount)
return result, 0 return result, 0
} }
//var talkcacche = make(map[string]uint32) //var talkcacche = make(map[string]uint32)
func (h Controller) TalkCate(data *item.TalkCateInboundInfo, c *player.Player) (result *item.DayTalkInfo, err errorcode.ErrorCode) { func (h Controller) GetTalkCategory(data *item.TalkCateInboundInfo, c *player.Player) (result *item.DayTalkInfo, err errorcode.ErrorCode) {
result = &item.DayTalkInfo{} result = &item.DayTalkInfo{}
result.OutList = make([]item.CateInfo, 0) result.OutList = make([]item.CateInfo, 0)
@@ -33,11 +33,11 @@ func (h Controller) TalkCate(data *item.TalkCateInboundInfo, c *player.Player) (
//service.NewItemService().GetItemCount(config.ItemID) //service.NewItemService().GetItemCount(config.ItemID)
for _, itemid := range config.ItemID { for _, itemID := range config.ItemID {
ritemcount := service.NewItemService().GetItemCount(itemid) itemCount := service.NewItemService().GetItemCount(itemID)
ret := c.ItemAdd(uint32(itemid), uint32(ritemcount)) success := c.ItemAdd(uint32(itemID), uint32(itemCount))
if ret { if success {
result.OutList = append(result.OutList, item.CateInfo{ID: itemid, Count: uint32(ritemcount)}) result.OutList = append(result.OutList, item.CateInfo{ID: itemID, Count: uint32(itemCount)})
} }
} }

59
logic/controller/user_task.go
View File

@@ -31,25 +31,24 @@ func (h Controller) AcceptTask(data *task.AcceptTaskInboundInfo, c *player.Playe
} }
// AddTaskBuf 更新任务步骤 // AddTaskBuf 更新任务步骤
// data: 包含任务ID和任务步骤列表的输入信息
// c: 当前玩家对象
// 返回: 空输出结果和错误码
func (h Controller) AddTaskBuf(data *task.AddTaskBufInboundInfo, c *player.Player) (result *task.AddTaskBufOutboundInfo, err errorcode.ErrorCode) { func (h Controller) AddTaskBuf(data *task.AddTaskBufInboundInfo, c *player.Player) (result *task.AddTaskBufOutboundInfo, err errorcode.ErrorCode) {
// isdaliy := false c.Service.Task.Exec(data.TaskId, func(taskEx *model.TaskEX) bool {
// if data.Head.CMD != 2204 { //判断是每日任务 taskEx.Data = data.TaskList
// isdaliy = true
// }
c.Service.Task.Exec(data.TaskId, func(te *model.TaskEX) bool {
te.Data = data.TaskList
return true return true
}) })
return result, 0 return result, 0
} }
// Complete_Task 完成任务 // CompleteTask 完成任务
func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.Player) (result *task.CompleteTaskOutboundInfo, err errorcode.ErrorCode) { // data: 包含任务ID的输入信息
if c.Info.GetTask(int(data.TaskId)) != model.Accepted { //如果任务没有接受或者已经完成Complete_Task // c: 当前玩家对象
// 返回: 任务完成结果和错误码
func (h Controller) CompleteTask(data *task.CompleteTaskInboundInfo, c *player.Player) (result *task.CompleteTaskOutboundInfo, err errorcode.ErrorCode) {
if c.Info.GetTask(int(data.TaskId)) != model.Accepted {
return result, 0 return result, 0
} }
c.Info.SetTask(int(data.TaskId), model.Completed) c.Info.SetTask(int(data.TaskId), model.Completed)
@@ -59,26 +58,22 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
ItemList: make([]model.ItemInfo, 0), ItemList: make([]model.ItemInfo, 0),
} }
//提交任务 taskInfo := task.Get_Task_Info(*data)
//task.Tasktopic.Pub(*data) if taskInfo == nil {
return result, 0
tt := task.Get_Task_Info(*data)
if tt == nil {
return result, 0 //通过PUB/SUB回包
} }
if tt.PetTypeId != 0 { if taskInfo.PetTypeId != 0 {
r := model.GenPetInfo(int(tt.PetTypeId), 31, -1, 0, 50, nil) newPet := model.GenPetInfo(int(taskInfo.PetTypeId), 31, -1, 0, 50, nil)
result.PetTypeId = newPet.ID
result.PetTypeId = r.ID c.Service.Pet.PetAdd(newPet)
c.Service.Pet.PetAdd(r) result.CaptureTime = newPet.CatchTime
result.CaptureTime = r.CatchTime //这个写到后面,方便捕捉时间被修改后造成的时间不对问题
} }
for _, v := range tt.ItemList { for _, item := range taskInfo.ItemList {
ret := c.ItemAdd(v.ItemId, v.ItemCnt) //获取成功的条目 success := c.ItemAdd(item.ItemId, item.ItemCnt)
if ret { if success {
result.ItemList = append(result.ItemList, v) result.ItemList = append(result.ItemList, item)
} }
} }
@@ -86,8 +81,8 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
return result, 0 //通过PUB/SUB回包 return result, 0 //通过PUB/SUB回包
} }
// Get_Task_Buf 获取任务状态 // GetTaskBuf 获取任务状态
func (h Controller) Get_Task_Buf(data *task.GetTaskBufInboundInfo, c *player.Player) (result *task.GetTaskBufOutboundInfo, err errorcode.ErrorCode) { func (h Controller) GetTaskBuf(data *task.GetTaskBufInboundInfo, c *player.Player) (result *task.GetTaskBufOutboundInfo, err errorcode.ErrorCode) {
result = &task.GetTaskBufOutboundInfo{ result = &task.GetTaskBufOutboundInfo{
TaskId: data.TaskId, TaskId: data.TaskId,
} }
@@ -100,8 +95,8 @@ func (h Controller) Get_Task_Buf(data *task.GetTaskBufInboundInfo, c *player.Pla
return result, 0 return result, 0
} }
// Delete_Task 删除任务 // DeleteTask 删除任务
func (h Controller) Delete_Task(data *task.DeleteTaskInboundInfo, c *player.Player) (result *task.DeleteTaskOutboundInfo, err errorcode.ErrorCode) { func (h Controller) DeleteTask(data *task.DeleteTaskInboundInfo, c *player.Player) (result *task.DeleteTaskOutboundInfo, err errorcode.ErrorCode) {
if c.Info.GetTask(int(data.TaskId)) == model.Accepted { if c.Info.GetTask(int(data.TaskId)) == model.Accepted {
c.Info.SetTask(int(data.TaskId), model.Unaccepted) c.Info.SetTask(int(data.TaskId), model.Unaccepted)

2
logic/controller/walk.go
View File

@@ -7,7 +7,7 @@ import (
"blazing/logic/service/space/info" "blazing/logic/service/space/info"
) )
func (h Controller) Walk(data *space.WalkInInfo, c *player.Player) (result *info.WalkOutInfo, err errorcode.ErrorCode) { func (h Controller) PlayerWalk(data *space.WalkInInfo, c *player.Player) (result *info.WalkOutInfo, err errorcode.ErrorCode) {
result = &info.WalkOutInfo{ result = &info.WalkOutInfo{
Flag: data.Flag, Flag: data.Flag,
Point: data.Point, Point: data.Point,

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

@@ -15,102 +15,77 @@ import (
"github.com/gogf/gf/v2/util/grand" "github.com/gogf/gf/v2/util/grand"
) )
// 处理技能攻击逻辑 // processSkillAttack 处理技能攻击逻辑
func (f *FightC) processSkillAttack(attacker, defender *input.Input, a *info.SkillEntity) { func (f *FightC) processSkillAttack(attacker, defender *input.Input, skill *info.SkillEntity) {
//oldpet := f.copypet(attacker.CurrentPet) skill.AttackTimeC(attacker.GetProp(5, true)) //计算命中
a.AttackTimeC(attacker.GetProp(5, true)) //计算命中
defender.Exec(func(t input.Effect) bool { //计算闪避 ,然后修改对方命中),同时相当于计算属性无效这种
t.Ctx().SkillEntity = a
t.Skill_Hit_ex()
defender.Exec(func(effect input.Effect) bool { //计算闪避,然后修改对方命中),同时相当于计算属性无效这种
effect.Ctx().SkillEntity = skill
effect.Skill_Hit_ex()
return true return true
}) })
var oldprop [2][6]int8 var originalProps [2][6]int8
var oldinfo [2]model.PetInfo var originalPetInfo [2]model.PetInfo
oldprop[0], oldprop[1] = attacker.Prop, defender.Prop //先复制能力提升 originalProps[0], originalProps[1] = attacker.Prop, defender.Prop //先复制能力提升
oldinfo[0], oldinfo[1] = attacker.CurrentPet.Info, defender.CurrentPet.Info originalPetInfo[0], originalPetInfo[1] = attacker.CurrentPet.Info, defender.CurrentPet.Info
attacker.Exec(func(t input.Effect) bool { attacker.Exec(func(effect input.Effect) bool {
//计算变威力 //计算变威力
t.Ctx().SkillEntity = a effect.Ctx().SkillEntity = skill
t.Skill_Hit() //相当于先调整基础命中,不光调整命中，这里还能调整技能属性，暴击率 effect.Skill_Hit() //相当于先调整基础命中,不光调整命中，这里还能调整技能属性，暴击率
return true return true
}) })
//技能命中+效果失效 这里就是修改效果命中为false //技能命中+效果失效 这里就是修改效果命中为false
//技能miss+效果生效 这里属于强制改命中效果,但是正常来说,技能miss掉后效果也应该失效 //技能miss+效果生效 这里属于强制改命中效果,但是正常来说,技能miss掉后效果也应该失效
//技能失效+效果失效 //技能失效+效果失效
// 记录技能信息 attacker.AttackTime = skill.AttackTime
//如果miss或者失效 attacker.SkillID = uint32(skill.ID) //获取技能ID
if skill.AttackTime != 0 { //如果命中
attacker.AttackTime = a.AttackTime attacker.CalculateCrit(defender, skill) //暴击计算
attacker.SkillID = uint32(a.ID) //获取技能ID attacker.IsCritical = skill.Crit
if a.AttackTime != 0 { //如果命中 attacker.SumDamage = attacker.CalculatePower(defender, skill)
attacker.CalculateCrit(defender, a) //暴击计算
attacker.IsCritical = a.Crit
attacker.SumDamage = attacker.CalculatePower(defender, a)
//睡眠受击消除
} }
attacker.Prop, defender.Prop = oldprop[0], oldprop[1] //先复制能力提升 attacker.Prop, defender.Prop = originalProps[0], originalProps[1]
attacker.CurrentPet.Info, defender.CurrentPet.Info = oldinfo[0], oldinfo[1] attacker.CurrentPet.Info, defender.CurrentPet.Info = originalPetInfo[0], originalPetInfo[1]
if attacker.IsCritical == 1 { //命中了才有暴击 if attacker.IsCritical == 1 { //命中了才有暴击
//暴击破防 //暴击破防
if a.Category() == info.Category.PHYSICAL && defender.Prop[1] > 0 { if skill.Category() == info.Category.PHYSICAL && defender.Prop[1] > 0 {
defender.Prop[1] = 0 defender.Prop[1] = 0
} else if a.Category() == info.Category.SPECIAL && defender.Prop[3] > 0 { } else if skill.Category() == info.Category.SPECIAL && defender.Prop[3] > 0 {
defender.Prop[3] = 0 defender.Prop[3] = 0
} }
//暴击翻倍 //暴击翻倍
attacker.SumDamage = attacker.SumDamage.Mul(alpacadecimal.NewFromInt(2)) attacker.SumDamage = attacker.SumDamage.Mul(alpacadecimal.NewFromInt(2))
} }
if !a.Side { //|| attacker.AttackTime == 0 { if !skill.Side {
//这时候将被覆盖的效果全部装回来enterturn //这时候将被覆盖的效果全部装回来enterturn
for _, e := range attacker.Effect_Lost { for _, effect := range attacker.Effect_Lost {
if e.Duration() > 0 || e.Duration() == -1 { if effect.Duration() > 0 || effect.Duration() == -1 {
e.Alive(true) effect.Alive(true)
} }
} }
} else { } else {
// attacker.AddEffects(attacker.EffectCache...) //命中再添加效果 for _, effect := range attacker.EffectCache {
for _, e := range attacker.EffectCache { effect.Hit(true) //我方效果命中
//这里实现应该参考本地技能是否命中,然后
e.Hit(true) //我方效果命中
} }
} }
// 扣减防御方血量 // 扣减防御方血量
attacker.Exec(func(t input.Effect) bool { attacker.Exec(func(effect input.Effect) bool {
t.Ctx().SkillEntity = a effect.Ctx().SkillEntity = skill
effect.OnSkill() //调用伤害计算
t.OnSkill() //调用伤害计算
return true return true
}) })
defender.Damage(attacker, &info.DamageZone{ defender.Damage(attacker, &info.DamageZone{
Damage: attacker.SumDamage, Damage: attacker.SumDamage,
}, })
)
//这里其实是受到致死伤害
//然后先触发死亡效果，消除所有buff
//然后触发回神效果
} }
// IsNil 检查值是否为nil
func IsNil(x interface{}) bool { func IsNil(x interface{}) bool {
if x == nil { if x == nil {
return true return true
@@ -118,23 +93,24 @@ func IsNil(x interface{}) bool {
rv := reflect.ValueOf(x) rv := reflect.ValueOf(x)
return rv.Kind() == reflect.Ptr && rv.IsNil() return rv.Kind() == reflect.Ptr && rv.IsNil()
} }
func (f *FightC) copyskill(t *action.SelectSkillAction) *info.SkillEntity {
if t == nil { // copySkill 复制技能实体
func (f *FightC) copySkill(action *action.SelectSkillAction) *info.SkillEntity {
if action == nil {
return nil return nil
} }
if t.SkillEntity == nil { if action.SkillEntity == nil {
return nil return nil
} }
oldskill, _ := deepcopy.Anything(t.SkillEntity) //备份技能 originalSkill, _ := deepcopy.Anything(action.SkillEntity) //备份技能
oldskill.(*info.SkillEntity).Rand = f.rand //拷贝后随机数丢失 originalSkill.(*info.SkillEntity).Rand = f.rand //拷贝后随机数丢失
return oldskill.(*info.SkillEntity) return originalSkill.(*info.SkillEntity)
} }
//回合有先手方和后手方,同时有攻击方和被攻击方 // enterturn 处理战斗回合逻辑
// 回合有先手方和后手方,同时有攻击方和被攻击方
func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) { func (f *FightC) enterturn(firstAttack, secondAttack *action.SelectSkillAction) {
//双方首发精灵登场时，依挑战方机制：房主方先判定，挑战方后判定 //双方首发精灵登场时，依挑战方机制：房主方先判定，挑战方后判定
//双方非首发精灵登场时，根据切换先后判定(看手速) //双方非首发精灵登场时，根据切换先后判定(看手速)
// 神罗、圣华登场时魂免，“登场时xx”等效果 // 神罗、圣华登场时魂免，“登场时xx”等效果
@@ -145,171 +121,134 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
} }
f.Broadcast(func(ff *input.Input) { f.Broadcast(func(ff *input.Input) {
ff.Exec(func(t input.Effect) bool { //回合开始前 ff.Exec(func(effect input.Effect) bool { //回合开始前
effect.Turn_Start(firstAttack, secondAttack)
//结算状态
t.Turn_Start(fattack, sattack)
return true return true
}) })
}) })
if fattack != nil { //如果首技能是空的,说明都空过了 if firstAttack != nil { //如果首技能是空的,说明都空过了
if firstAttack.GetPlayerID() == f.ownerID {
if fattack.GetPlayerID() == f.ownerID {
//是否miss都应该施加解析effect //是否miss都应该施加解析effect
f.Our.Parseskill(fattack) //解析到临时数据 f.Our.Parseskill(firstAttack) //解析到临时数据
f.Opp.Parseskill(secondAttack) //解析到临时数据
f.Opp.Parseskill(sattack) //解析到临时数据
} else { } else {
f.Opp.Parseskill(fattack) f.Opp.Parseskill(firstAttack)
f.Our.Parseskill(sattack) f.Our.Parseskill(secondAttack)
} }
} }
f.Broadcast(func(ff *input.Input) { f.Broadcast(func(fighter *input.Input) {
ff.Exec(func(t input.Effect) bool { //回合开始前 fighter.Exec(func(effect input.Effect) bool { //回合开始前
effect.Compare_Pre(firstAttack, secondAttack) //先结算技能的优先级
//结算状态
t.Compare_Pre(fattack, sattack) //先结算技能的优先级
return true return true
}) })
fighter.ResetAttackValue()
ff.ResetAttackValue()
}) })
f.First, f.Second = f.Our, f.Opp f.First, f.Second = f.Our, f.Opp
// 根据攻击方归属设置当前战斗的主/次攻击方属性 if firstAttack != nil {
if fattack != nil { if firstAttack.GetPlayerID() != f.ownerID {
if fattack.GetPlayerID() != f.ownerID {
f.First, f.Second = f.Opp, f.Our // 攻击方为对方时，主攻击方是对方 f.First, f.Second = f.Opp, f.Our // 攻击方为对方时，主攻击方是对方
} }
} }
if fattack != nil && sattack != nil { if firstAttack != nil && secondAttack != nil {
switch { switch {
case firstAttack.SkillEntity.Priority < secondAttack.SkillEntity.Priority:
case fattack.SkillEntity.Priority < sattack.SkillEntity.Priority: firstAttack, secondAttack = secondAttack, firstAttack //互换先手权
fattack, sattack = sattack, fattack //互换先手权
f.First, f.Second = f.Second, f.First f.First, f.Second = f.Second, f.First
case fattack.SkillEntity.Priority == sattack.SkillEntity.Priority: case firstAttack.SkillEntity.Priority == secondAttack.SkillEntity.Priority:
if f.Second.GetProp(4, false) > f.First.GetProp(4, false) { if f.Second.GetProp(4, false) > f.First.GetProp(4, false) {
fattack, sattack = sattack, fattack //互换先手权 firstAttack, secondAttack = secondAttack, firstAttack //互换先手权
f.First, f.Second = f.Second, f.First f.First, f.Second = f.Second, f.First
} }
if f.Second.GetProp(4, false) == f.First.GetProp(4, false) { if f.Second.GetProp(4, false) == f.First.GetProp(4, false) {
if grand.Meet(1, 2) { //随机出手 if grand.Meet(1, 2) { //随机出手
fattack, sattack = sattack, fattack //互换先手权 firstAttack, secondAttack = secondAttack, firstAttack //互换先手权
f.First, f.Second = f.Second, f.First f.First, f.Second = f.Second, f.First
} }
} }
} }
} }
if fattack == nil && sattack == nil { if firstAttack == nil && secondAttack == nil {
fattack, sattack = sattack, fattack //互换先手权 firstAttack, secondAttack = secondAttack, firstAttack //互换先手权
f.First, f.Second = f.Second, f.First f.First, f.Second = f.Second, f.First
} }
var attacker, defender *input.Input var attacker, defender *input.Input
//开始回合操作 //开始回合操作
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
var oldskill *info.SkillEntity //原始技能 var originalSkill *info.SkillEntity //原始技能
var currentskill *info.SkillEntity //当前技能 var currentSkill *info.SkillEntity //当前技能
if i == 0 { // if i == 0 {
attacker, defender = f.First, f.Second attacker, defender = f.First, f.Second
oldskill = f.copyskill(fattack) originalSkill = f.copySkill(firstAttack)
//先手阶段，先修复后手效果 //先手阶段，先修复后手效果
f.Second.RecoverEffect() f.Second.RecoverEffect()
} else { } else {
attacker, defender = f.Second, f.First attacker, defender = f.Second, f.First
oldskill = f.copyskill(sattack) originalSkill = f.copySkill(secondAttack)
f.Second.ReactvieEffect() f.Second.ReactvieEffect()
} }
currentskill = oldskill currentSkill = originalSkill
defender.Exec(func(t input.Effect) bool { //这个是能否使用技能 defender.Exec(func(effect input.Effect) bool { //这个是能否使用技能
//结算状态 effect.Ctx().SkillEntity = currentSkill
//然后这里还可以处理自爆类 return effect.Action_start_ex(firstAttack, secondAttack)
t.Ctx().SkillEntity = currentskill
return t.Action_start_ex(fattack, sattack) //返回本身结算,如果false,说明不能使用技能了
}) })
canuseskill := attacker.Exec(func(t input.Effect) bool { //这个是能否使用技能 canUseSkill := attacker.Exec(func(effect input.Effect) bool { //这个是能否使用技能
//结算状态 effect.Ctx().SkillEntity = currentSkill
//然后这里还可以处理自爆类 return effect.Action_start(firstAttack, secondAttack)
t.Ctx().SkillEntity = currentskill
return t.Action_start(fattack, sattack) //返回本身结算,如果false,说明不能使用技能了
}) })
canuse := canuseskill && // canUse := canUseSkill && action.CanUse(currentSkill) && attacker.CurrentPet.Info.Hp > 0
action.CanUse(currentskill) && //pp还在
attacker.CurrentPet.Info.Hp > 0
if !canuse { if !canUse {
attacker.RecoverEffect() attacker.RecoverEffect()
currentskill = nil currentSkill = nil
} else { } else {
f.processSkillAttack(attacker, defender, currentSkill)
f.processSkillAttack(attacker, defender, currentskill) currentSkill = originalSkill //还原技能
currentskill = oldskill //还原技能
_, skill, ok := utils.FindWithIndex(attacker.CurrentPet.Info.SkillList, func(item model.SkillInfo) bool { _, skill, ok := utils.FindWithIndex(attacker.CurrentPet.Info.SkillList, func(item model.SkillInfo) bool {
return item.ID == currentskill.Info.ID return item.ID == currentSkill.Info.ID
}) })
if ok { if ok {
skill.PP-- skill.PP--
} }
} }
//0血不触发
if defender.CurrentPet.Info.Hp > 0 { if defender.CurrentPet.Info.Hp > 0 {
//技能使用后 //技能使用后
defender.Exec(func(t input.Effect) bool { defender.Exec(func(effect input.Effect) bool {
t.Ctx().SkillEntity = currentskill effect.Ctx().SkillEntity = currentSkill
effect.Skill_Use_ex()
t.Skill_Use_ex()
return true return true
}) })
} }
//技能使用后 //技能使用后
attacker.Exec(func(t input.Effect) bool { //技能使用后的我方效果 attacker.Exec(func(effect input.Effect) bool { //技能使用后的我方效果
t.Ctx().SkillEntity = currentskill effect.Ctx().SkillEntity = currentSkill
effect.Skill_Useed()
t.Skill_Useed()
return true return true
}) })
defender.Exec(func(t input.Effect) bool { defender.Exec(func(effect input.Effect) bool {
t.Ctx().SkillEntity = currentskill effect.Ctx().SkillEntity = currentSkill
effect.Action_end_ex()
t.Action_end_ex()
return true return true
}) })
if !attacker.CurrentPet.NotAlive { if !attacker.CurrentPet.NotAlive {
//技能使用后 //技能使用后
attacker.Exec(func(t input.Effect) bool { //技能使用后的我方效果 attacker.Exec(func(effect input.Effect) bool { //技能使用后的我方效果
t.Ctx().SkillEntity = currentskill effect.Ctx().SkillEntity = currentSkill
effect.Action_end()
t.Action_end()
return true return true
}) })
} }
fmt.Println(i, fmt.Println(i,
// "玩家技能:", oldskill.(*info.SkillEntity).ID,
"玩家技能伤害:", attacker.SumDamage, "玩家技能伤害:", attacker.SumDamage,
"自身剩余血量:", attacker.CurrentPet.Info.Hp, "自身剩余血量:", attacker.CurrentPet.Info.Hp,
"对手剩余血量:", defender.CurrentPet.Info.Hp, "对手剩余血量:", defender.CurrentPet.Info.Hp,
@@ -368,33 +307,26 @@ func (f *FightC) enterturn(fattack, sattack *action.SelectSkillAction) {
ff.GenInfo() ff.GenInfo()
}) })
ret := info.AttackValueS{ attackValueResult := info.AttackValueS{
FAttack: *f.First.AttackValue, FAttack: *f.First.AttackValue,
SAttack: *f.Second.AttackValue, SAttack: *f.Second.AttackValue,
} }
//因为切完才能广播,所以必须和回合结束分开结算 //因为切完才能广播,所以必须和回合结束分开结算
f.Broadcast(func(ff *input.Input) { f.Broadcast(func(fighter *input.Input) {
for _, v := range f.Switch { for _, switchAction := range f.Switch {
if fighter.Player.GetInfo().UserID != switchAction.Reason.UserId {
if ff.Player.GetInfo().UserID != v.Reason.UserId { println("切精灵", switchAction.Reason.UserId, switchAction.Reason.ID)
fighter.Player.SendPackCmd(2407, &switchAction.Reason)
println("切精灵", v.Reason.UserId, v.Reason.ID)
ff.Player.SendPackCmd(2407, &v.Reason)
} }
} }
}) })
f.Switch = make(map[uint32]*action.ActiveSwitchAction) f.Switch = make(map[uint32]*action.ActiveSwitchAction)
if f.closefight && f.Info.Mode == info.BattleMode.PET_MELEE { if f.closefight && f.Info.Mode == info.BattleMode.PET_MELEE {
return return
} }
f.Broadcast(func(ff *input.Input) { f.Broadcast(func(fighter *input.Input) {
fighter.Player.SendPackCmd(2505, &attackValueResult)
ff.Player.SendPackCmd(2505, &ret) fighter.CanChange = 0
ff.CanChange = 0
}) })
println("回合结束") println("回合结束")
if f.Info.Status == info.BattleMode.FIGHT_WITH_NPC { if f.Info.Status == info.BattleMode.FIGHT_WITH_NPC {

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

@@ -31,35 +31,39 @@ func newbaseplayer() baseplayer {
} }
return ret return ret
} }
func (p *baseplayer) GetInfo() *model.PlayerInfo {
// GetInfo 获取玩家基础信息
func (p *baseplayer) GetInfo() *model.PlayerInfo {
return p.Info return p.Info
} }
func (f *baseplayer) SetFightC(ff common.FightI) {
f.FightC = ff // SetFightC 设置玩家战斗控制器
func (f *baseplayer) SetFightC(fightController common.FightI) {
f.FightC = fightController
} }
// GetPlayerCaptureContext 获取玩家捕捉上下文
func (f *baseplayer) GetPlayerCaptureContext() *info.PlayerCaptureContext { func (f *baseplayer) GetPlayerCaptureContext() *info.PlayerCaptureContext {
return f.PlayerCaptureContext return f.PlayerCaptureContext
} }
func (f *baseplayer) FindPet(CatchTime uint32) (int, *model.PetInfo, bool) { // FindPet 根据捕捉时间查找宠物
// 返回值: (索引, 宠物信息, 是否找到)
func (f *baseplayer) FindPet(catchTime uint32) (int, *model.PetInfo, bool) {
return utils.FindWithIndex(f.Info.PetList, func(item model.PetInfo) bool { return utils.FindWithIndex(f.Info.PetList, func(item model.PetInfo) bool {
return item.CatchTime == CatchTime return item.CatchTime == catchTime
}) })
} }
func (f *Player) Pet_del(CatchTime uint32) {
//println("删除精灵1", CatchTime) // Pet_del 删除指定宠物
index, _, ok := f.FindPet(CatchTime) // catchTime: 宠物的捕捉时间戳
func (f *Player) Pet_del(catchTime uint32) {
index, _, ok := f.FindPet(catchTime)
if ok { if ok {
// println("删除精灵", CatchTime)
copy(f.Info.PetList[index:], f.Info.PetList[index+1:]) copy(f.Info.PetList[index:], f.Info.PetList[index+1:])
f.Info.PetList = f.Info.PetList[:len(f.Info.PetList)-1] f.Info.PetList = f.Info.PetList[:len(f.Info.PetList)-1]
f.Service.Pet.Pet_del(CatchTime) f.Service.Pet.Pet_del(catchTime)
} }
} }
// // 计算整数的二进制1的个数（Integer.bitCount） // // 计算整数的二进制1的个数（Integer.bitCount）

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

@@ -7,59 +7,34 @@ import (
"sync/atomic" "sync/atomic"
) )
func (p *Player) JoinFight(fn func(p common.PlayerI) bool) errorcode.ErrorCode { // JoinFight 加入战斗队列
func (p *Player) JoinFight(handler func(p common.PlayerI) bool) errorcode.ErrorCode {
//加入队列前就开始判断一次 //加入队列前就开始判断一次
if !p.CanFight() { if !p.CanFight() {
return errorcode.ErrorCodes.ErrNoEligiblePokemon return errorcode.ErrorCodes.ErrNoEligiblePokemon
} }
if p.GetSpace().Owner.UserID == p.Info.UserID { if p.GetSpace().Owner.UserID == p.Info.UserID {
return errorcode.ErrorCodes.ErrSystemError return errorcode.ErrorCodes.ErrSystemError
} }
//修复发包进入,如果此时是擂台主
p.GetSpace().User.Range(func(key uint32, v common.PlayerI) bool { p.GetSpace().User.Range(func(key uint32, opponent common.PlayerI) bool {
if opponent.GetInfo().UserID != p.Info.UserID {
if v.GetInfo().UserID != p.Info.UserID {
//确认是乱斗模式 //确认是乱斗模式
if opponent.Getfightinfo() == p.Getfightinfo() && p.CanFight() {
if v.Getfightinfo() == p.Getfightinfo() && p.CanFight() { success := handler(opponent)
if success {
// p.Fightinfo = nil //先将自身的准备信息置空 atomic.StoreUint32(&opponent.(*Player).Fightinfo.Mode, 0)
// //value.PVPinfo = nil
ttt := fn(v)
if ttt {
atomic.StoreUint32(&v.(*Player).Fightinfo.Mode, 0)
atomic.StoreUint32(&p.Fightinfo.Mode, 0) atomic.StoreUint32(&p.Fightinfo.Mode, 0)
} }
return success //如果发起成功就停止,否则继续遍历队列
// lw = value
return ttt //如果发起成功就停止,否则继续遍历队列
} }
} }
return false return false
}) })
return 0 return 0
} }
func (p *Player) SendLoadPercent(b info.LoadPercentOutboundInfo) { // SendLoadPercent 发送加载进度
func (p *Player) SendLoadPercent(loadInfo info.LoadPercentOutboundInfo) {
p.SendPack(common.NewTomeeHeader(2441, p.Info.UserID).Pack(&b)) //准备包由各自发,因为协议不一样 p.SendPack(common.NewTomeeHeader(2441, p.Info.UserID).Pack(&loadInfo))
} }
// 同意对战
// AgreeBattle 处理战斗邀请响应（同意/拒绝）
// 参数：
//
// userid：邀请者ID
// flag：0-拒绝，1-同意
// mode：战斗模式
//
// 返回：
//
// bool：是否成功（仅同意且符合条件时为true）
// common.PlayerI：对应的邀请者玩家（成功时有效）

86
logic/service/player/pet.go
View File

@@ -11,82 +11,64 @@ import (
"github.com/jinzhu/copier" "github.com/jinzhu/copier"
) )
// 主函数实现 // AddPetExp 添加宠物经验
// 添加经验 func (p *Player) AddPetExp(petInfo *model.PetInfo, addExp uint32) {
// 禁止发包
func (p *Player) AddPetExp(petinfo *model.PetInfo, addExp uint32) {
addExp = utils.Min(addExp, p.Info.ExpPool) addExp = utils.Min(addExp, p.Info.ExpPool)
originalLevel := petinfo.Level originalLevel := petInfo.Level
Exp := petinfo.Exp + addExp exp := petInfo.Exp + addExp
p.Info.ExpPool -= addExp //减去已使用的经验 p.Info.ExpPool -= addExp //减去已使用的经验
gainexp := Exp //已获得的经验 gainedExp := exp //已获得的经验
for Exp >= petinfo.NextLvExp { for exp >= petInfo.NextLvExp {
petinfo.Level++ petInfo.Level++
Exp -= petinfo.LvExp exp -= petInfo.LvExp
petinfo.Update(true) petInfo.Update(true)
if originalLevel < 100 && petinfo.Level == 100 { //升到100了 if originalLevel < 100 && petInfo.Level == 100 { //升到100了
p.Info.ExpPool += Exp //减去已使用的经验 p.Info.ExpPool += exp //减去已使用的经验
gainexp -= Exp gainedExp -= exp
Exp = 0 exp = 0
break //停止升级 break //停止升级
} }
} }
petinfo.Exp = Exp petInfo.Exp = exp
// 重新计算面板 // 重新计算面板
if originalLevel != petinfo.Level { if originalLevel != petInfo.Level {
petinfo.CalculatePetPane(false) petInfo.CalculatePetPane(false)
petinfo.Cure() petInfo.Cure()
p.Info.PetMaxLevel = utils.Max(petinfo.Level, p.Info.PetMaxLevel) p.Info.PetMaxLevel = utils.Max(petInfo.Level, p.Info.PetMaxLevel)
// 处理技能学习 // 处理技能学习
canLearnSkillList := utils.LastFourElements(petinfo.GetLevelRangeCanLearningSkills(originalLevel, petinfo.Level), 4) //获取最后四个技能,如果不足,那就取全部技能 learnableSkills := utils.LastFourElements(petInfo.GetLevelRangeCanLearningSkills(originalLevel, petInfo.Level), 4) //获取最后四个技能,如果不足,那就取全部技能
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
if len(canLearnSkillList) != 0 { if len(learnableSkills) != 0 {
skid := canLearnSkillList[len(canLearnSkillList)-1] skillID := learnableSkills[len(learnableSkills)-1]
petinfo.SkillList = append(petinfo.SkillList, model.SkillInfo{ petInfo.SkillList = append(petInfo.SkillList, model.SkillInfo{
ID: skid, ID: skillID,
PP: uint32(xmlres.SkillMap[int(skid)].MaxPP), PP: uint32(xmlres.SkillMap[int(skillID)].MaxPP),
}) })
canLearnSkillList = canLearnSkillList[:len(canLearnSkillList)-1] learnableSkills = learnableSkills[:len(learnableSkills)-1]
} }
} }
if len(petinfo.SkillList) > 4 { if len(petInfo.SkillList) > 4 {
petinfo.SkillList = petinfo.SkillList[:4] //归正到4 petInfo.SkillList = petInfo.SkillList[:4] //归正到4
} }
} }
t1 := common.NewTomeeHeader(2508, p.Info.UserID) header := common.NewTomeeHeader(2508, p.Info.UserID)
rrr := &info.PetUpdateOutboundInfo{} updateOutbound := &info.PetUpdateOutboundInfo{}
var petinfwo info.UpdatePropInfo var petUpdateInfo info.UpdatePropInfo
copier.Copy(&petinfwo, petinfo) copier.Copy(&petUpdateInfo, petInfo)
petinfwo.Exp = gainexp petUpdateInfo.Exp = gainedExp
rrr.Data = append(rrr.Data, petinfwo) updateOutbound.Data = append(updateOutbound.Data, petUpdateInfo)
p.SendPack(t1.Pack(rrr)) //准备包由各自发,因为协议不一样 p.SendPack(header.Pack(updateOutbound)) //准备包由各自发,因为协议不一样
// 发送经验更新消息
//player.SendMessage(generatePetUpdateInfo(petEntity, originalExp+addExp-exp, addition))
// // 发送技能更新消息
// updateSkillInfo := UpdateSkillInfo{
// PetCatchTime: petEntity.captureTime,
// ActiveSkillNum: activeSkillNum,
// UnActiveSkillNum: unActiveSkillNum,
// SkillArray: canLearnSkillList,
// }
// player.SendMessage(UpdateSkillOutboundInfo{
// InfoArray: []UpdateSkillInfo{updateSkillInfo},
// })
// return exp
} }

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

@@ -22,8 +22,8 @@ import (
"github.com/panjf2000/gnet/v2" "github.com/panjf2000/gnet/v2"
) )
func ConutPlayer() int { // CountPlayer 统计在线玩家数量
func CountPlayer() int {
count := 0 count := 0
Mainplayer.Range(func(uint32, *Player) bool { Mainplayer.Range(func(uint32, *Player) bool {
count++ count++
@@ -32,7 +32,8 @@ func ConutPlayer() int {
return count return count
} }
var Mainplayer = &utils.SyncMap[uint32, *Player]{} //玩家数据 // Mainplayer 全局玩家数据存储映射
var Mainplayer = &utils.SyncMap[uint32, *Player]{}
type OgreInfo struct { type OgreInfo struct {
Data [9]OgrePetInfo Data [9]OgrePetInfo
@@ -86,9 +87,9 @@ type Player struct {
MapNPC timer.TimeNoder MapNPC timer.TimeNoder
context.Context context.Context
Fightinfo info.Fightinfo //当前邀请的玩家ID Fightinfo info.Fightinfo // 当前邀请的玩家ID
Logintime uint32 //当前登录时间 Logintime uint32 // 当前登录时间
OgreInfo OgreInfo OgreInfo OgreInfo
Service *blservice.UserService Service *blservice.UserService
@@ -96,41 +97,39 @@ type Player struct {
// PVP被邀请信息 // PVP被邀请信息
HavePVPinfo []common.PlayerI HavePVPinfo []common.PlayerI
monsters [3]int monsters [3]int
//0 无,1可以刷怪,2是切换过地图 // 0 无,1可以刷怪,2是切换过地图
Canmon uint32 //可以刷怪 Canmon uint32 // 可以刷怪
// Changemap bool //是否切换过地图
} }
// PlayerOption 定义配置 Player 的函数类型 // PlayerOption 定义配置 Player 的函数类型
type PlayerOption func(*Player) type PlayerOption func(*Player)
// WithConn 设置玩家连接的配置选项
func WithConn(c gnet.Conn) PlayerOption { func WithConn(c gnet.Conn) PlayerOption {
return func(p *Player) { return func(p *Player) {
p.MainConn = c p.MainConn = c
} }
} }
func (p *Player) UseCoins(t uint32) bool {
if p.Info.Coins < t { func (p *Player) UseCoins(amount uint32) bool {
if p.Info.Coins < amount {
return false return false
} }
return true return true
} }
func (p *Player) UseGold(t uint32) bool {
if p.User.GetGold(uint(p.Info.UserID)) < t { func (p *Player) UseGold(amount uint32) bool {
if p.User.GetGold(uint(p.Info.UserID)) < amount {
return false return false
} }
//p.Info.GoldBean = p.Info.GoldBean - t
return true return true
} }
func (p *Player) GetAction() { func (p *Player) GetAction() {
} }
// InvitePlayer 邀请玩家进行对战
func (f *Player) InvitePlayer(ff common.PlayerI) { func (f *Player) InvitePlayer(ff common.PlayerI) {
f.HavePVPinfo = append(f.HavePVPinfo, ff) f.HavePVPinfo = append(f.HavePVPinfo, ff)
tt := common.NewTomeeHeader(2501, f.GetInfo().UserID) tt := common.NewTomeeHeader(2501, f.GetInfo().UserID)
@@ -139,51 +138,46 @@ func (f *Player) InvitePlayer(ff common.PlayerI) {
Nick: ff.GetInfo().Nick, Nick: ff.GetInfo().Nick,
Mode: ff.Getfightinfo().Mode, Mode: ff.Getfightinfo().Mode,
})) }))
} }
// Getfightinfo 获取玩家的战斗信息
func (p *Player) Getfightinfo() info.Fightinfo { func (p *Player) Getfightinfo() info.Fightinfo {
return p.Fightinfo return p.Fightinfo
} }
// QuitFight 退出战斗
func (p *Player) QuitFight() { func (p *Player) QuitFight() {
p.FightC = nil p.FightC = nil
atomic.StoreUint32(&p.Fightinfo.Mode, 0) atomic.StoreUint32(&p.Fightinfo.Mode, 0)
} }
// GetSpace 获取玩家所在的空间
func (p *Player) GetSpace() *space.Space { func (p *Player) GetSpace() *space.Space {
return space.GetSpace(p.Info.MapID) return space.GetSpace(p.Info.MapID)
} }
// CanFight 检查玩家是否可以进行战斗
// 0无战斗，1PVP，2,BOOS,3PVE // 0无战斗，1PVP，2,BOOS,3PVE
func (p *Player) CanFight() bool { func (p *Player) CanFight() bool {
if len(p.Info.PetList) == 0 { if len(p.Info.PetList) == 0 {
atomic.StoreUint32(&p.Fightinfo.Mode, 0) atomic.StoreUint32(&p.Fightinfo.Mode, 0)
return false return false
} }
if p.FightC != nil { if p.FightC != nil {
atomic.StoreUint32(&p.Fightinfo.Mode, 0) atomic.StoreUint32(&p.Fightinfo.Mode, 0)
return false return false
} }
// if p.GetSpace().ARENA.ChallengerID == p.Info.UserID || p.GetSpace().ARENA.Id == p.Info.UserID {
// return false for _, pet := range p.Info.PetList {
// } if pet.Hp > 0 { // 只要找到一个血量大于0的宠物，就可以战斗
for _, v := range p.Info.PetList {
if v.Hp > 0 { // 只要找到一个血量大于0的宠物，就可以战斗
return true return true
} }
} }
// 遍历完所有宠物，都没有血量大于0的，才不能战斗 // 遍历完所有宠物，都没有血量大于0的，才不能战斗
atomic.StoreUint32(&p.Fightinfo.Mode, 0) atomic.StoreUint32(&p.Fightinfo.Mode, 0)
return false return false
// }
// return false
} }
func (p *Player) SendPack(b []byte) error { func (p *Player) SendPack(b []byte) error {
@@ -192,17 +186,13 @@ func (p *Player) SendPack(b []byte) error {
} }
_, ok := p.MainConn.Context().(*ClientData) _, ok := p.MainConn.Context().(*ClientData)
if ok { if ok {
return p.MainConn.Context().(*ClientData).SendPack(b) return p.MainConn.Context().(*ClientData).SendPack(b)
} }
return nil return nil
} }
// 添加物品 返回成功添加的物品 // 添加物品 返回成功添加的物品
func (p *Player) ItemAdd(ItemId, ItemCnt uint32) (result bool) { func (p *Player) ItemAdd(ItemId, ItemCnt uint32) (result bool) {
switch ItemId { switch ItemId {
case 1: //塞尔豆 case 1: //塞尔豆
p.Info.Coins = p.Info.Coins + ItemCnt p.Info.Coins = p.Info.Coins + ItemCnt