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

feat(xmlres): 实装性格重塑,实装性格指定

Browse Source 
fix(fight): 使用模型层方法生成精灵信息
refactor(controller): 移除冗余变量与内联XML读取逻辑
refactor(pet): 重构经验更新与进化逻辑
refactor(item): 校验并扣减使用道具数量
feat(item): 新增金豆购买商品协议结构体
feat(user): 迁移角色服装变更逻辑至user控制器
feat(pet): 增加技能排序协议定义
refactor(utils): 移除未使用的工具函数引用
chore(config): 更新地图怪物配置信息

详细变更内容包括：
- 在`xmlres/file.go`中初始化`GoldProductMap`并加载相关配置。
- 将`GenPetInfo`方法从玩家服务迁移至`model`包以统一管理。
- 合并部分不必要的局部变量声明，并优化XML资源加载方式。
- 拆分精灵升级与进化方法，明确调用职责。
- 在战斗和治疗等操作前增加货币校验及扣除逻辑。
- 补充金豆购买相关的客户端/服务端通信结构体。
- 调整技能选择逻辑避免潜在索引越界问题。
- 更新部分注释说明和代码结构以提升可维护性。
This commit is contained in:
昔念
2025-11-25 12:29:50 +08:00
parent 147758c5ae
commit 40d72790ff
23 changed files with 530 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
common/data/xmlres/file.go
View File

