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

refactor: 优化代码结构和逻辑

Browse Source
This commit is contained in:
xinian
2026-03-31 08:19:53 +08:00
committed by cnb
parent b4a8048b85
commit d6d03a576d
21 changed files with 1166 additions and 1080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
logic/controller/buy_seerdou_item.go Normal file
View File

@@ -0,0 +1,30 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/player"
)
func buySeerdouBackpackItem(player *player.Player, itemID int64, count int64) (bought bool, err errorcode.ErrorCode) {
if itemID <= 0 || count <= 0 {
return false, errorcode.ErrorCodes.ErrSystemError
}
itemInfo, exists := xmlres.ItemsMAP[int(itemID)]
if !exists {
return false, 0
}
totalCost := int64(itemInfo.Price) * count
if totalCost > 0 && !player.GetCoins(totalCost) {
return false, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
if !player.ItemAdd(itemID, count) {
return false, 0
}
player.Info.Coins -= totalCost
return true, 0
}

415
logic/controller/fight_boss野怪和地图怪.go
View File

@@ -7,9 +7,8 @@ import (
"strings"
"blazing/logic/service/fight"
"blazing/logic/service/fight/info"
fightinfo "blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/player"
configmodel "blazing/modules/config/model"
"blazing/modules/config/service"
@@ -20,217 +19,259 @@ import (
)
// PlayerFightBoss 挑战地图boss
// data: 包含挑战Boss信息的输入数据
// player: 当前玩家对象
// 返回: 战斗结果和错误码
func (Controller) PlayerFightBoss(data1 *fight.ChallengeBossInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
r := p.CanFight()
if p.CanFight() != 0 {
return nil, r
}
var monster *model.PetInfo
monsterInfo := &model.PlayerInfo{}
mdata := service.NewMapNodeService().GetDataNode(p.Info.MapID, data1.BossId)
if mdata == nil {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
var bosinfo []configmodel.BossConfig
switch len(mdata.BossIds) {
case 0:
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
case 1:
bosinfo = service.NewBossService().Get(mdata.BossIds[0])
default:
bosinfo = service.NewBossService().Get(mdata.BossIds[grand.Intn(len(mdata.BossIds))])
func (Controller) PlayerFightBoss(req *fight.ChallengeBossInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if err = p.CanFight(); err != 0 {
return nil, err
}
if len(bosinfo) == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
mapNode := service.NewMapNodeService().GetDataNode(p.Info.MapID, req.BossId)
bossConfigs, err := loadMapBossConfigs(mapNode)
if err != 0 {
return nil, err
}
dv := 24
ger := 0
if bosinfo[0].IsCapture == 1 {
dv = -1
ger = -1
monsterInfo, leadMonsterID, err := buildBossMonsterInfo(mapNode.NodeName, bossConfigs)
if err != 0 {
return nil, err
}
for i, bm := range bosinfo {
monster = model.GenPetInfo(
gconv.Int(bm.MonID), dv, //24个体
-1,
0, //野怪没特性
int(bm.Lv), nil, ger)
monster.CatchTime = uint32(i)
monster.ConfigBoss(bm.PetBaseConfig)
effects := service.NewEffectService().Args(bm.Effect)
for _, v := range effects {
monster.EffectInfo = append(monster.EffectInfo, model.PetEffectInfo{
Idx: uint16(v.SeIdx),
EID: gconv.Uint16(v.Eid),
Args: gconv.Ints(v.Args),
})
}
monsterInfo.PetList = append(monsterInfo.PetList, *monster)
}
if bosinfo[0].IsCapture == 1 {
monsterInfo.PetList[0].ShinyInfo = make([]data.GlowFilter, 0)
if grand.Meet(1, 500) {
monsterInfo.PetList[0].RandomByWeightShiny()
}
}
monsterInfo.Nick = mdata.NodeName //xmlres.PetMAP[int(monster.ID)].DefName
if len(monsterInfo.PetList) == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
p.Fightinfo.Status = info.BattleMode.FIGHT_WITH_NPC
p.Fightinfo.Mode = info.BattleMode.MULTI_MODE
p.Fightinfo.Status = fightinfo.BattleMode.FIGHT_WITH_NPC
p.Fightinfo.Mode = fightinfo.BattleMode.MULTI_MODE
ai := player.NewAI_player(monsterInfo)
ai.CanCapture = bosinfo[0].IsCapture
if bosinfo[0].IsCapture != 0 {
ai.CanCapture = xmlres.PetMAP[int(monster.ID)].CatchRate
if xmlres.PetMAP[int(monster.ID)].CatchRate == 0 {
ai.CanCapture = 0
}
}
ai.CanCapture = resolveBossCaptureRate(bossConfigs[0].IsCapture, leadMonsterID)
ai.Prop[0] = 2
var fighc *fight.FightC
fighc, _ = fight.NewFight(p, ai, p.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
if mdata.WinBonusID != 0 {
if len(bosinfo[0].Rule) == 0 {
if foi.Reason == 0 && foi.WinnerId == p.Info.UserID {
p.SptCompletedTask(mdata.WinBonusID, 1)
}
} else {
//说明是带规则的
iswin := true
for _, v := range service.NewFightRuleService().GetByRuleIdxs(bosinfo[0].Rule) {
r := input.GetRule(int64(v.RuleIdx))
if r != nil {
r.SetArgs(v.Args...)
if !(r.Exec(fighc, &foi)) {
iswin = false
break
}
}
}
if iswin {
p.SptCompletedTask(mdata.WinBonusID, 1)
}
}
var fightC *fight.FightC
fightC, err = fight.NewFight(p, ai, p.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
if mapNode.WinBonusID == 0 {
return
}
if shouldGrantBossWinBonus(fightC, p.Info.UserID, bossConfigs[0], foi) {
p.SptCompletedTask(mapNode.WinBonusID, 1)
}
//p.Done.Exec(model.MilestoneMode.BOSS, []uint32{p.Info.MapID, data.BossId, uint32(foi.Reason)}, nil)
})
if err != 0 {
return nil, err
}
return nil, -1
}
// OnPlayerFightNpcMonster 战斗野怪
// data: 包含战斗野怪信息的输入数据
// player: 当前玩家对象
// 返回: 战斗结果和错误码
func (Controller) OnPlayerFightNpcMonster(data1 *fight.FightNpcMonsterInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
r := p.CanFight()
if p.CanFight() != 0 {
return nil, r
func (Controller) OnPlayerFightNpcMonster(req *fight.FightNpcMonsterInboundInfo, p *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
if err = p.CanFight(); err != 0 {
return nil, err
}
if data1.Number > 9 {
if req.Number > 9 {
return nil, errorcode.ErrorCodes.ErrSystemError
}
refPet := p.Data[data1.Number]
if refPet.ID == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
refPet := p.Data[req.Number]
monster, monsterInfo, err := buildNpcMonsterInfo(refPet, p.Info.MapID)
if err != 0 {
return nil, err
}
monster := model.GenPetInfo(
int(refPet.GetID()), -1,
-1,
0, //野怪没特性
int(refPet.GetLevel()),
refPet.ShinyInfo, -1)
monster.CatchMap = p.Info.MapID //设置当前地图
if refPet.Ext != 0 {
if grand.Meet(1, 500) {
monster.RandomByWeightShiny()
}
}
monsterInfo := &model.PlayerInfo{}
monsterInfo.Nick = xmlres.PetMAP[int(monster.ID)].DefName
monsterInfo.PetList = append(monsterInfo.PetList, *monster)
ai := player.NewAI_player(monsterInfo)
ai.CanCapture = refPet.IsCapture
ai.CanCapture = refPet.IsCapture //handleNPCFightSpecial(monster.ID)
p.Fightinfo.Status = info.BattleMode.FIGHT_WITH_NPC //打野怪
p.Fightinfo.Mode = info.BattleMode.MULTI_MODE //多人模式
fight.NewFight(p, ai, p.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
//p.Done.Exec(model.MilestoneMode.Moster, []uint32{p.Info.MapID, monsterInfo.PetList[0].ID, uint32(foi.Reason)}, nil)
if foi.Reason == 0 && foi.WinnerId == p.Info.UserID && p.CanGet() {
exp := uint32(xmlres.PetMAP[int(monster.ID)].YieldingExp) * monster.Level / 7
addlevel, poolevel := p.CanGetExp()
addexp := gconv.Float32(addlevel * gconv.Float32(exp))
poolexp := gconv.Float32(poolevel) * gconv.Float32((exp))
items := &info.S2C_GET_BOSS_MONSTER{}
p.ItemAdd(3, int64(poolexp+addexp))
items.ADDitem(3, uint32(poolexp))
p.AddPetExp(foi.Winpet, int64(addexp))
pettype := int64(xmlres.PetMAP[int(refPet.GetID())].Type)
if p.CanGetItem() {
item := p.GetSpace().GetDrop()
if item != 0 {
count := int64(grand.N(1, 2))
ok := p.ItemAdd(item, count)
if ok {
items.ADDitem(uint32(item), uint32(count))
}
}
}
if monster.IsShiny() && p.CanGetXUAN() && pettype < 16 {
xuan := 400686 + pettype
count := uint32(grand.N(1, 2))
ok := p.ItemAdd(xuan, int64(count))
if ok {
items.ADDitem(uint32(xuan), count)
}
}
p.SendPackCmd(8004, items)
evs := gconv.Int64s(strings.Split(xmlres.PetMAP[int(monster.ID)].YieldingEV, " "))
foi.Winpet.AddEV(evs)
//取消累计学习力掉落
// if leve == 8 {
// items.EV = lo.Sum(evs) - 1
// p.Info.EVPool += lo.Sum(evs) //给予累计学习力
// }
}
p.Fightinfo.Status = fightinfo.BattleMode.FIGHT_WITH_NPC
p.Fightinfo.Mode = fightinfo.BattleMode.MULTI_MODE
_, err = fight.NewFight(p, ai, p.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
handleNpcFightRewards(p, foi, monster)
})
if err != 0 {
return nil, err
}
return nil, -1
}
func loadMapBossConfigs(mapNode *configmodel.MapNode) ([]configmodel.BossConfig, errorcode.ErrorCode) {
if mapNode == nil || len(mapNode.BossIds) == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
bossID := mapNode.BossIds[0]
if len(mapNode.BossIds) > 1 {
bossID = mapNode.BossIds[grand.Intn(len(mapNode.BossIds))]
}
bossConfigs := service.NewBossService().Get(bossID)
if len(bossConfigs) == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
return bossConfigs, 0
}
func buildBossMonsterInfo(nodeName string, bossConfigs []configmodel.BossConfig) (*model.PlayerInfo, uint32, errorcode.ErrorCode) {
monsterInfo := &model.PlayerInfo{Nick: nodeName}
var leadMonsterID uint32
for i, bossConfig := range bossConfigs {
dv, generation := bossFightPetArgs(bossConfig.IsCapture)
monster := model.GenPetInfo(
gconv.Int(bossConfig.MonID),
dv,
-1,
0,
int(bossConfig.Lv),
nil,
generation,
)
if monster == nil {
return nil, 0, errorcode.ErrorCodes.ErrPokemonNotExists
}
monster.CatchTime = uint32(i)
monster.ConfigBoss(bossConfig.PetBaseConfig)
appendPetEffects(monster, bossConfig.Effect)
if i == 0 {
leadMonsterID = monster.ID
}
monsterInfo.PetList = append(monsterInfo.PetList, *monster)
}
if len(monsterInfo.PetList) == 0 {
return nil, 0, errorcode.ErrorCodes.ErrPokemonNotExists
}
if bossConfigs[0].IsCapture == 1 {
monsterInfo.PetList[0].ShinyInfo = make([]data.GlowFilter, 0)
if grand.Meet(1, 500) {
monsterInfo.PetList[0].RandomByWeightShiny()
}
}
return monsterInfo, leadMonsterID, 0
}
func bossFightPetArgs(canCapture int) (dv int, generation int) {
if canCapture == 1 {
return -1, -1
}
return 24, 0
}
func appendPetEffects(monster *model.PetInfo, effectIDs []uint32) {
effects := service.NewEffectService().Args(effectIDs)
for _, effect := range effects {
monster.EffectInfo = append(monster.EffectInfo, model.PetEffectInfo{
Idx: uint16(effect.SeIdx),
EID: gconv.Uint16(effect.Eid),
Args: gconv.Ints(effect.Args),
})
}
}
func resolveBossCaptureRate(canCapture int, petID uint32) int {
if canCapture == 0 {
return 0
}
petCfg, ok := xmlres.PetMAP[int(petID)]
if !ok || petCfg.CatchRate == 0 {
return 0
}
return petCfg.CatchRate
}
func shouldGrantBossWinBonus(fightC *fight.FightC, playerID uint32, bossConfig configmodel.BossConfig, foi model.FightOverInfo) bool {
if len(bossConfig.Rule) == 0 {
return foi.Reason == 0 && foi.WinnerId == playerID
}
for _, ruleConfig := range service.NewFightRuleService().GetByRuleIdxs(bossConfig.Rule) {
rule := input.GetRule(int64(ruleConfig.RuleIdx))
if rule == nil {
continue
}
rule.SetArgs(ruleConfig.Args...)
if !rule.Exec(fightC, &foi) {
return false
}
}
return true
}
func buildNpcMonsterInfo(refPet player.OgrePetInfo, mapID uint32) (*model.PetInfo, *model.PlayerInfo, errorcode.ErrorCode) {
if refPet.ID == 0 {
return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
monster := model.GenPetInfo(
refPet.GetID(),
-1,
-1,
0,
refPet.GetLevel(),
refPet.ShinyInfo,
-1,
)
if monster == nil {
return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
monster.CatchMap = mapID
if refPet.Ext != 0 && grand.Meet(1, 500) {
monster.RandomByWeightShiny()
}
petCfg, ok := xmlres.PetMAP[int(monster.ID)]
if !ok {
return nil, nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
monsterInfo := &model.PlayerInfo{
Nick: petCfg.DefName,
PetList: []model.PetInfo{*monster},
}
return monster, monsterInfo, 0
}
func handleNpcFightRewards(p *player.Player, foi model.FightOverInfo, monster *model.PetInfo) {
if foi.Reason != 0 || foi.WinnerId != p.Info.UserID || !p.CanGet() {
return
}
petCfg, ok := xmlres.PetMAP[int(monster.ID)]
if !ok {
return
}
exp := uint32(petCfg.YieldingExp) * monster.Level / 7
addlevel, poolevel := p.CanGetExp()
addexp := gconv.Float32(addlevel * gconv.Float32(exp))
poolexp := gconv.Float32(poolevel) * gconv.Float32(exp)
rewards := &fightinfo.S2C_GET_BOSS_MONSTER{}
p.ItemAdd(3, int64(poolexp+addexp))
rewards.ADDitem(3, uint32(poolexp))
p.AddPetExp(foi.Winpet, int64(addexp))
if p.CanGetItem() {
itemID := p.GetSpace().GetDrop()
if itemID != 0 {
count := uint32(grand.N(1, 2))
if p.ItemAdd(itemID, int64(count)) {
rewards.ADDitem(uint32(itemID), count)
}
}
}
petType := int64(petCfg.Type)
if monster.IsShiny() && p.CanGetXUAN() && petType < 16 {
xuanID := uint32(400686 + petType)
count := uint32(grand.N(1, 2))
if p.ItemAdd(int64(xuanID), int64(count)) {
rewards.ADDitem(xuanID, count)
}
}
p.SendPackCmd(8004, rewards)
foi.Winpet.AddEV(gconv.Int64s(strings.Fields(petCfg.YieldingEV)))
}

338
logic/controller/fight_塔.go
View File

@@ -17,201 +17,239 @@ import (
"github.com/jinzhu/copier"
)
const (
towerCmdChoiceTrial uint32 = 2428
towerCmdChoiceBrave uint32 = 2414
towerCmdFightTrial uint32 = 2429
towerCmdFightBrave uint32 = 2415
towerCmdFightDark uint32 = 2425
towerTaskDark int = 110
towerTaskBrave int = 500
towerTaskTrial int = 600
)
type towerChoiceState struct {
currentLevel *uint32
maxLevel *uint32
service *service.TowerService
}
// 暗黑门进入boss
func (h Controller) FreshOpen(data *fight.C2S_OPEN_DARKPORTAL, c *player.Player) (result *fight.S2C_OPEN_DARKPORTAL, err errorcode.ErrorCode) {
result = &fight.S2C_OPEN_DARKPORTAL{}
// c.Info.CurrentFreshStage = utils.Max(c.Info.CurrentFreshStage, 1)
// c.Info.CurrentStage = utils.Max(c.Info.CurrentStage, 1)
boss := service.NewTower110Service().Boss(uint32(data.Level))
if len(boss) == 0 {
towerBosses := service.NewTower110Service().Boss(uint32(data.Level))
bossConfig, ok := firstTowerBossConfig(towerBosses)
if !ok {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
if len(boss[0].BossIds) == 0 {
bosses := service.NewBossService().Get(bossConfig.BossIds[0])
if len(bosses) == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
result = &fight.S2C_OPEN_DARKPORTAL{}
r := service.NewBossService().Get(boss[0].BossIds[0])
result.CurBossID = uint32(r[0].MonID)
result.CurBossID = uint32(bosses[0].MonID)
c.CurDark = uint32(data.Level)
defer c.GetSpace().LeaveMap(c)
return result, 0
}
// 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{}
c.Info.CurrentFreshStage = utils.Max(c.Info.CurrentFreshStage, 1)
c.Info.CurrentStage = utils.Max(c.Info.CurrentStage, 1)
choiceState, ok := towerChoiceRuntime(c, data.Head.CMD)
if !ok {
return nil, errorcode.ErrorCodes.ErrSystemError
}
if data.Level > 0 {
switch data.Head.CMD {
case 2428: //试炼之塔
if data.Level > uint(c.Info.MaxFreshStage) && data.Level != 1 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
c.Info.CurrentFreshStage = uint32(data.Level)
case 2414: //勇者之塔
if data.Level > uint(c.Info.MaxStage) && data.Level != 1 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
c.Info.CurrentStage = uint32(data.Level)
if !canSelectTowerLevel(data.Level, *choiceState.maxLevel) {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
*choiceState.currentLevel = uint32(data.Level)
}
var boss []configmodel.BaseTowerConfig
switch data.Head.CMD {
case 2428: //试炼之塔
result.CurFightLevel = uint32(c.Info.CurrentFreshStage)
boss = service.NewTower600Service().Boss(c.Info.CurrentFreshStage)
result.CurFightLevel = *choiceState.currentLevel
appendTowerBossPreview(&result.BossId, choiceState.service.Boss(*choiceState.currentLevel))
case 2414: //勇者之塔
result.CurFightLevel = uint32(c.Info.CurrentStage)
boss = service.NewTower500Service().Boss(c.Info.CurrentStage)
//next := service.NewTower600Service().Boss(c.Info.CurrentFreshStage + 1)
}
if len(boss) != 0 && len(boss[0].BossIds) != 0 {
//单节点,取获取到的一个,然后因为不是剧情,所以只有一层
r := service.NewBossService().Get(boss[0].BossIds[0])
for _, v := range r {
result.BossId = append(result.BossId, uint32(v.MonID))
}
}
// 重置玩家的Canmon标志位为0，表示可以刷怪
atomic.StoreUint32(&c.Canmon, 0)
// 在函数结束时将玩家传送到对应地图
defer c.GetSpace().LeaveMap(c)
return result, 0
}
func (h Controller) FreshLeaveFightLevel(data *fight.FRESH_LEAVE_FIGHT_LEVEL, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
func (h Controller) FreshLeaveFightLevel(data *fight.FRESH_LEAVE_FIGHT_LEVEL, c *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) {
_ = data
defer c.GetSpace().EnterMap(c)
out := info.NewOutInfo()
copier.CopyWithOption(out, c.GetInfo(), copier.Option{DeepCopy: true})
//c.SendPackCmd(2001, out)
return result, 0
}
func (h Controller) PetTawor(data *fight.StartTwarInboundInfo, c *player.Player) (result *fight.S2C_ChoiceLevelRequestInfo, err errorcode.ErrorCode) {
r := c.CanFight()
if c.CanFight() != 0 {
return nil, r
if err = c.CanFight(); err != 0 {
return nil, err
}
bossList, currentLevel, taskID, ok := towerFightBosses(c, data.Head.CMD)
if !ok {
return nil, errorcode.ErrorCodes.ErrSystemError
}
currentBoss, ok := firstTowerBossConfig(bossList)
if !ok {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
result = &fight.S2C_ChoiceLevelRequestInfo{CurFightLevel: currentLevel}
appendTowerNextBossPreview(&result.BossID, bossList)
monsterInfo, ok := buildTowerMonsterInfo(currentBoss)
if !ok {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
c.Fightinfo.Mode = fightinfo.BattleMode.MULTI_MODE
c.Fightinfo.Status = fightinfo.BattleMode.FIGHT_WITH_NPC
monsterInfo := &model.PlayerInfo{}
var boss []configmodel.BaseTowerConfig
result = &fight.S2C_ChoiceLevelRequestInfo{}
switch data.Head.CMD {
case 2429: //试炼之塔
boss = service.NewTower600Service().Boss(c.Info.CurrentFreshStage, c.Info.CurrentFreshStage+1)
result.CurFightLevel = uint32(c.Info.CurrentFreshStage)
case 2415: //勇者之塔
boss = service.NewTower500Service().Boss(c.Info.CurrentStage, c.Info.CurrentStage+1)
result.CurFightLevel = uint32(c.Info.CurrentStage)
case 2425:
boss = service.NewTower110Service().Boss(c.CurDark)
}
if len(boss) > 1 {
r := service.NewBossService().Get(boss[1].BossIds[0])
for _, v := range r {
result.BossID = append(result.BossID, uint32(v.MonID))
}
}
bosss := service.NewBossService().Get(boss[0].BossIds[0])
monsterInfo.Nick = boss[0].Name
for i, r := range bosss {
monster := model.GenPetInfo(int(r.MonID), 24, int(r.Nature), 0, int(r.Lv), nil, 0)
if r.Hp != 0 {
monster.Hp = uint32(r.Hp)
monster.MaxHp = uint32(r.Hp)
}
for i, v := range r.Prop {
if v != 0 {
monster.Prop[i] = v
}
}
if len(r.SKill) != 0 {
for i := 0; i < len(monster.SkillList); i++ {
if r.SKill[i] != 0 {
monster.SkillList[i].ID = r.SKill[i]
}
}
}
effects := service.NewEffectService().Args(r.Effect)
for _, v := range effects {
monster.EffectInfo = append(monster.EffectInfo, model.PetEffectInfo{
Idx: uint16(v.SeIdx),
EID: gconv.Uint16(v.Eid),
Args: gconv.Ints(v.Args),
})
}
monster.CatchTime = uint32(i)
monsterInfo.PetList = append(monsterInfo.PetList, *monster)
}
ai := player.NewAI_player(monsterInfo)
_, err = fight.NewFight(c, ai, c.GetPetInfo(100), ai.GetPetInfo(0), func(foi model.FightOverInfo) {
if foi.Reason == 0 && foi.WinnerId == c.Info.UserID { //我放获胜
switch data.Head.CMD {
case 2429: //试炼之塔
c.TawerCompletedTask(600, int(c.Info.CurrentFreshStage))
c.Info.CurrentFreshStage++
if c.Info.CurrentFreshStage >= c.Info.MaxFreshStage {
c.Info.MaxFreshStage = c.Info.CurrentFreshStage
}
case 2415: //勇者之塔
c.TawerCompletedTask(500, int(c.Info.CurrentStage))
c.Info.CurrentStage++
if c.Info.CurrentStage >= c.Info.MaxStage {
c.Info.MaxStage = c.Info.CurrentStage
}
case 2425:
c.TawerCompletedTask(110, int(c.CurDark))
}
if foi.Reason != 0 || foi.WinnerId != c.Info.UserID {
return
}
}) ///开始对战,房主方以及被邀请方
handleTowerFightWin(c, data.Head.CMD, taskID, currentLevel)
})
return
}
func towerChoiceRuntime(c *player.Player, cmd uint32) (towerChoiceState, bool) {
switch cmd {
case towerCmdChoiceTrial:
return towerChoiceState{
currentLevel: &c.Info.CurrentFreshStage,
maxLevel: &c.Info.MaxFreshStage,
service: service.NewTower600Service(),
}, true
case towerCmdChoiceBrave:
return towerChoiceState{
currentLevel: &c.Info.CurrentStage,
maxLevel: &c.Info.MaxStage,
service: service.NewTower500Service(),
}, true
default:
return towerChoiceState{}, false
}
}
func towerFightBosses(c *player.Player, cmd uint32) ([]configmodel.BaseTowerConfig, uint32, int, bool) {
switch cmd {
case towerCmdFightTrial:
return service.NewTower600Service().Boss(c.Info.CurrentFreshStage, c.Info.CurrentFreshStage+1), c.Info.CurrentFreshStage, towerTaskTrial, true
case towerCmdFightBrave:
return service.NewTower500Service().Boss(c.Info.CurrentStage, c.Info.CurrentStage+1), c.Info.CurrentStage, towerTaskBrave, true
case towerCmdFightDark:
return service.NewTower110Service().Boss(c.CurDark), c.CurDark, towerTaskDark, true
default:
return nil, 0, 0, false
}
}
func canSelectTowerLevel(targetLevel uint, maxLevel uint32) bool {
return targetLevel == 1 || targetLevel <= uint(maxLevel)
}
func firstTowerBossConfig(bossList []configmodel.BaseTowerConfig) (configmodel.BaseTowerConfig, bool) {
if len(bossList) == 0 || len(bossList[0].BossIds) == 0 {
return configmodel.BaseTowerConfig{}, false
}
return bossList[0], true
}
func appendTowerBossPreview(dst *[]uint32, bossList []configmodel.BaseTowerConfig) {
bossConfig, ok := firstTowerBossConfig(bossList)
if !ok {
return
}
bosses := service.NewBossService().Get(bossConfig.BossIds[0])
for _, boss := range bosses {
*dst = append(*dst, uint32(boss.MonID))
}
}
func appendTowerNextBossPreview(dst *[]uint32, bossList []configmodel.BaseTowerConfig) {
if len(bossList) < 2 || len(bossList[1].BossIds) == 0 {
return
}
bosses := service.NewBossService().Get(bossList[1].BossIds[0])
for _, boss := range bosses {
*dst = append(*dst, uint32(boss.MonID))
}
}
func buildTowerMonsterInfo(towerBoss configmodel.BaseTowerConfig) (*model.PlayerInfo, bool) {
bosses := service.NewBossService().Get(towerBoss.BossIds[0])
if len(bosses) == 0 {
return nil, false
}
monsterInfo := &model.PlayerInfo{Nick: towerBoss.Name}
for i, boss := range bosses {
monster := model.GenPetInfo(int(boss.MonID), 24, int(boss.Nature), 0, int(boss.Lv), nil, 0)
if boss.Hp != 0 {
monster.Hp = uint32(boss.Hp)
monster.MaxHp = uint32(boss.Hp)
}
for statIdx, prop := range boss.Prop {
if prop != 0 {
monster.Prop[statIdx] = prop
}
}
for skillIdx := 0; skillIdx < len(monster.SkillList) && skillIdx < len(boss.SKill); skillIdx++ {
if boss.SKill[skillIdx] != 0 {
monster.SkillList[skillIdx].ID = boss.SKill[skillIdx]
}
}
effects := service.NewEffectService().Args(boss.Effect)
for _, effect := range effects {
monster.EffectInfo = append(monster.EffectInfo, model.PetEffectInfo{
Idx: uint16(effect.SeIdx),
EID: gconv.Uint16(effect.Eid),
Args: gconv.Ints(effect.Args),
})
}
monster.CatchTime = uint32(i)
monsterInfo.PetList = append(monsterInfo.PetList, *monster)
}
return monsterInfo, true
}
func handleTowerFightWin(c *player.Player, cmd uint32, taskID int, currentLevel uint32) {
c.TawerCompletedTask(taskID, int(currentLevel))
switch cmd {
case towerCmdFightTrial:
c.Info.CurrentFreshStage++
if c.Info.CurrentFreshStage >= c.Info.MaxFreshStage {
c.Info.MaxFreshStage = c.Info.CurrentFreshStage
}
case towerCmdFightBrave:
c.Info.CurrentStage++
if c.Info.CurrentStage >= c.Info.MaxStage {
c.Info.MaxStage = c.Info.CurrentStage
}
}
}

94
logic/controller/item_buy.go
View File

@@ -1,7 +1,6 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/modules/config/service"
@@ -12,73 +11,34 @@ import (
// 防止封包通过领取来获取道具
// BuyItem 购买单个道具
// data: 包含购买道具信息的输入数据
// player: 当前玩家对象
// 返回: 购买结果和错误码
func (h Controller) BuyItem(data *item.BuyInboundInfo, player *player.Player) (result *item.BuyOutboundInfo, err errorcode.ErrorCode) {
itemInfo, exists := xmlres.ItemsMAP[int(data.ItemId)]
if !exists {
return &item.BuyOutboundInfo{Coins: player.Info.Coins}, 0
result = &item.BuyOutboundInfo{Coins: player.Info.Coins}
bought, err := buySeerdouBackpackItem(player, data.ItemId, data.Count)
if err != 0 {
return result, err
}
if !bought {
result.Coins = player.Info.Coins
return result, 0
}
// 免费道具直接添加
if itemInfo.Price == 0 {
if player.ItemAdd(data.ItemId, data.Count) {
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: player.Info.Coins,
}, 0
}
return &item.BuyOutboundInfo{Coins: player.Info.Coins}, 0
}
// 需要付费的道具
totalCost := int64(data.Count) * int64(itemInfo.Price)
if !player.GetCoins(totalCost) {
return &item.BuyOutboundInfo{Coins: player.Info.Coins}, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
if player.ItemAdd(data.ItemId, data.Count) {
player.Info.Coins -= totalCost
return &item.BuyOutboundInfo{
ItemId: data.ItemId,
Level: 1,
Count: data.Count,
Coins: player.Info.Coins,
}, 0
}
// 购买失败，返还赛尔豆
player.Info.Coins += totalCost
return &item.BuyOutboundInfo{Coins: player.Info.Coins}, 0
result.ItemId = data.ItemId
result.Level = 1
result.Count = data.Count
result.Coins = player.Info.Coins
return result, 0
}
// BuyMultipleItems 批量购买道具
// data: 包含批量购买道具信息的输入数据
// player: 当前玩家对象
// 返回: 批量购买结果和错误码
func (h Controller) BuyMultipleItems(data *item.BuyMultiInboundInfo, player *player.Player) (result *item.BuyMultiOutboundInfo, err errorcode.ErrorCode) {
for _, itemID := range data.ItemIds {
itemInfo, exists := xmlres.ItemsMAP[int(itemID)]
if !exists {
continue
}
// 免费道具直接添加
if itemInfo.Price == 0 {
player.ItemAdd(int64(itemID), 1)
continue
}
// 需要付费的道具
if !player.GetCoins(int64(itemInfo.Price)) {
bought, buyErr := buySeerdouBackpackItem(player, int64(itemID), 1)
if buyErr == errorcode.ErrorCodes.ErrSunDouInsufficient10016 {
break
}
if player.ItemAdd(int64(itemID), 1) {
player.Info.Coins -= int64(itemInfo.Price)
if buyErr != 0 || !bought {
continue
}
}
@@ -88,11 +48,7 @@ func (h Controller) BuyMultipleItems(data *item.BuyMultiInboundInfo, player *pla
}
// BuyGoldItem 使用金豆购买商品
// data: 包含金豆购买商品信息的输入数据
// player: 当前玩家对象
// 返回: 金豆购买结果和错误码
func (h Controller) BuyGoldItem(data *item.C2S_GOLD_BUY_PRODUCT, player *player.Player) (result *item.S2C_GoldBuyProductInfo, err errorcode.ErrorCode) {
//product, exists := xmlres.GoldProductMap[int(data.ProductID)]
pro := service.NewShopService().Get(data.ProductID)
if pro == nil {
return nil, errorcode.ErrorCodes.ErrTooManyProducts
@@ -105,15 +61,6 @@ func (h Controller) BuyGoldItem(data *item.C2S_GOLD_BUY_PRODUCT, player *player.
}
}
// if pro.QuotaType != 0 {
// if data.Count > int64(pro.QuotaLimit) {
// return nil, errorcode.ErrorCodes.ErrExceedStock
// }
// if player.Service.Talk.Cheak(0, int(data.ProductID)) {
// return nil, errorcode.ErrorCodes.ErrExceedStock
// }
// }
var usegold uint64
switch data.Type {
@@ -136,12 +83,10 @@ func (h Controller) BuyGoldItem(data *item.C2S_GOLD_BUY_PRODUCT, player *player.
return nil, errorcode.ErrorCodes.ErrSystemError
}
usegold = uint64(data.Count) * uint64(pro.JindouPrice*100)
}
switch data.Type {
case 0:
if player.ItemAdd(pro.ProductID, data.Count) {
player.Info.Coins -= int64(usegold)
}
@@ -157,9 +102,6 @@ func (h Controller) BuyGoldItem(data *item.C2S_GOLD_BUY_PRODUCT, player *player.
if player.ItemAdd(pro.ProductID, data.Count) {
player.User.UpdateGold(player.Info.UserID, -int64(usegold))
}
//购买成功，执行记录
}
player.SendPackCmd(1105, item.GoldOnlineRemainOutboundInfo{

22
logic/controller/item_use.go
View File

@@ -22,16 +22,8 @@ const (
// c: 当前玩家对象
// 返回: 道具列表和错误码
func (h Controller) GetUserItemList(data *item.ItemListInboundInfo, c *player.Player) (result *item.ItemListOutboundInfo, err errorcode.ErrorCode) {
result = &item.ItemListOutboundInfo{}
items := c.Service.Item.Get(data.Param1, data.Param2)
result.ItemList = make([]model.SingleItemInfo, len(items))
for i, itemData := range items {
result.ItemList[i] = model.SingleItemInfo{
ItemId: itemData.ItemId,
ItemCnt: uint32(itemData.ItemCnt),
LeftTime: ItemDefaultLeftTime,
}
result = &item.ItemListOutboundInfo{
ItemList: c.Service.Item.GetUserItemList(data.Param1, data.Param2, ItemDefaultLeftTime),
}
return result, 0
}
@@ -48,7 +40,7 @@ func (h Controller) UsePetItemOutOfFight(data *item.C2S_USE_PET_ITEM_OUT_OF_FIGH
itemID := uint32(data.ItemID)
if c.Service.Item.CheakItem(itemID) == 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
return nil, errorcode.ErrorCodes.ErrInsufficientItems
}
itemCfg, ok := xmlres.ItemsMAP[int(itemID)]
@@ -195,7 +187,7 @@ func (h Controller) ResetNature(data *item.C2S_PET_RESET_NATURE, c *player.Playe
}
if c.Service.Item.CheakItem(data.ItemId) <= 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
return nil, errorcode.ErrorCodes.ErrInsufficientItems
}
currentHP := currentPet.Hp
@@ -218,7 +210,7 @@ func (h Controller) UseSpeedupItem(data *item.C2S_USE_SPEEDUP_ITEM, c *player.Pl
// 1. 校验道具是否存在且数量充足
itemCount := c.Service.Item.CheakItem(data.ItemID)
if itemCount <= 0 {
return nil, errorcode.ErrorCodes.ErrSystemError // 道具不足复用系统错误码（可根据需求改为专属错误码）
return nil, errorcode.ErrorCodes.ErrInsufficientItems
}
result = &item.S2C_USE_SPEEDUP_ITEM{}
@@ -275,7 +267,7 @@ func (h Controller) UseEnergyXishou(data *item.C2S_USE_ENERGY_XISHOU, c *player.
// 1. 校验道具是否存在且数量充足
itemCount := c.Service.Item.CheakItem(data.ItemID)
if itemCount <= 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
return nil, errorcode.ErrorCodes.ErrInsufficientItems
}
if c.Info.EnergyTime != 0 {
return nil, errorcode.ErrorCodes.ErrItemInUse
@@ -311,7 +303,7 @@ func (h Controller) UseAutoFightItem(data *item.C2S_USE_AUTO_FIGHT_ITEM, c *play
itemCount := c.Service.Item.CheakItem(data.ItemID)
if itemCount <= 0 {
return nil, errorcode.ErrorCodes.ErrSystemError
return nil, errorcode.ErrorCodes.ErrInsufficientItems
}
if c.Info.AutoFightTime != 0 {
return nil, errorcode.ErrorCodes.ErrItemInUse

54
logic/controller/login_getserver.go
View File

@@ -1,54 +0,0 @@
package controller
// var sg singleflight.Group
// var ServerList []rpc.ServerInfo
// func fetchData() (any, error) {
// ServerList = rpc.GetServerInfoList() //todo 待修改增加缓存
// return ServerList, nil
// }
// GetServerOnline 处理命令: 105
// func (h Controller) GetServerOnline(data *user.SidInfo, c gnet.Conn) (result *rpc.CommendSvrInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
// result = rpc.NewInInfo()
// // tt, _ := cool.CacheManager.Keys(context.Background())
// //g.Dump(tt)
// t1 := hex.EncodeToString(data.Sid)
// userid, ok := playerservice.User.Load(t1)
// if !ok || userid != data.Head.UserID {
// defer c.Close()
// return
// }
// result.IsVip = 1
// result.ServerList = rpc.GetServerInfoList(service.NewBaseSysUserService().GetPerson(data.Head.UserID).Debug)
// ser := playerservice.NewUserService(data.Head.UserID)
// f, b := ser.Friend.Get()
// for _, v := range f {
// result.FriendInfo = append(result.FriendInfo, rpc.FriendInfo{Userid: v, TimePoke: 1})
// }
// result.BlackInfo = b
// defer func() {
// // share.ShareManager.DeleteSession(t1)
// kickErr := ser.Info.Kick(data.Head.UserID)
// if kickErr != nil {
// fmt.Println("踢人失败", kickErr)
// }
// logininfo := ser.Info.SetLogin()
// if logininfo != nil {
// cool.CacheManager.Set(context.TODO(), fmt.Sprintf("player:%d", data.Head.UserID), logininfo, 0)
// cool.CacheManager.Set(context.Background(), fmt.Sprintf("session:%d", data.Head.UserID), t1, 0)
// }
// }()
// return
// //return //TODO 这里待实现改成接口调用Ret方法
// }

43
logic/controller/nono.go
View File

@@ -4,20 +4,25 @@ import (
"blazing/common/socket/errorcode"
"blazing/logic/service/nono"
"blazing/logic/service/player"
)
"github.com/jinzhu/copier"
const (
nonoFuncValue = 255
nonoDefaultNum = 1
nonoDefaultPower = 0
nonoDefaultLevel = 12
nonoPetCureCost int64 = 50
)
func (h Controller) NonoFollowOrHome(data *nono.NonoFollowOrHomeInInfo, c *player.Player) (result *nono.NonoFollowOutInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
c.Info.NONO.Flag = data.Flag
result = &nono.NonoFollowOutInfo{
UserID: data.Head.UserID,
SuperStage: data.Flag,
Flag: data.Flag,
Nick: "",
Color: c.Info.NONO.NonoColor,
Power: 0,
Power: nonoDefaultPower,
}
return
@@ -25,22 +30,26 @@ func (h Controller) NonoFollowOrHome(data *nono.NonoFollowOrHomeInInfo, c *playe
// GetNonoInfo 获取nono信息
func (h *Controller) GetNonoInfo(data *nono.NonoInboundInfo, c *player.Player) (result *nono.NonoOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
_ = data
result = &nono.NonoOutboundInfo{}
copier.Copy(result, &c.Info.NONO)
result.UserID = c.Info.UserID
for i := 0; i < 20; i++ {
result.Func[i] = 255
result = &nono.NonoOutboundInfo{
UserID: c.Info.UserID,
Nick: c.Info.NONO.Nick,
SuperNono: nonoDefaultNum,
Color: c.Info.NONO.NonoColor,
Num: nonoDefaultNum,
SuperLevel: nonoDefaultLevel,
SuperStage: c.Info.NONO.Flag,
Power: nonoDefaultPower,
SuperEnergy: nonoDefaultPower,
}
for i := range result.Func {
result.Func[i] = nonoFuncValue
}
result.Num = 1
result.SuperNono = 1
result.SuperLevel = 12
return
}
func (h *Controller) SwitchFlying(data *nono.SwitchFlyingInboundInfo, c *player.Player) (result *nono.SwitchFlyingOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
result = &nono.SwitchFlyingOutboundInfo{
UserId: data.Head.UserID,
Type: data.Type,
@@ -51,16 +60,16 @@ func (h *Controller) SwitchFlying(data *nono.SwitchFlyingInboundInfo, c *player.
}
func (h *Controller) PlayerPetCure(data *nono.PetCureInboundInfo, c *player.Player) (result *nono.PetCureOutboundEmpty, err errorcode.ErrorCode) { //这个时候player应该是空的
_ = data
if c.GetSpace().Owner.UserID == c.Info.UserID {
return result, errorcode.ErrorCodes.ErrChampionCannotHeal
}
if !c.GetCoins(50) {
if !c.GetCoins(nonoPetCureCost) {
return result, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
for i := 0; i < len(c.Info.PetList); i++ {
for i := range c.Info.PetList {
c.Info.PetList[i].Cure()
}
c.Info.Coins -= 50
c.Info.Coins -= nonoPetCureCost
return
}

26
logic/controller/pet_elo.go
View File

@@ -18,34 +18,34 @@ func (h Controller) PetELV(data *C2S_PET_EVOLVTION, c *player.Player) (result *f
return nil, errorcode.ErrorCodes.Err10401
}
flag := xmlres.PetMAP[int(currentPet.ID)].EvolvFlag
if flag == 0 {
petCfg, ok := xmlres.PetMAP[int(currentPet.ID)]
if !ok || petCfg.EvolvFlag == 0 {
return nil, errorcode.ErrorCodes.ErrPokemonNotEvolveReady
}
if xmlres.PetMAP[int(currentPet.ID)].EvolvingLv > int(currentPet.Level) {
if petCfg.EvolvingLv > int(currentPet.Level) {
return nil, errorcode.ErrorCodes.ErrPokemonNotEvolveReady
}
evinfo := xmlres.EVOLVMAP[flag].Branches[data.Index-1]
if c.Service.Item.CheakItem(uint32(evinfo.EvolvItem)) < int64(evinfo.EvolvItemCount) {
evolveCfg, ok := xmlres.EVOLVMAP[petCfg.EvolvFlag]
if !ok || data.Index == 0 || int(data.Index) > len(evolveCfg.Branches) {
return nil, errorcode.ErrorCodes.ErrPokemonNotEvolveReady
}
branch := evolveCfg.Branches[data.Index-1]
if branch.EvolvItem != 0 && c.Service.Item.CheakItem(uint32(branch.EvolvItem)) < int64(branch.EvolvItemCount) {
return nil, errorcode.ErrorCodes.ErrInsufficientItemsMulti
}
if evinfo.EvolvItem != 0 {
c.Service.Item.UPDATE(uint32(evinfo.EvolvItem), -evinfo.EvolvItemCount)
if branch.EvolvItem != 0 {
c.Service.Item.UPDATE(uint32(branch.EvolvItem), -branch.EvolvItemCount)
}
currentPet.ID = uint32(xmlres.EVOLVMAP[flag].Branches[data.Index-1].MonTo)
currentPet.ID = uint32(branch.MonTo)
currentPet.Update(true)
currentPet.CalculatePetPane(100)
currentPet.Update(true)
updateOutbound := &info.PetUpdateOutboundInfo{}
var petUpdateInfo info.UpdatePropInfo
copier.Copy(&petUpdateInfo, currentPet)
updateOutbound.Data = append(updateOutbound.Data, petUpdateInfo)
c.SendPackCmd(2508, updateOutbound) //准备包由各自发,因为协议不一样
return nil, -1

40
logic/controller/pet_ev.go
View File

@@ -5,8 +5,11 @@ import (
"blazing/logic/service/common"
"blazing/logic/service/fight"
"blazing/logic/service/player"
)
"github.com/samber/lo"
const (
petEVMaxTotal uint32 = 510
petEVMaxSingle uint32 = 255
)
// PetEVDiy 自定义分配宠物努力值（EV）
@@ -18,30 +21,39 @@ func (h Controller) PetEVDiy(data *PetEV, c *player.Player) (result *fight.NullO
if !found {
return nil, errorcode.ErrorCodes.Err10401
}
// 分配超过510的数据
if lo.Sum(data.EVs[:]) > 510 {
return nil, errorcode.ErrorCodes.Err10401
}
var targetTotal uint32
var currentTotal uint32
for i, evValue := range data.EVs {
// 分配超过255的数据
if evValue > 255 {
currentEV := currentPet.Ev[i]
// 单项分配不能超过上限。
if evValue > petEVMaxSingle {
return nil, errorcode.ErrorCodes.Err10401
}
// 分配比之前点数少的
if evValue < currentPet.Ev[i] {
targetTotal += evValue
if targetTotal > petEVMaxTotal {
return nil, errorcode.ErrorCodes.Err10401
}
}
if lo.Sum(data.EVs[:]) < lo.Sum(currentPet.Ev[:]) {
return nil, errorcode.ErrorCodes.Err10401
// 不允许回退已分配的努力值。
if evValue < currentEV {
return nil, errorcode.ErrorCodes.Err10401
}
currentTotal += currentEV
}
usedEV := lo.Sum(data.EVs[:]) - lo.Sum(currentPet.Ev[:])
// 加的比池子还多
usedEV := targetTotal - currentTotal
if usedEV == 0 {
return result, 0
}
// 新增分配不能超过玩家累计学习力池。
if int64(usedEV) > c.Info.EVPool {
return nil, errorcode.ErrorCodes.Err10401
}
currentPet.Ev = data.EVs
currentPet.CalculatePetPane(100)
c.Info.EVPool -= int64(usedEV)

190
logic/controller/pet_fusion.go
View File

@@ -10,133 +10,159 @@ import (
"github.com/alpacahq/alpacadecimal"
"github.com/gogf/gf/v2/util/grand"
"github.com/samber/lo"
)
const (
petFusionCost = 1000
petFusionKeepAuxItemID = 300043
petFusionFailureItemID = 300044
petFusionSoulID = 1000017
)
func (h Controller) PetFusion(data *pet.C2S_PetFusion, c *player.Player) (result *pet.PetFusionInfo, err errorcode.ErrorCode) {
if !c.GetCoins(1000) {
return result, errorcode.ErrorCodes.ErrSunDouInsufficient10016
result = &pet.PetFusionInfo{
SoulID: petFusionSoulID,
}
c.Info.Coins -= 1000
// g.Dump(c.Info.PetList)
//防止同一只
if data.Mcatchtime == data.Auxcatchtime {
return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady
}
_, Mcatchpetinfo, ok := c.FindPet(data.Mcatchtime)
_, masterPet, ok := c.FindPet(data.Mcatchtime)
if !ok {
return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady2
}
if xmlres.PetMAP[int(Mcatchpetinfo.ID)].FuseMaster == 0 {
masterCfg, ok := xmlres.PetMAP[int(masterPet.ID)]
if !ok || masterCfg.FuseMaster == 0 {
return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady3
}
_, Auxpetinfo, ok := c.FindPet(data.Auxcatchtime)
_, auxPet, ok := c.FindPet(data.Auxcatchtime)
if !ok {
return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady2
}
if xmlres.PetMAP[int(Auxpetinfo.ID)].FuseSub == 0 {
auxCfg, ok := xmlres.PetMAP[int(auxPet.ID)]
if !ok || auxCfg.FuseSub == 0 {
return result, errorcode.ErrorCodes.ErrPokemonNotFusionReady3
}
//println(len(c.Info.PetList), data.Mcatchtime, data.Auxcatchtime, Mcatchpetinfo.CatchTime, Auxpetinfo.CatchTime)
///性格生成
var natureId int32 = -1
if Auxpetinfo.Nature == Mcatchpetinfo.Nature {
natureId = int32(Auxpetinfo.Nature)
materialCounts := collectItemCounts(data.Item1[:])
if !hasEnoughItems(c, materialCounts) {
return result, errorcode.ErrorCodes.ErrInsufficientItems
}
for _, v := range c.Service.Item.CheakItemM(data.Item1[:]...) {
if v.ItemCnt <= 0 {
return result, errorcode.ErrorCodes.ErrInsufficientItems
}
}
resid := int(service.NewPetFusionService().Data(Mcatchpetinfo.ID, Auxpetinfo.ID, Mcatchpetinfo.Level+Auxpetinfo.Level))
effect := int(service.NewPetFusionMaterialService().Data(data.Item1))
materialService := service.NewPetFusionMaterialService()
effect := int(materialService.Data(data.Item1))
if effect == 0 {
return result, errorcode.ErrorCodes.ErrSpiritOrbNotExists
}
//c.Service.Item.UPDATEM(data.Item1[:], -1)
// utils.CountSliceElements(data.Item1[:])
for _, v := range data.Item1 {
err := c.Service.Item.UPDATE(v, -1)
if err != nil {
return result, errorcode.ErrorCodes.ErrInsufficientItems
}
fusionService := service.NewPetFusionService()
resultPetID := int(fusionService.Data(masterPet.ID, auxPet.ID, masterPet.Level+auxPet.Level))
if !c.GetCoins(petFusionCost) {
return result, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
result = &pet.PetFusionInfo{
SoulID: 1000017,
consumeItems(c, materialCounts)
c.Info.Coins -= petFusionCost
CostItemFlag: 0,
}
if resid == 0 {
_, ok := lo.Find(data.GoldItem1[:], func(item uint32) bool {
return item == 300044
})
if c.Service.Item.CheakItem(300044) > 0 && ok {
c.Service.Item.UPDATE(300044, -1)
if resultPetID == 0 {
if useOptionalItem(c, data.GoldItem1[:], petFusionFailureItemID) {
result.CostItemFlag = 1
} else if auxPet.Level > 5 {
auxPet.Downgrade(auxPet.Level - 5)
} else {
if Auxpetinfo.Level > 5 {
// Auxpetinfo.Level = Auxpetinfo.Level - 5
Auxpetinfo.Downgrade(Auxpetinfo.Level - 5)
} else {
Auxpetinfo.Downgrade(1)
}
auxPet.Downgrade(1)
}
return &pet.PetFusionInfo{}, 0
}
dv1 := alpacadecimal.NewFromInt(2).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(Mcatchpetinfo.Dv)))
dv2 := alpacadecimal.NewFromInt(1).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(Auxpetinfo.Dv)))
natureID := int32(-1)
if auxPet.Nature == masterPet.Nature {
natureID = int32(auxPet.Nature)
}
dv1 := alpacadecimal.NewFromInt(2).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(masterPet.Dv)))
dv2 := alpacadecimal.NewFromInt(1).Div(alpacadecimal.NewFromInt(3)).Mul(alpacadecimal.NewFromInt(int64(auxPet.Dv)))
dv := dv1.Add(dv2).Add(alpacadecimal.NewFromInt(1)).IntPart()
r := model.GenPetInfo(resid, int(dv), int(natureId), effect, 1, nil, -1)
r.OldCatchTime = Mcatchpetinfo.CatchTime
newPet := model.GenPetInfo(resultPetID, int(dv), int(natureID), effect, 1, nil, -1)
newPet.OldCatchTime = masterPet.CatchTime
shinycont := 1
if Mcatchpetinfo.IsShiny() || Auxpetinfo.IsShiny() {
shinycont = 50
shinyChance := 1
if masterPet.IsShiny() || auxPet.IsShiny() {
shinyChance = 50
}
if Mcatchpetinfo.IsShiny() && Auxpetinfo.IsShiny() {
shinycont = 100
if masterPet.IsShiny() && auxPet.IsShiny() {
shinyChance = 100
}
if grand.Meet(shinyChance, 100) {
newPet.RandomByWeightShiny()
}
if grand.Meet(shinycont, 100) {
r.RandomByWeightShiny()
}
c.Service.Pet.PetAdd(r, 0)
println(c.Info.UserID, "进行融合", len(c.Info.PetList), Mcatchpetinfo.ID, Auxpetinfo.ID, r.ID)
c.Service.Pet.PetAdd(newPet, 0)
println(c.Info.UserID, "进行融合", len(c.Info.PetList), masterPet.ID, auxPet.ID, newPet.ID)
c.PetDel(data.Mcatchtime)
_, ok2 := lo.Find(data.GoldItem1[:], func(item uint32) bool {
return item == 300043
})
if c.Service.Item.CheakItem(300043) > 0 && ok2 {
c.Service.Item.UPDATE(300043, -1)
if useOptionalItem(c, data.GoldItem1[:], petFusionKeepAuxItemID) {
result.CostItemFlag = 1
} else {
c.PetDel(data.Auxcatchtime)
}
result.ObtainTime = r.CatchTime
result.StarterCpTm = r.ID
//todo材料扣除
result.ObtainTime = newPet.CatchTime
result.StarterCpTm = newPet.ID
return result, 0
}
func collectItemCounts(itemIDs []uint32) map[uint32]int {
counts := make(map[uint32]int, len(itemIDs))
for _, itemID := range itemIDs {
counts[itemID]++
}
return counts
}
func hasEnoughItems(c *player.Player, itemCounts map[uint32]int) bool {
if len(itemCounts) == 0 {
return true
}
itemIDs := make([]uint32, 0, len(itemCounts))
for itemID := range itemCounts {
itemIDs = append(itemIDs, itemID)
}
hadItems := c.Service.Item.CheakItemM(itemIDs...)
ownedCounts := make(map[uint32]int64, len(hadItems))
for _, item := range hadItems {
ownedCounts[item.ItemId] = item.ItemCnt
}
for itemID, need := range itemCounts {
if ownedCounts[itemID] < int64(need) {
return false
}
}
return true
}
func consumeItems(c *player.Player, itemCounts map[uint32]int) {
for itemID, count := range itemCounts {
_ = c.Service.Item.UPDATE(itemID, -count)
}
}
func useOptionalItem(c *player.Player, itemIDs []uint32, target uint32) bool {
if c.Service.Item.CheakItem(target) <= 0 {
return false
}
for _, itemID := range itemIDs {
if itemID == target {
_ = c.Service.Item.UPDATE(target, -1)
return true
}
}
return false
}

113
logic/controller/pet_繁殖.go
View File

@@ -10,7 +10,6 @@ import (
"time"
"github.com/gogf/gf/v2/util/grand"
"github.com/samber/lo"
"github.com/yudeguang/ratelimit"
)
@@ -35,40 +34,27 @@ func (ctl Controller) GetBreedInfo(
// 前端到后端
func (ctl Controller) GetBreedPet(
data *pet.C2S_GET_BREED_PET, playerObj *player.Player) (result *pet.S2C_GET_BREED_PET, err errorcode.ErrorCode) { //这个时候player应该是空的
_, fPet, found := playerObj.FindPet(data.MaleCatchTime)
if !found {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
if fPet.Gender != 1 {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
if fPet.Generation > 9 {
_, malePet, found := playerObj.FindPet(data.MaleCatchTime)
if !found || !canBreedPet(malePet, 1) {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
result = &pet.S2C_GET_BREED_PET{}
compatibleFemaleIDs := buildBreedPetIDSet(service.NewEggService().GetData(malePet.ID))
if len(compatibleFemaleIDs) == 0 {
return result, 0
}
MPETS := service.NewEggService().GetData(fPet.ID)
// 这里只是示例，实际应该根据雄性精灵的catchTime查找可繁殖的雌性精灵
for _, v := range playerObj.Info.PetList {
if v.Level < 50 {
result.FemaleList = make([]uint32, 0, len(playerObj.Info.PetList))
for i := range playerObj.Info.PetList {
femalePet := &playerObj.Info.PetList[i]
if !canBreedPet(femalePet, 2) {
continue
}
//不是雌性
if v.Gender != 2 {
if _, ok := compatibleFemaleIDs[femalePet.ID]; !ok {
continue
}
if v.Generation > 9 {
continue
}
_, ok := lo.Find(MPETS, func(item int32) bool {
return item == int32(v.ID)
})
if !ok {
continue
}
// 如果是雌性精灵，且可以繁殖，则添加到列表
result.FemaleList = append(result.FemaleList, v.CatchTime)
result.FemaleList = append(result.FemaleList, femalePet.CatchTime)
}
return result, 0
@@ -78,34 +64,38 @@ func (ctl Controller) GetBreedPet(
// 前端到后端
func (ctl Controller) StartBreed(
data *pet.C2S_START_BREED, player *player.Player) (result *fight.NullOutboundInfo, err errorcode.ErrorCode) { //这个时候player应该是空的
if !player.GetCoins(1000) {
return result, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
player.Info.Coins -= 1000
_, MalePet, found := player.FindPet(data.Male)
if !found {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
_, Female, found := player.FindPet(data.Female)
if !found {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
// TODO: 实现开始繁殖的具体逻辑
result = &fight.NullOutboundInfo{}
r := player.Service.Egg.StartBreed(MalePet, Female)
if !r {
if data.Male == data.Female {
return nil, errorcode.ErrorCodes.ErrCannotPerformAction
}
MalePet.Generation++
Female.Generation++
_, malePet, found := player.FindPet(data.Male)
if !found || !canBreedPet(malePet, 1) {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
_, femalePet, found := player.FindPet(data.Female)
if !found || !canBreedPet(femalePet, 2) {
return nil, errorcode.ErrorCodes.ErrPokemonNotExists
}
if !canBreedPair(malePet.ID, femalePet.ID) {
return nil, errorcode.ErrorCodes.ErrCannotPerformAction
}
if !player.GetCoins(breedCost) {
return nil, errorcode.ErrorCodes.ErrSunDouInsufficient10016
}
r1 := grand.Meet(1, 2)
if r1 {
MalePet.Gender = 0
result = &fight.NullOutboundInfo{}
if !player.Service.Egg.StartBreed(malePet, femalePet) {
return nil, errorcode.ErrorCodes.ErrCannotPerformAction
}
player.Info.Coins -= breedCost
malePet.Generation++
femalePet.Generation++
if grand.Meet(1, 2) {
malePet.Gender = 0
} else {
Female.Gender = 0
femalePet.Gender = 0
}
return result, 0
@@ -113,6 +103,23 @@ func (ctl Controller) StartBreed(
// GetEggList 获取精灵蛋数组
// 前端到后端无数据 请求协议
func canBreedPet(p *model.PetInfo, gender int) bool {
return p != nil && p.Level >= breedMinLevel && p.Gender == gender && p.Generation <= breedMaxGeneration
}
func buildBreedPetIDSet(ids []int32) map[uint32]struct{} {
ret := make(map[uint32]struct{}, len(ids))
for _, id := range ids {
ret[uint32(id)] = struct{}{}
}
return ret
}
func canBreedPair(maleID, femaleID uint32) bool {
_, ok := buildBreedPetIDSet(service.NewEggService().GetData(maleID))[femaleID]
return ok
}
func (ctl Controller) GetEggList(
data *pet.C2S_GET_EGG_LIST, player *player.Player) (result *pet.S2C_GET_EGG_LIST, err errorcode.ErrorCode) { //这个时候player应该是空的
@@ -130,6 +137,12 @@ func (ctl Controller) GetEggList(
}
const (
breedMinLevel = 50
breedMaxGeneration = 9
breedCost = 1000
)
var limiter *ratelimit.Rule = ratelimit.NewRule()
// 简单规则案例

24
logic/controller/room_buy.go
View File

@@ -1,28 +1,26 @@
package controller
import (
"blazing/common/data/xmlres"
"blazing/common/socket/errorcode"
"blazing/logic/service/player"
"blazing/logic/service/room"
)
// BuyFitment 购买基地家具
// 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{Coins: c.Info.Coins}
itemConfig := xmlres.ItemsMAP[int(data.ID)]
totalCost := int64(itemConfig.Price) * int64(data.Count)
if !c.GetCoins((totalCost)) {
return nil, errorcode.ErrorCodes.ErrSunDouInsufficient10016
bought, err := buySeerdouBackpackItem(c, int64(data.ID), int64(data.Count))
if err != 0 {
return nil, err
}
c.Service.Item.UPDATE(data.ID, int(data.Count))
c.Info.Coins -= int64(totalCost)
if !bought {
result.Coins = c.Info.Coins
return result, 0
}
result.ID = data.ID
result.Count = data.Count
result.Coins = c.Info.Coins
return
return result, 0
}

35
logic/controller/user_cdk.go
View File

@@ -12,7 +12,12 @@ import (
func (h Controller) CDK(data *user.C2S_GET_GIFT_COMPLETE, player *player.Player) (result *user.S2C_GET_GIFT_COMPLETE, err errorcode.ErrorCode) {
result = &user.S2C_GET_GIFT_COMPLETE{}
r := service.NewCdkService().Get(data.PassText)
cdkService := service.NewCdkService()
rewardPetService := service.NewPetRewardService()
itemRewardService := service.NewItemService()
now := time.Now()
r := cdkService.Get(data.PassText)
if r == nil {
return nil, errorcode.ErrorCodes.ErrMolecularCodeNotExists
}
@@ -20,38 +25,36 @@ func (h Controller) CDK(data *user.C2S_GET_GIFT_COMPLETE, player *player.Player)
return nil, errorcode.ErrorCodes.ErrMolecularCodeFrozen
}
if r.ValidEndTime.Compare(time.Now()) == -1 {
if r.ValidEndTime.Compare(now) == -1 {
return nil, errorcode.ErrorCodes.ErrMolecularCodeExpired
}
if !player.Service.Cdk.CanGet(uint32(r.ID)) {
return
}
if !service.NewCdkService().Set(data.PassText) {
if !cdkService.Set(data.PassText) {
return nil, errorcode.ErrorCodes.ErrMolecularCodeGiftsGone
}
result.Flag = 1
for _, v := range r.ElfRewardIds {
pet := service.NewPetRewardService().Get(v)
if pet != nil {
peti := model.GenPetInfo(int(pet.MonID), int(pet.DV), int(pet.Nature), int(pet.Effect), int(pet.Lv), nil, 0)
player.Service.Pet.PetAdd(peti, 0)
result.PetGift = append(result.PetGift, user.PetGiftInfo{PetID: peti.ID, CacthTime: peti.CatchTime})
for _, rewardID := range r.ElfRewardIds {
pet := rewardPetService.Get(rewardID)
if pet == nil {
continue
}
petInfo := model.GenPetInfo(int(pet.MonID), int(pet.DV), int(pet.Nature), int(pet.Effect), int(pet.Lv), nil, 0)
player.Service.Pet.PetAdd(petInfo, 0)
result.PetGift = append(result.PetGift, user.PetGiftInfo{PetID: petInfo.ID, CacthTime: petInfo.CatchTime})
}
for _, itemID := range r.ItemRewardIds {
iteminfo := service.NewItemService().GetItemCount(itemID)
player.ItemAdd(iteminfo.ItemId, iteminfo.ItemCnt)
result.GiftList = append(result.GiftList, user.GiftInfo{GiftID: iteminfo.ItemId, Count: iteminfo.ItemCnt})
for _, rewardID := range r.ItemRewardIds {
itemInfo := itemRewardService.GetItemCount(rewardID)
player.ItemAdd(itemInfo.ItemId, itemInfo.ItemCnt)
result.GiftList = append(result.GiftList, user.GiftInfo{GiftID: itemInfo.ItemId, Count: itemInfo.ItemCnt})
}
if r.TitleRewardIds != 0 {
player.Service.Title.Give(r.TitleRewardIds)
result.Tile = r.TitleRewardIds
}
player.Service.Cdk.Log(uint32(r.ID))