@@ -52,6 +52,7 @@ var (
ShopMap map[int]ShopItem
SkillTypeMap map[int]SkillType
RelationsMap map[int]Relation
GoldProductMap = make(map[int]GoldProductItem, 0)
)
func initfile() {
@@ -72,15 +73,12 @@ func initfile() {
TalkConfig = getXml[TalkRoot](path + "talk.xml")
Monster := getXml[MonsterRoot](path + "地图配置野怪.xml")
MonsterMap = utils.ToMap(Monster.Maps, func(m TMapConfig) int {
MonsterMap = utils.ToMap(getXml[MonsterRoot](path+"地图配置野怪.xml").Maps, func(m TMapConfig) int {
return m.ID
})
Shop1 := getXml[ShopRoot](path + "地图配置野怪.xml")
ShopMap = utils.ToMap(Shop1.Items, func(m ShopItem) int {
ShopMap = utils.ToMap(getXml[ShopRoot](path+"地图配置野怪.xml").Items, func(m ShopItem) int {
return gconv.Int(m.ProductID)
})
@@ -92,19 +90,18 @@ func initfile() {
v.SideEffectArgS = ParseSideEffectArgs(v.SideEffectArg)
SkillMap[v.ID] = v
}
task := getXml[Tasks](path + "task.xml")
TaskMap = utils.ToMap[Task, int](task.Tasks, func(m Task) int {
TaskMap = utils.ToMap[Task, int](getXml[Tasks](path+"task.xml").Tasks, func(m Task) int {
return m.ID
})
pet := getXml[Monsters](path + "226.xml")
PetMAP = utils.ToMap[PetInfo, int](pet.Monsters, func(m PetInfo) int {
PetMAP = utils.ToMap[PetInfo, int](getXml[Monsters](path+"226.xml").Monsters, func(m PetInfo) int {
return m.ID
})
NatureRootMap1 := getXml[NatureRoot](path + "nature.xml")
NatureRootMap = utils.ToMap[NatureItem, int](NatureRootMap1.Items, func(m NatureItem) int {
NatureRootMap = utils.ToMap[NatureItem, int](getXml[NatureRoot](path+"nature.xml").Items, func(m NatureItem) int {
return m.ID
})
@@ -125,6 +122,13 @@ func initfile() {
}
GoldProductMap = utils.ToMap(getXml[GoldProductConfig](path+"30001.xml").Items,
func(m GoldProductItem) int {
return gconv.Int(m.ProductID)
},
)
}
func init() {

28
common/data/xmlres/glod.go Normal file
View File

@@ -0,0 +1,28 @@
package xmlres
import "github.com/ECUST-XX/xml"
// GoldProductConfig XML根节点结构体
type GoldProductConfig struct {
XMLName xml.Name `xml:"root"`
Items []GoldProductItem `xml:"item"` // 匹配所有<item>节点
}
// GoldProductItem 金豆商品配置项结构体
// 注：xml标签为`xml:"属性名,attr"` 表示解析XML属性而非子节点
type GoldProductItem struct {
ItemID string `xml:"itemID,attr"` // 物品ID（字符串先接收，后续转uint）
Name string `xml:"name,attr"` // 物品名称
ProductID string `xml:"productID,attr"` // 商品ID（可选字段）
Price string `xml:"price,attr"` // 金豆价格（可选字段，后续转float64）
Vip string `xml:"vip,attr"` // VIP折扣（可选字段，后续转float64，如0.6=6折）
MoneyType string `xml:"moneyType,attr"` // 货币类型（可选字段）
Gold string `xml:"gold,attr"` // 赠送金豆数（可选字段）
// // 解析后的强类型字段（便于业务使用）
// ItemIDUint uint32 `xml:"-"` // 解析后的物品ID
// ProductIDUint uint32 `xml:"-"` // 解析后的商品ID
// PriceFloat float64 `xml:"-"` // 解析后的金豆价格
// VipFloat float64 `xml:"-"` // 解析后的VIP折扣
// MoneyTypeUint uint16 `xml:"-"` // 解析后的货币类型
// GoldUint uint32 `xml:"-"` // 解析后的赠送金豆数
}

48
logic/controller/ev.go Normal file
View File

@@ -0,0 +1,48 @@
package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/pet"
"blazing/logic/service/player"
"github.com/samber/lo"
)
func (h Controller) PetEVdiy(data *pet.PetEV, c *player.Player) (result *pet.S2C_50001, err errorcode.ErrorCode) {
_, onpet, ok := c.FindPet(data.CacthTime)
if !ok {
return nil, errorcode.ErrorCodes.Err10401
}
//分配超过510的数据
if lo.Sum(data.EVs[:]) > 510 {
return nil, errorcode.ErrorCodes.Err10401
}
for i, v := range data.EVs {
//分配超过255的数据
if v > 255 {
return nil, errorcode.ErrorCodes.Err10401
}
//分配比之前点数少的
if v < onpet.Ev[i] {
return nil, errorcode.ErrorCodes.Err10401
}
}
if lo.Sum(data.EVs[:]) < lo.Sum(onpet.Ev[:]) {
return nil, errorcode.ErrorCodes.Err10401
}
USEEV1 := lo.Sum(data.EVs[:]) - lo.Sum(onpet.Ev[:])
//加的比池子还多
if USEEV1 > c.Info.EVPool {
return nil, errorcode.ErrorCodes.Err10401
}
onpet.Ev = data.EVs
onpet.CalculatePetPane()
c.Info.EVPool -= USEEV1
result = &pet.S2C_50001{}
result.UseEV = USEEV1
return result, 0
}

4
logic/controller/fight_boss.go
View File

@@ -74,7 +74,7 @@ func (h Controller) PlayerFightBoss(data *fight.ChallengeBossInboundInfo, c *pla
for _, bm := range bc.BossMon {
mo = c.GenPetInfo(
mo = model.GenPetInfo(
gconv.Int(processMonID(bm.MonID)), 24, //24个体
-1,
0, //野怪没特性
@@ -139,7 +139,7 @@ func (h Controller) OnPlayerFightNpcMonster(data *fight.FightNpcMonsterInboundIn
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
mo := c.GenPetInfo(
mo := model.GenPetInfo(
int(refpet.Id), -1,
-1,
0, //野怪没特性

23
logic/controller/gold_exp.go Normal file
View File

@@ -0,0 +1,23 @@
package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/item"
"blazing/logic/service/player"
)
func (h Controller) PlayerGoldCount(data *item.GoldOnlineRemainInboundInfo, c *player.Player) (result *item.GoldOnlineRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.GoldOnlineRemainOutboundInfo{
GoldNumber: uint32(c.Info.GoldBean) * 100,
Coin: c.Info.Coins,
}, 0
}
func (h Controller) PlayerExp(data *item.ExpTotalRemainInboundInfo, c *player.Player) (result *item.ExpTotalRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.ExpTotalRemainOutboundInfo{
TotalExp: uint32(c.Info.ExpPool),
}, 0
}

164
logic/controller/item.go
View File

@@ -1,164 +0,0 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/item"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
"github.com/gogf/gf/v2/util/grand"
)
func (h Controller) UserItemList(data *item.ItemListInboundInfo, c *player.Player) (result *item.ItemListOutboundInfo, err errorcode.ErrorCode) {
result = &item.ItemListOutboundInfo{}
result.ItemList = make([]model.SingleItemInfo, 0)
item := c.Service.Item.Get(data.Param1, data.Param2)
for _, v := range item {
var vv model.SingleItemInfo
vv.ItemId = v.ItemId
vv.ItemCnt = v.ItemCnt
vv.LeftTime = 360000
result.ItemList = append(result.ItemList, vv)
}
return result, 0
}
func (h Controller) PlayerGoldCount(data *item.GoldOnlineRemainInboundInfo, c *player.Player) (result *item.GoldOnlineRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.GoldOnlineRemainOutboundInfo{
GoldNumber: uint32(c.Info.GoldBean) * 100,
Coin: c.Info.Coins,
}, 0
}
func (h Controller) PlayerExp(data *item.ExpTotalRemainInboundInfo, c *player.Player) (result *item.ExpTotalRemainOutboundInfo, err errorcode.ErrorCode) {
return &item.ExpTotalRemainOutboundInfo{
TotalExp: uint32(c.Info.ExpPool),
}, 0
}
func (h Controller) BuyItem(data *item.BuyInboundInfo, c *player.Player) (result *item.BuyOutboundInfo, err errorcode.ErrorCode) {
tt, ok := xmlres.ItemsMAP[int(data.ItemId)]
if ok && tt.Price != 0 && c.UseCoins(data.Count*uint32(tt.Price)) {
r := c.ItemAdd(model.ItemInfo{ItemId: data.ItemId, ItemCnt: data.Count})
if len(r) != 0 {
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: c.Info.Coins,
}, 0
}
//购买失败,返还豆子
c.Info.Coins += data.Count * uint32(tt.Price)
}
return &item.BuyOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
func (h Controller) ChangePlayerCloth(data *item.ChangePlayerClothInboundInfo, c *player.Player) (result *item.ChangePlayerClothOutboundInfo, err errorcode.ErrorCode) {
result = &item.ChangePlayerClothOutboundInfo{
UserID: c.Info.UserID,
ClothList: make([]model.PeopleItemInfo, 0),
}
for _, v := range data.ClothList {
result.ClothList = append(result.ClothList, model.PeopleItemInfo{ID: v, Level: 1})
}
c.Info.Clothes = result.ClothList
c.GetSpace().Broadcast(c, data.Head.CMD, result)
return
}
func (h Controller) Talk(data *item.TalkCountInboundInfo, c *player.Player) (result *item.TalkCountOutboundInfo, err errorcode.ErrorCode) {
result = &item.TalkCountOutboundInfo{}
c.Service.Talk.Exec(func(t map[uint32]uint32) bool {
tt, ok := t[data.ID]
if ok {
result.GiftCount = tt
}
return false
})
return result, 0
}
var talkcacche = make(map[string]uint32)
func (h Controller) TalkCate(data *item.TalkCateInboundInfo, c *player.Player) (result *item.DayTalkInfo, err errorcode.ErrorCode) {
result = &item.DayTalkInfo{}
result.OutList = make([]item.CateInfo, 0)
for _, te := range xmlres.TalkConfig.Energies {
if te.MapID == uint64(c.Info.MapID) && te.Type == uint64(data.ID) { //
_, ok := talkcacche[te.Name]
if !ok {
for _, v := range xmlres.ItemsMAP {
if v.Name == te.Name {
talkcacche[te.Name] = uint32(v.ID)
}
}
}
randomNum := grand.Intn(10) + 1
c.Service.Talk.Exec(func(t map[uint32]uint32) bool {
if t == nil {
t = make(map[uint32]uint32)
}
_, ok := t[data.ID]
if !ok {
t[data.ID] = 0
}
t[data.ID] += 1
if t[data.ID] < uint32(te.CollectCnt) {
result.OutList = append(result.OutList, item.CateInfo{ID: uint32(talkcacche[te.Name]), Count: uint32(randomNum)})
c.ItemAdd(model.ItemInfo{ItemId: uint32(talkcacche[te.Name]), ItemCnt: uint32(randomNum)})
}
return true
})
break
}
}
return result, 0
}
func (h Controller) BuyMItem(data *item.BuyMultiInboundInfo, c *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) {
var rrr []model.ItemInfo
for _, v := range data.ItemIds {
_, ok := xmlres.ItemsMAP[int(v)]
if ok {
rrr = append(rrr, model.ItemInfo{ItemId: uint32(v), ItemCnt: 1})
}
}
r := c.ItemAdd(rrr...)
if len(r) != 0 {
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}

74
logic/controller/item_buy.go Normal file
View File

@@ -0,0 +1,74 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/item"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
"github.com/gogf/gf/v2/util/gconv"
)
func (h Controller) BuyItem(data *item.BuyInboundInfo, c *player.Player) (result *item.BuyOutboundInfo, err errorcode.ErrorCode) {
tt, ok := xmlres.ItemsMAP[int(data.ItemId)]
if ok && tt.Price != 0 && c.UseCoins(data.Count*uint32(tt.Price)) {
r := c.ItemAdd(model.ItemInfo{ItemId: data.ItemId, ItemCnt: data.Count})
if len(r) != 0 {
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: c.Info.Coins,
}, 0
}
//购买失败,返还豆子
c.Info.Coins += data.Count * uint32(tt.Price)
}
return &item.BuyOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
func (h Controller) BuyMItem(data *item.BuyMultiInboundInfo, c *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) {
var rrr []model.ItemInfo
for _, v := range data.ItemIds {
_, ok := xmlres.ItemsMAP[int(v)]
if ok {
rrr = append(rrr, model.ItemInfo{ItemId: uint32(v), ItemCnt: 1})
}
}
r := c.ItemAdd(rrr...)
if len(r) != 0 {
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
return &item.BuyMultiOutboundInfo{
Coins: c.Info.Coins,
}, 0
}
func (h Controller) BuyGoldItem(data *item.C2S_GOLD_BUY_PRODUCT, c *player.Player) (result *item.S2C_GoldBuyProductInfo, err errorcode.ErrorCode) {
r := xmlres.GoldProductMap[int(data.ProductID)]
if uint32(data.Count)*uint32(gconv.Uint32(r.Price)) > c.Info.GoldBean {
return nil, errorcode.ErrorCodes.ErrSystemError
}
c.ItemAdd(model.ItemInfo{ItemId: uint32(gconv.Uint32(r.ItemID)), ItemCnt: uint32(data.Count)})
c.Info.GoldBean -= gconv.Uint32(r.Price)
result = &item.S2C_GoldBuyProductInfo{
Gold: c.Info.GoldBean,
PayGold: uint32(data.Count) * uint32(gconv.Uint32(r.Price)),
Reserved: 0,
}
return
}

79
logic/controller/item_use.go Normal file
View File

@@ -0,0 +1,79 @@
package controller
import (
"blazing/common/socket/errorcode"
"blazing/logic/service/fight"
"blazing/logic/service/item"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
"github.com/gogf/gf/v2/util/grand"
"github.com/jinzhu/copier"
)
func (h Controller) UserItemList(data *item.ItemListInboundInfo, c *player.Player) (result *item.ItemListOutboundInfo, err errorcode.ErrorCode) {
result = &item.ItemListOutboundInfo{}
result.ItemList = make([]model.SingleItemInfo, 0)
item := c.Service.Item.Get(data.Param1, data.Param2)
for _, v := range item {
var vv model.SingleItemInfo
vv.ItemId = v.ItemId
vv.ItemCnt = v.ItemCnt
vv.LeftTime = 360000
result.ItemList = append(result.ItemList, vv)
}
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)
if !ok {
return nil, errorcode.ErrorCodes.Err10401
}
// 绑定变量到switch，显式匹配true
switch itemID := data.ItemID; true {
//这是学习力遗忘
case itemID >= 300037 && itemID <= 300041:
onpet.Ev[itemID-300037+1] = 0
// 体力遗忘
case itemID == 300042:
onpet.Ev[0] = 0
// 全能遗忘
case itemID == 300650:
onpet.Ev = [6]uint32{}
//性格随机
case itemID == 300025:
onpet.Nature = uint32(grand.Intn(25))
default:
// 无效ID处理
return nil, errorcode.ErrorCodes.ErrSystemError
}
if c.Service.Item.CheakItem(data.ItemID) == 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
}
c.Service.Item.SubItem(data.ItemID, 1)
result = &item.S2C_USE_PET_ITEM_OUT_OF_FIGHT{}
onpet.Update()
copier.Copy(&result, onpet)
return result, 0
}
func (h Controller) RESET_NATURE(data *item.C2S_PET_RESET_NATURE, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if c.Service.Item.CheakItem(data.ItemId) == 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
}
_, onpet, ok := c.FindPet(data.CatchTime)
if !ok {
return nil, errorcode.ErrorCodes.Err10401
}
onpet.Nature = data.Nature
c.Service.Item.SubItem(data.ItemId, 1)
return result, 0
}

3
logic/controller/nono.go
View File

@@ -55,6 +55,9 @@ func (h *Controller) PlayerPetCure(data *nono.PetCureInboundInfo, c *player.Play
if c.GetSpace().Owner.UserID == c.Info.UserID {
return result, errorcode.ErrorCodes.ErrChampionCannotHeal
}
if !c.UseCoins(50) {
return result, errorcode.ErrorCodes.ErrSystemBusy
}
for i := 0; i < len(c.Info.PetList); i++ {
c.Info.PetList[i].Cure()

64
logic/controller/pet.go
View File

@@ -3,7 +3,6 @@ package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/common/utils"
"blazing/logic/service/fight"
"blazing/logic/service/pet"
"blazing/logic/service/player"
@@ -11,7 +10,6 @@ import (
"blazing/modules/blazing/model"
"github.com/jinzhu/copier"
"github.com/samber/lo"
)
// 获取精灵信息
@@ -128,8 +126,13 @@ func (h *Controller) PetRelease(
switch data.Flag {
case 0:
index, _, ok := c.FindPet(data.CatchTime)
index, v, ok := c.FindPet(data.CatchTime)
if ok {
c.Service.Pet.PetInfo_One_exec(data.CatchTime, func(t *model.PetEX) {
t.Data = *v
//t.InBag = 0
})
c.Info.PetList = append(c.Info.PetList[:index], c.Info.PetList[index+1:]...)
}
@@ -182,6 +185,10 @@ func (h *Controller) PetOneCure(
if c.GetSpace().Owner.UserID == c.Info.UserID {
return result, errorcode.ErrorCodes.ErrChampionCannotHeal
}
if !c.UseCoins(20) {
return result, errorcode.ErrorCodes.ErrSystemBusy
}
_, onpet, ok := c.FindPet(data.CatchTime)
if ok {
onpet.Cure()
@@ -229,23 +236,6 @@ func (h Controller) SetPetExp(data *pet.PetSetExpInboundInfo, c *player.Player)
Exp: c.Info.ExpPool,
}, 0
}
func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (result *pet.ChangeSkillOutInfo, err errorcode.ErrorCode) {
_, onpet, ok := c.FindPet(data.CatchTime)
if ok {
_, HasSkill, ok := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { //已经存在技能
return item.ID == data.ReplaceSkill
})
if !ok {
HasSkill.ID = data.ReplaceSkill
HasSkill.PP = uint32(xmlres.SkillMap[int(HasSkill.ID)].MaxPP)
}
}
return &pet.ChangeSkillOutInfo{
CatchTime: data.CatchTime,
}, 0
}
func (h Controller) PetBargeList(data *pet.PetBargeListInboundInfo, c *player.Player) (result *pet.PetBargeListOutboundInfo, err errorcode.ErrorCode) {
@@ -253,37 +243,3 @@ func (h Controller) PetBargeList(data *pet.PetBargeListInboundInfo, c *player.Pl
PetBargeList: make([]pet.PetBargeListInfo, 0),
}, 0
}
func (h Controller) PetEVdiy(data *pet.PetEV, c *player.Player) (result *pet.S2C_50001, err errorcode.ErrorCode) {
_, onpet, ok := c.FindPet(data.CacthTime)
if !ok {
return nil, errorcode.ErrorCodes.Err10401
}
//分配超过510的数据
if lo.Sum(data.EVs[:]) > 510 {
return nil, errorcode.ErrorCodes.Err10401
}
for _, v := range data.EVs {
//分配超过255的数据
if v > 255 {
return nil, errorcode.ErrorCodes.Err10401
}
}
if lo.Sum(data.EVs[:]) < lo.Sum(onpet.Ev[:]) {
return nil, errorcode.ErrorCodes.Err10401
}
USEEV1 := lo.Sum(data.EVs[:]) - lo.Sum(onpet.Ev[:])
//加的比池子还多
if USEEV1 > c.Info.EVPool {
return nil, errorcode.ErrorCodes.Err10401
}
onpet.Ev = data.EVs
c.Info.EVPool -= USEEV1
result = &pet.S2C_50001{}
result.UseEV = USEEV1
return result, 0
}

54
logic/controller/pet_skill.go Normal file
View File

@@ -0,0 +1,54 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/common/utils"
"blazing/logic/service/fight"
"blazing/logic/service/pet"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
)
func (h Controller) SetPetSkill(data *pet.ChangeSkillInfo, c *player.Player) (result *pet.ChangeSkillOutInfo, err errorcode.ErrorCode) {
if !c.UseCoins(100) {
return result, errorcode.ErrorCodes.ErrSystemBusy
}
_, onpet, ok := c.FindPet(data.CatchTime)
if ok {
_, HasSkill, ok := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { //已经存在技能
return item.ID == data.ReplaceSkill
})
if !ok {
HasSkill.ID = data.ReplaceSkill
HasSkill.PP = uint32(xmlres.SkillMap[int(HasSkill.ID)].MaxPP)
}
}
return &pet.ChangeSkillOutInfo{
CatchTime: data.CatchTime,
}, 0
}
func (h Controller) Skill_Sort(data *pet.C2S_Skill_Sort, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if !c.UseCoins(100) {
return result, errorcode.ErrorCodes.ErrSystemBusy
}
_, onpet, ok := c.FindPet(data.CapTm)
if ok {
var newskill []model.SkillInfo
for _, v := range data.Skill {
_, HasSkill, ok := utils.FindWithIndex(onpet.SkillList, func(item model.SkillInfo) bool { //已经存在技能
return item.ID == v
})
if ok {
newskill = append(newskill, *HasSkill)
}
}
onpet.SkillList = newskill
}
return nil, 0
}

72
logic/controller/talk.go Normal file
View File

@@ -0,0 +1,72 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/item"
"blazing/logic/service/player"
"blazing/modules/blazing/model"
"github.com/gogf/gf/v2/util/grand"
)
func (h Controller) Talk(data *item.TalkCountInboundInfo, c *player.Player) (result *item.TalkCountOutboundInfo, err errorcode.ErrorCode) {
result = &item.TalkCountOutboundInfo{}
c.Service.Talk.Exec(func(t map[uint32]uint32) bool {
tt, ok := t[data.ID]
if ok {
result.GiftCount = tt
}
return false
})
return result, 0
}
var talkcacche = make(map[string]uint32)
func (h Controller) TalkCate(data *item.TalkCateInboundInfo, c *player.Player) (result *item.DayTalkInfo, err errorcode.ErrorCode) {
result = &item.DayTalkInfo{}
result.OutList = make([]item.CateInfo, 0)
for _, te := range xmlres.TalkConfig.Energies {
if te.MapID == uint64(c.Info.MapID) && te.Type == uint64(data.ID) { //
_, ok := talkcacche[te.Name]
if !ok {
for _, v := range xmlres.ItemsMAP {
if v.Name == te.Name {
talkcacche[te.Name] = uint32(v.ID)
}
}
}
randomNum := grand.Intn(10) + 1
c.Service.Talk.Exec(func(t map[uint32]uint32) bool {
if t == nil {
t = make(map[uint32]uint32)
}
_, ok := t[data.ID]
if !ok {
t[data.ID] = 0
}
t[data.ID] += 1
if t[data.ID] < uint32(te.CollectCnt) {
result.OutList = append(result.OutList, item.CateInfo{ID: uint32(talkcacche[te.Name]), Count: uint32(randomNum)})
c.ItemAdd(model.ItemInfo{ItemId: uint32(talkcacche[te.Name]), ItemCnt: uint32(randomNum)})
}
return true
})
break
}
}
return result, 0
}

2
logic/controller/task.go
View File

@@ -76,7 +76,7 @@ func (h Controller) Complete_Task(data *task.CompleteTaskInboundInfo, c *player.
result.ItemList = tt.ItemList
if tt.PetTypeId != 0 {
r := c.GenPetInfo(int(tt.PetTypeId), 31, -1, 0, 0, 50)
r := model.GenPetInfo(int(tt.PetTypeId), 31, -1, 0, 0, 50)
result.CaptureTime = r.CatchTime
result.PetTypeId = r.ID
c.Service.Pet.PetAdd(*r)

18
logic/controller/user.go
View File

@@ -3,8 +3,10 @@ package controller
import (
"blazing/common/socket/errorcode"
"blazing/cool"
"blazing/logic/service/item"
"blazing/logic/service/player"
"blazing/logic/service/user"
"blazing/modules/blazing/model"
"github.com/jinzhu/copier"
)
@@ -119,3 +121,19 @@ func (h Controller) PEOPLE_TRANSFROM(data *user.C2SPEOPLE_TRANSFROM, c *player.P
c.GetSpace().Broadcast(c, data.Head.CMD, result)
return
}
func (h Controller) ChangePlayerCloth(data *item.ChangePlayerClothInboundInfo, c *player.Player) (result *item.ChangePlayerClothOutboundInfo, err errorcode.ErrorCode) {
result = &item.ChangePlayerClothOutboundInfo{
UserID: c.Info.UserID,
ClothList: make([]model.PeopleItemInfo, 0),
}
for _, v := range data.ClothList {
result.ClothList = append(result.ClothList, model.PeopleItemInfo{ID: v, Level: 1})
}
c.Info.Clothes = result.ClothList
c.GetSpace().Broadcast(c, data.Head.CMD, result)
return
}

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

@@ -130,6 +130,7 @@ func (f *FightC) initplayer(c common.PlayerI) (*input.Input, errorcode.ErrorCode
p := model.GenPetInfo(v, 24, -1, -1, -1, 100)
//p.CatchTime = uint32(v)
p.Update()
p.Update_EXP()
p = model.GenPetInfo(int(p.ID), 24, -1, -1, -1, 100)
//p.CalculatePetPane()

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

@@ -263,12 +263,13 @@ func (our *Input) GetAction(opp *Input) {
}
randomIdx := grand.Intn(len(allSkills))
for i, v := range skills {
for i := 0; i < len(allSkills); i++ {
if randomIdx == int(i) {
our.FightC.UseSkill(our.Player, uint32(v.ID))
our.FightC.UseSkill(our.Player, uint32(allSkills[i].ID))
}
}
}
our.FightC.UseSkill(our.Player, 0)
}

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

@@ -229,6 +229,11 @@ func (f *FightC) handleItemAction(a *action.UseItemAction) {
if !ok {
return
}
r := f.GetInputByAction(a, false).Player.(*player.Player).Service.Item.CheakItem(a.ItemID)
if r < 1 {
return
}
f.GetInputByAction(a, false).Player.(*player.Player).Service.Item.SubItem(a.ItemID, 1)
switch {
case gconv.Int(item.Bonus) != 0:

14
logic/service/item/buy.go
View File

@@ -28,3 +28,17 @@ type BuyMultiOutboundInfo struct {
//剩余的数量
Coins uint32
}
// C2S_GOLD_BUY_PRODUCT 客户端→服务端：金豆购买商品请求
type C2S_GOLD_BUY_PRODUCT struct {
Head common.TomeeHeader `cmd:"1104" struc:"skip"`
ProductID uint32 `json:"product_id"` // 金豆物品id对应的产品id
Count uint16 `json:"count"` // 购买数量（前端限制金豆物品只能1个1个买）
}
// S2C_GoldBuyProductInfo 服务端→客户端：金豆购买商品结果返回
type S2C_GoldBuyProductInfo struct {
Reserved uint32 `json:"reserved"` // 0 空数据（预留字段）
PayGold uint32 `json:"pay_gold"` // 购买物品消耗的金豆数（后端返回值需*100）
Gold uint32 `json:"gold"` // 购买后剩余金豆数（后端返回值需*100）
}

38
logic/service/item/pet.go Normal file
View File

@@ -0,0 +1,38 @@
package item
import (
"blazing/logic/service/common"
"blazing/modules/blazing/model"
)
// C2S_USE_PET_ITEM_OUT_OF_FIGHT 客户端→服务端：非战斗场景使用宠物道具
type C2S_USE_PET_ITEM_OUT_OF_FIGHT struct {
Head common.TomeeHeader `cmd:"2326" struc:"skip"`
CatchTime uint32 `json:"catch_time"` // 使用物品的精灵的捕获时间
ItemID uint32 `json:"item_id"` // 使用的物品ID
}
// S2C_USE_PET_ITEM_OUT_OF_FIGHT 服务端→客户端：非战斗场景使用宠物道具回包
type S2C_USE_PET_ITEM_OUT_OF_FIGHT struct {
CatchTime uint32 `json:"catch_time"` // 使用物品的精灵的捕获时间
ID uint32 `json:"id"` // 精灵ID
Nick string `struc:"[16]byte" fieldDesc:"16字节昵称" json:"nick"`
Nature uint32 `json:"nature"` // 精灵性格
Dv uint32 `json:"dv"` // 精灵个体值
Level uint32 `json:"lv"` // 精灵等级
Hp uint32 `json:"hp"` // 当前血量
MaxHp uint32 `json:"maxhp"` // 最大血量
Exp uint32 `json:"exp"` // 升级所需经验
// * ev:生命学习力,攻击学习力,防御学习力,特攻学习力,特防学习力,速度学习力
Ev [6]uint32 `fieldDesc:"属性" `
// * battle_lv: atk(0), def(1), sp_atk(2), sp_def(3), spd(4), accuracy(5)
Prop [5]uint32 `fieldDesc:"属性" `
SkillList []model.SkillInfo `json:"skilllist"` // 技能数组
}
type C2S_PET_RESET_NATURE struct {
Head common.TomeeHeader `cmd:"2343" struc:"skip"`
CatchTime uint32 // 精灵捕捉时间
Nature uint32 // 目标性格值
ItemId uint32 // 消耗的物品ID
}

6
logic/service/pet/skill.go
View File

@@ -17,3 +17,9 @@ type ChangeSkillOutInfo struct {
CatchTime uint32 `json:"catchTime"` // 精灵生成时间
}
type C2S_Skill_Sort struct {
Head common.TomeeHeader `cmd:"2328" struc:"skip"`
CapTm uint32 `json:"capTm"` // 精灵的捕捉时间（对应C# uint capTm）
Skill [4]uint32 `json:"skill_1"` // 技能1（对应C# uint skill_1）
}

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

@@ -18,11 +18,11 @@ func (p *Player) AddPetExp(petinfo *model.PetInfo, addExp uint32) {
addExp = utils.Min(addExp, p.Info.ExpPool)
originalLevel := petinfo.Level
Exp := petinfo.Exp + addExp
petinfo.Update()
petinfo.Update_EXP()
p.Info.ExpPool -= addExp //减去已使用的经验
for Exp >= petinfo.NextLvExp {
petinfo.Level++
petinfo.Update()
petinfo.Update_EXP()
Exp -= petinfo.LvExp
if originalLevel < 100 && petinfo.Level == 100 { //升到100了
p.Info.ExpPool += Exp //减去已使用的经验
@@ -85,20 +85,3 @@ func (p *Player) AddPetExp(petinfo *model.PetInfo, addExp uint32) {
// return exp
}
// GenPetInfo 生成一个新的精灵实例
// - 参数为 -1 时表示随机生成对应属性
// * @param petTypeId 精灵类型ID
// * @param individualValue 个体值（0-31）
// * @param natureId 性格ID（0-24）
// * @param abilityTypeEnum 特性类型ID（0=无, >0=指定, -1=随机）
// * @param shinyid 闪光ID（-1=随机）
// * @param level 等级（1-100）
// * @return 生成的精灵实体
func (player *Player) GenPetInfo(
id int,
dv, natureId, abilityTypeEnum, shinyid, level int,
) *model.PetInfo {
return model.GenPetInfo(id, dv, natureId, abilityTypeEnum, shinyid, level)
}

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

@@ -215,9 +215,7 @@ func (pet *PetInfo) Downgrade(level uint32) {
}
// 传入bool则不升级
// Update 改造为循环进化：直到宠物无法再进化为止，再更新经验
// t ...bool：原参数逻辑，len(t)==0时触发进化检查，否则仅更新经验
// 执行进化逻辑
func (petinfo *PetInfo) Update() {
// 最大进化次数限制（防止配置表闭环导致死循环）
@@ -253,6 +251,14 @@ func (petinfo *PetInfo) Update() {
evolveCount++ // 进化次数+1
}
}
// 传入bool则不升级
// Update 改造为循环进化：直到宠物无法再进化为止，再更新经验
// t ...bool：原参数逻辑，len(t)==0时触发进化检查，否则仅更新经验
func (petinfo *PetInfo) Update_EXP() {
// 进化完成后，统一更新经验（原逻辑保留）
petinfo.LvExp = petinfo.NextLvExp
// 获取最终形态的宠物配置，计算下一等级经验
@@ -324,8 +330,19 @@ func NewPet() *Pet {
// init 创建表
func init() {
_ = cool.CreateTable(&Pet{})
// fmt.Println(err)
}
// GenPetInfo 生成一个新的精灵实例
// - 参数为 -1 时表示随机生成对应属性
// * @param petTypeId 精灵类型ID
// * @param individualValue 个体值（0-31）
// * @param natureId 性格ID（0-24）
// * @param abilityTypeEnum 特性类型ID（0=无, >0=指定, -1=随机）
// * @param shinyid 闪光ID（-1=随机）
// * @param level 等级（1-100）
// * @return 生成的精灵实体
func GenPetInfo(
id int,
dv, natureId, abilityTypeEnum, shinyid, level int,
@@ -416,7 +433,7 @@ func GenPetInfo(
// ---- 属性计算 ----
p.CalculatePetPane()
p.Update()
p.Update_EXP()
return p
}

11
public/config/地图配置野怪.xml
View File

@@ -7826,6 +7826,17 @@ eg:
</Map>
<Map ID="737" Name="深海禁地" InitX="300" InitY="100">
<Monsters>
<Monster ID="2186" Lv="13 16"/>
<Monster ID="2186" Lv="13 16"/>
<Monster ID="2186" Lv="13 16"/>
<Monster ID="2186" Lv="20 23"/>
<Monster ID="108" Lv="20 20"/>
<Monster ID="2186" Lv="20 20"/>
<Monster ID="2186" Lv="20 20"/>
<Monster ID="2186" Lv="20 20"/>
<Monster ID="2186" Lv="20 20"/>
</Monsters>
<Bosses>
<Boss AppearTime="13 13" AppearStartMin="0" AppearEndMin="7" BossVisible="0" Name="巨齿鲨">
<BossMon MonID="1230" Hp="6000" Lv="100"/>