pet_home/pet_home_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'sdk' into online

Browse Source
This commit is contained in:
hahwu 2026-03-30 14:51:45 +08:00
commit f5978169dd
73 changed files with 4415 additions and 4208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/server/MergeConst/system.go Normal file
View File

@ -0,0 +1,7 @@
package MergeConst
const (
Go_gc_percent = 200
Go_gc_memory_limit = 1024 << 20
Go_game_version = "1.0.3" // 游戏版本号，格式为 "主版本号.次版本号.修订号"，每次发布新版本时需要更新
)

66
src/server/backend/server.go
View File

@ -1,24 +1,52 @@
package backend
func Start() {
// addr := net.JoinHostPort("localhost", "9090")
// handler := NewGameServiceHandler()
import (
"context"
"net"
"server/conf"
"server/game"
"server/msg"
"server/pkg/github.com/name5566/leaf/log"
// //创建处理器
// processor := backend.NewGameAdminServiceProcessor(handler)
"google.golang.org/grpc"
)
// transportFactory := thrift.NewTBufferedTransportFactory(8192)
// protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{})
// tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
// if err != nil {
// fmt.Printf("Failed to resolve address %s: %v\n", addr, err)
// return
// }
// serverTransport := thrift.NewTServerSocketFromAddrTimeout(tcpAddr, 0)
// server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
// fmt.Printf("Starting the server on %s...\n", addr)
// if err := server.Serve(); err != nil {
// fmt.Printf("Error starting the server: %v\n", err)
// }
type backendServer struct {
msg.UnimplementedBackendServer
}
func (s *backendServer) ReloadActivity(ctx context.Context, req *msg.ReqActivityCfgReload) (*msg.ResActivityCfgReload, error) {
log.Debug("Received ReloadActivity request: %v", req)
game.AcitivityCfgReload()
return nil, nil
}
func (s *backendServer) OrderShipping(ctx context.Context, req *msg.ReqOrderShipping) (*msg.ResOrderShipping, error) {
log.Debug("Received OrderShipping request: %v", req)
res, err := game.AdminShipping(req)
if err != nil {
log.Error("OrderShipping error: %v", err)
return nil, err
}
return res, nil
}
func Start() {
if conf.Server.RPCAddr == "" {
log.Debug("RPC server address not configured, skipping gRPC server startup")
return
}
lis, err := net.Listen("tcp", conf.Server.RPCAddr)
if err != nil {
log.Error("failed to listen: %v", err)
return
}
s := grpc.NewServer()
msg.RegisterBackendServer(s, &backendServer{})
log.Debug("gRPC server listening on %s", conf.Server.RPCAddr)
if err := s.Serve(lis); err != nil {
log.Error("server exited with error: %v", err)
}
}

135
src/server/backend/sever_handler.go
View File

@ -1,135 +0,0 @@
package backend
// type GameServiceHandler struct{}
// func NewGameServiceHandler() *GameServiceHandler {
// return &GameServiceHandler{}
// }
// func (h *GameServiceHandler) ReqPlayerInfo(ctx context.Context, id int64) (*backend.ResAdminInfo, error) {
// player := game.G_GameLogicPtr.GetPlayer(int64(id))
// online := true
// if player == nil {
// player = new(game.Player)
// player.M_DwUin = int64(id)
// player.InitPlayerOnly()
// player.ZeroUpdate(nil)
// online = false
// }
// res := &backend.ResAdminInfo{}
// res.Name = player.GetBaseMod().NickName
// res.UID = player.M_DwUin
// res.AreaId = int32(player.GetDecorateMod().GetAreaId())
// res.Face = int32(player.GetFaceMod().SetId)
// res.Charge = player.GetChargeMod().Charge
// res.MaxCharge = player.GetChargeMod().MaxCharge
// res.Level = int32(player.GetPlayerBaseMod().GetLevel())
// res.Diamond = int32(player.GetPlayerBaseMod().GetDiamond())
// res.Star = int32(player.GetPlayerBaseMod().GetStar())
// res.Energy = int32(player.GetPlayerBaseMod().GetEnergy())
// res.UserName = player.GetPlayerBaseMod().GetName()
// res.LoginTime = player.GetBaseMod().LoginTime
// res.Cumulative = int32(player.GetBaseMod().Cumulative)
// res.RegisterTime = int32(player.GetPlayerBaseMod().GetRegisterTime())
// res.TodayCumulative = int32(player.GetBaseMod().TodayCumulative)
// res.Ban = int8(db.GetPlayerBan(player.GetBaseMod().Account))
// if online {
// res.Cumulative = int32(int64(player.GetBaseMod().Cumulative) + GoUtil.Now() - int64(player.GetBaseMod().LoginTime))
// res.TodayCumulative = int32(int64(player.GetBaseMod().TodayCumulative) + GoUtil.Now() - int64(player.GetBaseMod().LoginTime))
// }
// res.Code = player.GetBaseMod().AddCode
// res.ChessMap = player.GetChessMod().ChessMap
// resActLog := make([]*backend.Actlog, 0, len(player.GetFriendMod().ActivityLog))
// for _, log := range player.GetFriendMod().ActivityLog {
// resActLog = append(resActLog, &backend.Actlog{
// Type: int8(log.Type),
// Time: log.Time,
// Param: log.Param,
// })
// }
// res.ActLog = resActLog
// friendList := player.GetFriendMod().NewFriendList
// type friendInfo struct {
// Uid int64
// NickName string
// Avatar int
// Level int
// LogoutTime int64
// LoginTime int64
// }
// resFriendList := make([]*backend.FriendInfo, 0, len(friendList))
// for v := range friendList {
// ps := game.G_GameLogicPtr.GetSimplePlayerByUid(v)
// if ps == nil {
// continue
// }
// resFriendList = append(resFriendList, &backend.FriendInfo{
// UID: int64(v),
// NickName: ps.Name,
// Face: int32(ps.Face),
// Level: int32(ps.Level),
// LogoutTime: ps.Loginout,
// LoginTime: ps.Login,
// })
// }
// res.FriendList = resFriendList
// OrderMap := make(map[int32]*backend.OrderInfo)
// Index := 0
// for k, v := range player.GetOrderMod().OrderList {
// OrderMap[int32(Index)] = &backend.OrderInfo{
// ID: int32(k),
// Type: int32(v.Type),
// Time: v.Timestamp,
// ChessId: GoUtil.IntSliceToString(v.MergeId),
// Diff: int8(v.Diff),
// }
// Index++
// }
// res.OrderList = OrderMap
// return res, nil
// }
// func (h *GameServiceHandler) ReqReloadServerMail(ctx context.Context) (*backend.ResMessage, error) {
// game.G_GameLogicPtr.MailMgrCall(&msg.Msg{Type: msg.HANDLE_TYPE_MAIL_RELOAD})
// game.G_GameLogicPtr.NotifyAll(&msg.Msg{Type: msg.HANDLE_TYPE_MAIL})
// log.Debug("ReqReloadServerMail success")
// return &backend.ResMessage{
// Code: 0,
// }, nil
// }
// func (h *GameServiceHandler) ReqConfigReload(ctx context.Context) (*backend.ResMessage, error) {
// gamedata.Reload()
// return &backend.ResMessage{
// Code: 0,
// }, nil
// }
// func (h *GameServiceHandler) ReqAdminGm(ctx context.Context, uid int64, command string) (*backend.ResMessage, error) {
// player := game.G_GameLogicPtr.GetPlayer(uid)
// if player == nil {
// return &backend.ResMessage{
// Code: 1,
// Msg: "player not online",
// }, nil
// }
// player.Lock()
// defer player.UnLock()
// err := game.ReqGmCommand_(player, command)
// if err != nil {
// return &backend.ResMessage{
// Code: 1,
// Msg: err.Error(),
// }, nil
// }
// return &backend.ResMessage{
// Code: 0,
// }, nil
// }
// func (h *GameServiceHandler) ReqAdminBan(ctx context.Context, uid int64, banTime int64) (*backend.ResMessage, error) {
// db.UpdatePlayerBan(uid, banTime)
// return &backend.ResMessage{
// Code: 0,
// }, nil
// }

12
src/server/conf/activity/activity_cfg.go
View File

@ -1,11 +1,9 @@
package activityCfg
import (
languageCfg "server/conf/language"
"server/game/mod/item"
GoUtil "server/game_util"
"server/gamedata"
"server/msg"
"server/pkg/github.com/name5566/leaf/log"
"strconv"
)
@ -136,16 +134,6 @@ func GetActivityRewardItems(ActId int) []*item.Item {
return nil
}
func GetActivityTitle(ActId int) (string, string) {
data, err := gamedata.GetDataByIntKey(CFG_ACTIVITY, ActId)
if err != nil {
log.Debug("GetActivityTitle err:%v", err)
return "", ""
}
title := gamedata.GetStringValue(data, "Title")
return languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, title), languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, title)
}
func GetActivityRecycleMail(ActId int) (string, string, string) {
data, err := gamedata.GetDataByIntKey(CFG_ACTIVITY, ActId)
if err != nil {

1
src/server/conf/json.go
View File

@ -14,6 +14,7 @@ var Server struct {
LogLevel string
LogPath string
WSAddr string
RPCAddr string
CertFile string
KeyFile string
TCPAddr string

28
src/server/conf/limited_time_event/limited_time_event_cfg.go
View File

@ -24,7 +24,6 @@ const (
CFG_LIMITED_TIME_EVENT_BONUS = "LimitedTimeEventBonus"
CFG_LIMITED_TIME_EVENT_MONEY = "LimitedTimeEventMoney"
CFG_LIMITED_TIME_EVENT_LUCKY = "LimitedTimeEventLucky"
CFG_LIMITED_TIME_EVENT_CAT_TRICK = "LimitedTimeEventCatTrick"
CFG_LIMTTED_TIME_EVENT_DECORATE_OFF = "LimitedTimeEventDecorateOff"
)
@ -42,7 +41,6 @@ func init() {
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_MONEY)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_LUCKY)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
gamedata.InitCfg(CFG_LIMTTED_TIME_EVENT_DECORATE_OFF)
}
@ -421,28 +419,22 @@ func GetLuckyCatMaxEarning(Remain int) int {
return 0
}
func GetCatTrickType(Duartion int) int {
data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
func GetCatTrickEnergy() int {
data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "CatTrick_ConsumeEnergy")
if err != nil {
log.Debug("GetCatTrickType err:%v, Duartion=%d", err, Duartion)
return 1
log.Debug("GetCatTrickEnergy err:%v", err)
return 0
}
for k, v := range data {
D := gamedata.GetIntValue(v, "Duration")
if Duartion == D {
return GoUtil.Int(k)
}
}
return gamedata.GetIntValue(data, "Type")
return gamedata.GetIntValue(data, "Value")
}
func GetCatTrickDiamond(Type int) (int, int) {
data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_CAT_TRICK, Type)
func GetCatTrickDiamond() int {
data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "CatTrick_RewardDiamond")
if err != nil {
log.Debug("GetCatTrickDiamond err:%v, Type=%d", err, Type)
return 0, 0
log.Debug("GetCatTrickDiamond err:%v", err)
return 0
}
return gamedata.GetIntValue(data, "Diamond"), gamedata.GetIntValue(data, "Energy")
return gamedata.GetIntValue(data, "Value")
}
func GetDecorateOffDiscount(AreaId, StepId int) int {

1
src/server/conf/server.json
View File

@ -4,6 +4,7 @@
"LogPath": "./log",
"TCPAddr": ":3602",
"WSAddr": ":3567",
"RPCAddr": ":50051",
"MySqlAddr": "127.0.0.1",
"MySqlPort": "3306",
"MySqlUsr": "root",

6
src/server/db/Mysql.go
View File

@ -413,6 +413,12 @@ func GetServerMailData(data *[]*SqlServerMailStruct) error {
return err
}
func GetActivityData(data *[]*SqlActivityCfgStruct) error {
sql := "select `id`, `type`, `title`, `mail_title`, `mail_content`, `level_limit`, `start_time`, `end_time`, `cfg_buf`, `extra` from t_activity_mod"
err := SqlDb.Select(data, sql)
return err
}
func CreateOrderSn(Uid, ChargeId int, OrderSn, Platform, Channel string, Price float64, Currency, Extra string) error {
sql := "insert into t_player_charge (`Uid`,`OrderId`, `ProductId`, `Price`,`Currency`, `CreateTime`, `PayPlatform`, `PayChannel`, `PayChannelExtra`) Values (?,?,?,?,?,?,?,?,?)"
Now := GoUtil.Now()

13
src/server/db/SqlStruct.go
View File

@ -497,6 +497,19 @@ type SqlServerMailStruct struct {
CreateTime int64 `db:"create_time"`
}
type SqlActivityCfgStruct struct {
Id int `db:"id"`
Type int `db:"type"`
Title string `db:"title"`
MailTitle string `db:"mail_title"`
MailContent string `db:"mail_content"`
Level int `db:"level_limit"`
Start_time int64 `db:"start_time"`
End_time int64 `db:"end_time"`
Cfg []byte `db:"cfg_buf"`
Extra string `db:"extra"`
}
type SqlChargeOrderStruct struct {
Id int `db:"id"`
Uid int `db:"Uid"`

38
src/server/game/GameLogic.go
View File

@ -84,6 +84,7 @@ type GameLogic struct {
VarMgr *VarMgr // 变量管理器
StartTime int64 // 服务器启动时间
MessageMgr *MessageMgr // 消息管理器
ActivityMgr *ActivityMgr // 活动管理器
}
type ServerInfo struct {
@ -293,6 +294,12 @@ func (ad *GameLogic) CreateMailMgr() {
ad.MailMgr.Init()
}
// 活动管理器
func (ad *GameLogic) CreateActivityMgr() {
ad.ActivityMgr = &ActivityMgr{}
ad.ActivityMgr.Init()
}
func (ad *GameLogic) CreateMessageMgr() {
ad.MessageMgr = &MessageMgr{
ServerMod: new(ServerMod),
@ -478,6 +485,8 @@ func G_getGameLogic() *GameLogic {
// G_GameLogicPtr.CreateFriendMgr() //创建好友管理器
G_GameLogicPtr.CreateChampshipMgr() // 创建竞标赛管理器
G_GameLogicPtr.CreateVarMgr() // 创建变量管理器
} else {
G_GameLogicPtr.CreateActivityMgr() //创建活动管理器
}
G_GameLogicPtr.CreateRankMgr() //创建排行榜管理器
G_GameLogicPtr.CreateMailMgr() //创建邮件管理器
@ -646,19 +655,20 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
RegisterMsgProcessFunc("ReqAdWatch", ReqAdWatch) // 观看广告
// #region 棋盘
RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc) //设置能量倍数
RegisterMsgProcessFunc("ReqChessEx", ReqChessEx) // 转换棋子
RegisterMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff) // 从buff中获取棋子
RegisterMsgProcessFunc("ReqPutPartInBag", ReqPutPartInBag) // 把零件放入背包
RegisterMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag) // 把棋子放入背包
RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag) // 从背包中取出棋子
RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid) // 解锁背包格子
RegisterMsgProcessFunc("ReqSourceChest", ReqSourceChest) // 开宝箱
RegisterMsgProcessFunc("ReqSeparateChess", ReqSeparateChess) // 分解棋子
RegisterMsgProcessFunc("ReqUpgradeChess", ReqUpgradeChess) // 升级棋子
RegisterMsgProcessFunc("ReqSellChessNum", ReqSellChessNum) //购买能量
RegisterMsgProcessFunc("ReqGetChessRetireReward", ReqGetChessRetireReward) //领取棋子退役奖励
RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc) //设置能量倍数
RegisterMsgProcessFunc("ReqChessEx", ReqChessEx) // 转换棋子
RegisterMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff) // 从buff中获取棋子
RegisterMsgProcessFunc("ReqPutPartInBag", ReqPutPartInBag) // 把零件放入背包
RegisterMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag) // 把棋子放入背包
RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag) // 从背包中取出棋子
RegisterMsgProcessFunc("ReqTakeChessOutBagToHonor", ReqTakeChessOutBagToHonor) // 从背包中取出棋子
RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid) // 解锁背包格子
RegisterMsgProcessFunc("ReqSourceChest", ReqSourceChest) // 开宝箱
RegisterMsgProcessFunc("ReqSeparateChess", ReqSeparateChess) // 分解棋子
RegisterMsgProcessFunc("ReqUpgradeChess", ReqUpgradeChess) // 升级棋子
RegisterMsgProcessFunc("ReqSellChessNum", ReqSellChessNum) //购买能量
RegisterMsgProcessFunc("ReqGetChessRetireReward", ReqGetChessRetireReward) //领取棋子退役奖励
//领取图鉴奖励
RegisterMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励
@ -847,7 +857,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
RegisterMsgProcessFunc("ReqPlayroomGuide", ReqPlayroomGuide) // 展示游戏结果数据
RegisterMsgProcessFunc("ReqPetFur", ReqPetFur) // 宠物毛皮信息
RegisterMsgProcessFunc("ReqPetFurBuy", ReqPetFurBuy) // 宠物毛皮商店购买
RegisterMsgProcessFunc("ReqFurSet", ReqFurSet) //宠物毛皮设置
RegisterMsgProcessFunc("ReqFurSet", ReqFurSet) // 宠物毛皮设置
// 宠物宝藏
RegisterMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure) // 请求好友宝藏数据
RegisterMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始游戏

206
src/server/game/activity_func.go
View File

@ -23,7 +23,6 @@ import (
// 活动模块 登录
func (p *Player) ActivityLogin() {
ItemMod := p.PlayMod.getItemMod()
// 通用登录处理：检查旧Activity道具并通过邮件退还
handleSimpleLogin := func(actType int, loginFn func(int) int) {
ActivityId := p.GetActivityId(actType)
@ -58,10 +57,10 @@ func (p *Player) ActivityLogin() {
// 赛跑
handleSimpleLogin(activity.ACT_TYPE_RACE, p.PlayMod.getRaceMod().Login)
// 猫草大作战
CatnipActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
catnipActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
CatnipMod := p.PlayMod.getCatnipMod()
OldId, CatnipUnReward := CatnipMod.Login(CatnipActivityId)
if OldId != 0 && len(CatnipUnReward) > 0 {
oldId, catnipUnReward := CatnipMod.Login(catnipActivityId)
if oldId != 0 && len(catnipUnReward) > 0 {
// 清空猫草大作战数据无需发邮件
MailMod := p.PlayMod.getMailMod()
MailMod.SendMail(&mail.MailStruct{
@ -73,25 +72,24 @@ func (p *Player) ActivityLogin() {
ContentPtBr: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, "backend_gardenend_mail_content"),
TitleEsLatam: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_title"),
ContentEsLatam: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_content"),
Items: CatnipUnReward,
Items: catnipUnReward,
Type: mail.MAIL_TYPE_NORMAL,
})
}
// 通行证
PassActivityId := p.GetActivityId(activity.ACT_TYPE_PASS)
passActivityId := p.GetActivityId(activity.ACT_TYPE_PASS)
PassMod := p.PlayMod.getPassMod()
PassOldId := PassMod.Login(PassActivityId)
if PassOldId != 0 {
ItemId := passCfg.GetActivityItemId(PassOldId)
passOldId := PassMod.Login(passActivityId)
if passOldId != 0 {
ItemId := passCfg.GetActivityItemId(passOldId)
ItemNum := PassMod.Num
RewardItems, _ := PassMod.GetRewardItems()
if ItemNum != 0 {
ItemMod.AddItem(ItemId, -ItemNum)
p.SendActivityMail(ItemId, ItemNum, PassActivityId, RewardItems)
p.SendActivityMail(ItemId, ItemNum, passActivityId, RewardItems)
}
}
// 初始化活动道具
initItem := p.GetMiningMod().GetInitItem()
if len(initItem) > 0 {
@ -189,15 +187,15 @@ func (p *Player) GetActivityInfoById(Id int) *ActivityInfo {
// 获取活动状态
func (p *Player) GetActivityStatus(actType int) int {
ActivityInfo := p.GetActivityInfo(actType)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(actType)
if activityInfo == nil {
return ACT_STATUS_NOT_START
}
Now := GoUtil.Now()
if Now < ActivityInfo.StartT {
now := GoUtil.Now()
if now < activityInfo.StartT {
return ACT_STATUS_NOT_START
}
if Now > ActivityInfo.EndT {
if now > activityInfo.EndT {
return ACT_STATUS_END
}
return ACT_STATUS_START
@ -205,12 +203,12 @@ func (p *Player) GetActivityStatus(actType int) int {
// 挖矿活动数据返回
func (p *Player) MiningBackData() {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
if activityInfo == nil {
return
}
Status := p.GetActivityStatus(activity.ACT_TYPE_MINING)
Template := miningCfg.GetTemplate(ActivityInfo.Id)
status := p.GetActivityStatus(activity.ACT_TYPE_MINING)
template := miningCfg.GetTemplate(activityInfo.Id)
DecorateMod := p.PlayMod.getDecorateMod()
orderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
passRewardList := miningCfg.GetPassItemList(orderFactor)
@ -220,10 +218,10 @@ func (p *Player) MiningBackData() {
}
MiningMod := p.PlayMod.getMiningMod()
p.PushClientRes(&msg.ResMining{
Id: int32(ActivityInfo.Id),
Status: int32(Status),
EndTime: int32(ActivityInfo.EndT),
Template: int32(Template),
Id: int32(activityInfo.Id),
Status: int32(status),
EndTime: int32(activityInfo.EndT),
Template: int32(template),
Pass: int32(MiningMod.GetPass()),
Gem: GoUtil.IntToInt32(MiningMod.GetGem()),
Map: MiningMod.GetMap(),
@ -234,23 +232,23 @@ func (p *Player) MiningBackData() {
// 猜颜色活动数据返回
func (p *Player) GuessColorBackData() {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_GUESS_COLOR)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_GUESS_COLOR)
if activityInfo == nil {
return
}
Status := p.GetActivityStatus(activity.ACT_TYPE_GUESS_COLOR)
status := p.GetActivityStatus(activity.ACT_TYPE_GUESS_COLOR)
GuessColorMod := p.PlayMod.getGuessColorMod()
MapList := make([]*msg.GuessColorInfo, 0, len(GuessColorMod.MapList))
mapList := make([]*msg.GuessColorInfo, 0, len(GuessColorMod.MapList))
for _, v := range GuessColorMod.MapList {
MapList = append(MapList, &msg.GuessColorInfo{
mapList = append(mapList, &msg.GuessColorInfo{
Map: v,
})
}
p.PushClientRes(&msg.ResGuessColor{
Id: int32(ActivityInfo.Id),
Status: int32(Status),
EndTime: int32(ActivityInfo.EndT),
Id: int32(activityInfo.Id),
Status: int32(status),
EndTime: int32(activityInfo.EndT),
Pass: int32(GuessColorMod.Pass),
Opponent: &msg.Opponent{
Name: GuessColorMod.Opponent.Name,
@ -259,22 +257,22 @@ func (p *Player) GuessColorBackData() {
Progress: int32(GuessColorMod.Opponent.Progress),
},
WinTime: int32(GuessColorMod.WinTime),
MapList: MapList,
MapList: mapList,
OMap: GuessColorMod.OMap,
})
}
// 赛跑活动数据返回
func (p *Player) RaceBackData() {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_RACE)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_RACE)
if activityInfo == nil {
return
}
Status := p.GetActivityStatus(activity.ACT_TYPE_RACE)
status := p.GetActivityStatus(activity.ACT_TYPE_RACE)
RaceMod := p.PlayMod.getRaceMod()
Opponent := make([]*msg.Raceopponent, 0, len(RaceMod.Opponent))
opponent := make([]*msg.Raceopponent, 0, len(RaceMod.Opponent))
for _, v := range RaceMod.Opponent {
Opponent = append(Opponent, &msg.Raceopponent{
opponent = append(opponent, &msg.Raceopponent{
Id: int32(v.Id),
Name: v.Name,
Face: int32(v.Face),
@ -283,14 +281,14 @@ func (p *Player) RaceBackData() {
})
}
p.PushClientRes(&msg.ResRace{
Id: int32(ActivityInfo.Id),
Status: int32(Status),
EndTime: int32(ActivityInfo.EndT),
Id: int32(activityInfo.Id),
Status: int32(status),
EndTime: int32(activityInfo.EndT),
Pass: int32(RaceMod.Pass),
GameStartTime: int32(RaceMod.StartTime),
Progress: int32(RaceMod.Progress),
GameEndTime: int32(RaceMod.EndTime),
Opponent: Opponent,
Opponent: opponent,
Rank: int32(RaceMod.Rank),
})
}
@ -298,9 +296,9 @@ func (p *Player) RaceBackData() {
// 红点数据返回
func (p *Player) RedBackData() {
result := make(map[int32]int32)
Now := GoUtil.Now()
now := GoUtil.Now()
for _, v := range p.activity {
if v.StartT < Now && v.EndT > Now {
if v.StartT < now && v.EndT > now {
result[int32(v.Type)] = int32(p.GetRed(v))
}
}
@ -308,27 +306,27 @@ func (p *Player) RedBackData() {
}
func (p *Player) GetMiningItemId() int {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
if activityInfo == nil {
return 0
}
return miningCfg.GetActivityItemId(ActivityInfo.Id)
return miningCfg.GetActivityItemId(activityInfo.Id)
}
// 通行证活动数据返回
func (p *Player) ActPassBackData() {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
if activityInfo == nil {
return
}
Status := p.GetActivityStatus(activity.ACT_TYPE_PASS)
Template := passCfg.GetTemplate(ActivityInfo.Id)
status := p.GetActivityStatus(activity.ACT_TYPE_PASS)
template := passCfg.GetTemplate(activityInfo.Id)
PassMod := p.PlayMod.getPassMod()
p.PushClientRes(&msg.ResActPass{
Id: int32(ActivityInfo.Id),
Status: int32(Status),
Template: int32(Template),
EndTime: int32(ActivityInfo.EndT),
Id: int32(activityInfo.Id),
Status: int32(status),
Template: int32(template),
EndTime: int32(activityInfo.EndT),
LowPass: PassMod.LowPass > 0,
HighPass: PassMod.HighPass > 0,
Score: int32(PassMod.Num),
@ -338,57 +336,57 @@ func (p *Player) ActPassBackData() {
// 获取活动道具
func (p *Player) GetActivityItem(ActType []int) []*item.Item {
Items := make([]*item.Item, 0)
Now := GoUtil.Now()
items := make([]*item.Item, 0)
now := GoUtil.Now()
for _, v := range ActType {
ActivityInfo := p.GetActivityInfo(v)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(v)
if activityInfo == nil {
continue
}
Status := ACT_STATUS_START
if Now < ActivityInfo.StartT {
Status = ACT_STATUS_NOT_START
} else if Now > ActivityInfo.EndT {
Status = ACT_STATUS_END
status := ACT_STATUS_START
if now < activityInfo.StartT {
status = ACT_STATUS_NOT_START
} else if now > activityInfo.EndT {
status = ACT_STATUS_END
}
if Status != ACT_STATUS_START {
if status != ACT_STATUS_START {
continue
}
switch v {
case activity.ACT_TYPE_MINING:
Item := miningCfg.GetLoseItem(ActivityInfo.Id)
Items = item.Merge(Items, Item)
itemInfo := miningCfg.GetLoseItem(activityInfo.Id)
items = item.Merge(items, itemInfo)
case activity.ACT_TYPE_GUESS_COLOR:
Item := guesscolorCfg.GetLoseItem(ActivityInfo.Id)
Items = item.Merge(Items, Item)
itemInfo := guesscolorCfg.GetLoseItem(activityInfo.Id)
items = item.Merge(items, itemInfo)
case activity.ACT_TYPE_RACE:
ItemId := raceCfg.GetCoin(ActivityInfo.Id)
Item := item.NewItem(ItemId, 1)
Items = append(Items, Item)
itemId := raceCfg.GetCoin(activityInfo.Id)
itemInfo := item.NewItem(itemId, 1)
items = append(items, itemInfo)
case activity.ACT_TYPE_PASS:
ItemId := passCfg.GetActivityItemId(ActivityInfo.Id)
Item := item.NewItem(ItemId, 1)
Items = append(Items, Item)
itemId := passCfg.GetActivityItemId(activityInfo.Id)
itemInfo := item.NewItem(itemId, 1)
items = append(items, itemInfo)
}
}
return Items
return items
}
// 猫草大作战活动数据返回
func (p *Player) CatnipBackData() {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
if ActivityInfo == nil {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
if activityInfo == nil {
return
}
CatnipMod := p.PlayMod.getCatnipMod()
Status := p.GetActivityStatus(activity.ACT_TYPE_CATNIP)
status := p.GetActivityStatus(activity.ACT_TYPE_CATNIP)
if CatnipMod == nil {
return
}
FriendMod := p.PlayMod.getFriendMod()
GameList := make([]*msg.CatnipGame, 0, len(CatnipMod.Game))
gameList := make([]*msg.CatnipGame, 0, len(CatnipMod.Game))
for _, v := range CatnipMod.Game {
GameInfo := &msg.CatnipGame{
gameInfo := &msg.CatnipGame{
Id: int32(v.Id),
Progress: int32(v.Progress),
Status: int32(v.Status),
@ -398,13 +396,13 @@ func (p *Player) CatnipBackData() {
SendEmoji: int32(v.SendEmoji),
}
if v.Partner != 0 {
PlayerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
if PlayerData != nil {
GameInfo.Partner = PlayerData
playerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
if playerData != nil {
gameInfo.Partner = playerData
}
}
GameList = append(GameList, GameInfo)
gameList = append(gameList, gameInfo)
}
tmpData := make(map[int]*msg.CatnipInvite)
for uid, info := range CatnipMod.InviteList {
@ -443,24 +441,24 @@ func (p *Player) CatnipBackData() {
invite.Type = 4 // 已参与游戏的好友不显示邀请
}
}
InviteList := make([]*msg.CatnipInvite, 0, len(tmpData))
inviteList := make([]*msg.CatnipInvite, 0, len(tmpData))
for _, v := range tmpData {
ResPlayerSimple := G_getGameLogic().GetResSimplePlayerByUid(int(v.Uid))
if ResPlayerSimple != nil {
v.Player = ResPlayerSimple
resPlayerSimple := G_getGameLogic().GetResSimplePlayerByUid(int(v.Uid))
if resPlayerSimple != nil {
v.Player = resPlayerSimple
}
InviteList = append(InviteList, v)
inviteList = append(inviteList, v)
}
Template := catnipCfg.GetTemplateId(CatnipMod.Id)
template := catnipCfg.GetTemplateId(CatnipMod.Id)
res := &msg.ResCatnip{
Id: int32(CatnipMod.Id),
EndTime: int32(ActivityInfo.EndT),
Status: int32(Status),
Template: int32(Template),
GameList: GameList,
EndTime: int32(activityInfo.EndT),
Status: int32(status),
Template: int32(template),
GameList: gameList,
Multiply: int32(CatnipMod.Mul),
FriendList: InviteList,
FriendList: inviteList,
}
p.PushClientRes(res)
}
@ -468,9 +466,9 @@ func (p *Player) CatnipBackData() {
func (p *Player) GetChampshipActivityId() (int, int) {
var todayActivityId int
var yesterdayActivityId int
activiyCfgList := activityCfg.GetActivityListOrigin()
Now := GoUtil.Now()
YesterDay := GoUtil.ZeroTimestamp() - 1
activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
now := GoUtil.Now()
yesterday := GoUtil.ZeroTimestamp() - 1
level := p.GetBaseMod().GetLevel()
champshipActivityIds := champshipCfg.GetChampshipActivityId()
for _, v := range activiyCfgList {
@ -480,10 +478,10 @@ func (p *Player) GetChampshipActivityId() (int, int) {
if v.Level > level {
continue
}
if v.StartTime <= Now && v.EndTime >= Now {
if v.Startime <= now && v.Endtime >= now {
todayActivityId = v.Id
}
if v.StartTime <= YesterDay && v.EndTime >= YesterDay {
if v.Startime <= yesterday && v.Endtime >= yesterday {
yesterdayActivityId = v.Id
}
}
@ -492,8 +490,8 @@ func (p *Player) GetChampshipActivityId() (int, int) {
func (p *Player) GetDailyTaskActivityId() int {
var activityId int
activiyCfgList := activityCfg.GetActivityListOrigin()
Now := GoUtil.Now()
activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
now := GoUtil.Now()
level := p.GetBaseMod().GetLevel()
activityIds := dailyTaskCfg.GetActivityIds()
for _, v := range activiyCfgList {
@ -503,7 +501,7 @@ func (p *Player) GetDailyTaskActivityId() int {
if v.Level > level {
continue
}
if v.StartTime <= Now && v.EndTime >= Now {
if v.Startime <= now && v.Endtime >= now {
activityId = v.Id
break
}

92
src/server/game/activity_mgr.go
View File

@ -1,12 +1,19 @@
package game
import (
"fmt"
"server/db"
"server/game/mod/msg"
Msg "server/game/mod/msg"
protoMsg "server/msg"
"server/pkg/github.com/name5566/leaf/log"
"sync"
"google.golang.org/protobuf/proto"
)
type ActivityMgr struct {
*ServerMod
data *ActivityData
}
type ActivityData struct {
@ -17,29 +24,32 @@ type ActivityData struct {
type ActivityCfg struct {
Id int
Type int
Strartime int64
Startime int64
Endtime int64
Level int
Title string
MailTitle string
MailContent string
RewardItem map[string]interface{}
cfg interface{}
Extra map[string]interface{}
}
func (ac *ActivityCfg) String() string {
return fmt.Sprintf("Id: %d, Type: %d, StartTime: %d, EndTime: %d, Level: %d, Title: %s, MailTitle: %s, MailContent: %s, cfg: %v, Extra: %v",
ac.Id, ac.Type, ac.Startime, ac.Endtime, ac.Level, ac.Title, ac.MailTitle, ac.MailContent, ac.cfg, ac.Extra)
}
const ()
func (r *ActivityMgr) Init() {
r.key = RANK_MGR_KEY
r.data = &ActivityData{
List: make(map[int]*ActivityCfg, 0),
}
// 注册处理函数
r.init()
r.Reload()
}
func (r *ActivityMgr) getData() *ActivityData {
return r.data.(*ActivityData)
return r.data
}
// 零点更新 重置榜单
@ -47,7 +57,19 @@ func (r *ActivityMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
return nil, nil
}
func (r ActivityMgr) GetActivityCfg(Id int) ActivityCfg {
func (r *ActivityMgr) GetActivityList() []ActivityCfg {
// 获取活动列表
data := r.getData()
data.mu.Lock()
defer data.mu.Unlock()
list := make([]ActivityCfg, 0, len(data.List))
for _, v := range data.List {
list = append(list, *v)
}
return list
}
func (r *ActivityMgr) GetActivityCfg(Id int) ActivityCfg {
// 获取活动配置
data := r.getData()
data.mu.Lock()
@ -58,3 +80,57 @@ func (r ActivityMgr) GetActivityCfg(Id int) ActivityCfg {
}
return *cfg
}
func (r *ActivityMgr) Reload() error {
// 重新加载活动配置
// 从数据库加载邮件
log.Debug("reload activity data")
data := r.getData()
data.mu.Lock()
defer data.mu.Unlock()
cfgList := make([]*db.SqlActivityCfgStruct, 0)
err := db.GetActivityData(&cfgList)
if err != nil {
log.Error("LoadActivityData error: %v", err)
return err
}
data.List = make(map[int]*ActivityCfg, 0)
for _, v := range cfgList {
activityCfg, err := unmarshalActivityCfg(v.Type, []byte(v.Cfg))
if err != nil {
log.Error("Unmarshal activity cfg error: %v", err)
continue
}
cfg := &ActivityCfg{
Id: v.Id,
Type: v.Type,
Startime: v.Start_time,
Endtime: v.End_time,
Level: v.Level,
Title: v.Title,
MailTitle: v.MailTitle,
MailContent: v.MailContent,
cfg: activityCfg,
}
log.Debug("load activity cfg: %v", cfg)
data.List[v.Id] = cfg
}
G_GameLogicPtr.NotifyAll(&Msg.Msg{Type: Msg.HANDLE_TYPE_ACTIVITY_RELOAD})
return nil
}
func unmarshalActivityCfg(atype int, buf []byte) (interface{}, error) {
if len(buf) == 0 {
return nil, nil
}
switch atype {
case 1:
cfg := &protoMsg.MiningCfg{}
err := proto.Unmarshal(buf, cfg)
if err != nil {
return nil, err
}
return cfg, nil
}
return nil, nil
}

54
src/server/game/admin.go
View File

@ -30,14 +30,14 @@ var AdminFuncMap = map[string]func([]interface{}) error{
"ReqAdminShipping": ReqAdminShipping,
}
func AdminProcess(Func string, args []interface{}) {
func AdminProcess(funcName string, args []interface{}) {
defer func() {
if r := recover(); r != nil {
log.Error("uid : %d, func : %s, fatal : %s", 0, Func, r)
//GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", r))
log.Error("uid : %d, func : %s, fatal : %s", 0, funcName, r)
//GoUtil.SendFeishuFatal(0, funcName, fmt.Sprintf("fatal : %s", r))
}
}()
if f, ok := AdminFuncMap[Func]; ok {
if f, ok := AdminFuncMap[funcName]; ok {
err := f(args)
if err != nil {
log.Debug("AdminProcess error: %v", err)
@ -123,27 +123,27 @@ func ReqAdminShipping(args []interface{}) error {
proto.Unmarshal(buf, req)
res := make(map[string]interface{})
res["Code"] = 0
OrderInfo, err := db.GetPlayerChargeData(req.OrderSn)
orderInfo, err := db.GetPlayerChargeData(req.OrderSn)
if err != nil {
res["Code"] = 1
res["Msg"] = "order not found"
AdminPlayerBack(a, res)
}
if OrderInfo.PayStatus == MergeConst.ORDER_STATUS_SHIP {
if orderInfo.PayStatus == MergeConst.ORDER_STATUS_SHIP {
res["Msg"] = "order already shipped"
AdminPlayerBack(a, res)
}
Player := G_GameLogicPtr.GetPlayer(int64(OrderInfo.Uid))
if Player != nil {
go Player.TriggerShippingOrderOrigin(&msg.ReqShippingOrder{
player := G_GameLogicPtr.GetPlayer(int64(orderInfo.Uid))
if player != nil {
go player.TriggerShippingOrderOrigin(&msg.ReqShippingOrder{
OrderSn: req.OrderSn,
})
res["Msg"] = "player online,triggered sync"
AdminPlayerBack(a, res)
} else {
OrderInfo.PayStatus = MergeConst.ORDER_STATUS_PAY
OrderInfo.PayChannelOrderId = req.ChannelOrderSn
db.UpdatePlayerChargeData(OrderInfo)
orderInfo.PayStatus = MergeConst.ORDER_STATUS_PAY
orderInfo.PayChannelOrderId = req.ChannelOrderSn
db.UpdatePlayerChargeData(orderInfo)
}
return nil
}
@ -230,10 +230,10 @@ func AdminPlayerInfo(args []interface{}) error {
}
func AdminPlayerBack(a gate.Agent, res map[string]interface{}) {
JsonBuff, _ := json.Marshal(res)
jsonBuff, _ := json.Marshal(res)
response := &msg.AdminRes{}
response.Func = "admin"
response.Info = string(JsonBuff)
response.Info = string(jsonBuff)
a.WriteMsg(response)
}
@ -322,3 +322,29 @@ func ReqAdminBan(args []interface{}) error {
AdminPlayerBack(a, res)
return nil
}
func AcitivityCfgReload() {
G_GameLogicPtr.ActivityMgr.Reload()
}
func AdminShipping(req *msg.ReqOrderShipping) (*msg.ResOrderShipping, error) {
res := &msg.ResOrderShipping{}
res.Code = 0
orderInfo, err := db.GetPlayerChargeData(req.OrderSn)
if err != nil {
res.Code = 1
res.Msg = "order not found"
}
if orderInfo.PayStatus == MergeConst.ORDER_STATUS_SHIP {
res.Msg = "order already shipped"
}
// 玩家在线，通知发货
player := G_GameLogicPtr.GetPlayer(int64(orderInfo.Uid))
if player != nil {
go player.TriggerShippingOrderOrigin(&msg.ReqShippingOrder{
OrderSn: req.OrderSn,
})
res.Msg = "player online,triggered sync"
}
return res, nil
}

535
src/server/game/champship_mgr.go
View File

@ -94,15 +94,15 @@ func (c *ChampshipMgr) Init() {
}
// 注册处理函数
c.init()
Now := GoUtil.Now()
ZeroTime := GoUtil.ZeroTimestamp()
if c.getData().ZeroTime != ZeroTime {
now := GoUtil.Now()
zeroTime := GoUtil.ZeroTimestamp()
if c.getData().ZeroTime != zeroTime {
c.ZeroUpdate()
}
Remain := Now - ZeroTime
Remain1 := 1800 - Remain%1800
remain := now - zeroTime
remain1 := 1800 - remain%1800
c.mDispatr.AfterFunc(time.Duration(Remain1)*time.Second, func() { // 30分钟后重新分组
c.mDispatr.AfterFunc(time.Duration(remain1)*time.Second, func() { // 30分钟后重新分组
c.group(false)
})
@ -205,10 +205,10 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
ChampshipData := c.getData()
ChampshipData.mu.Lock()
defer ChampshipData.mu.Unlock()
Now := GoUtil.Now()
now := GoUtil.Now()
uids := make(map[int]struct{})
for k, v := range ChampshipData.Rank {
Notify := make(map[int]int)
notify := make(map[int]int)
for e, r := range v {
if r.Type == RANK_PLAYER_ROBOT {
AddScore := 0.0
@ -217,17 +217,17 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
continue
}
if Robot.Type == 2 && Robot.Time+60 < Now {
if Robot.Type == 2 && Robot.Time+60 < now {
AddScore = Robot.PerScore
Robot.Time = Now
Robot.Time = now
}
if Robot.Type == 3 && Robot.Time+1800 < Now {
if Robot.Type == 3 && Robot.Time+1800 < now {
AddScore = Robot.PerScore
Robot.Time = Now
Robot.Time = now
}
r.Score += AddScore
} else {
Notify[r.Uid] = e
notify[r.Uid] = e
}
}
sort.Slice(v, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
@ -242,14 +242,13 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
if r.Type == RANK_PLAYER_ROBOT {
continue
}
if Notify[r.Uid] != e {
if notify[r.Uid] != e {
c.SetRankCache(r.Uid)
uids[r.Uid] = struct{}{}
}
}
ChampshipData.Rank[k] = v
}
now := GoUtil.Now()
// 在锁外通知玩家，避免在持锁时启动 goroutine 访问可能被并发修改的数据
for uid := range uids {
go NotifyPlayer(uid, &msg.Msg{
@ -264,180 +263,180 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
return nil, nil
}
func (c *ChampshipMgr) GetPreRankMsg(Uid int) *proto.ResChampshipPreRank {
func (c *ChampshipMgr) GetPreRankMsg(uid int) *proto.ResChampshipPreRank {
ChampshipData := c.getData()
ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.PreGroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.PreGroupInfo[uid]
if groupId == 0 {
return &proto.ResChampshipPreRank{}
}
RankList, ok := ChampshipData.PreRank[GroupId]
RankList, ok := ChampshipData.PreRank[groupId]
if !ok {
return &proto.ResChampshipPreRank{}
}
MyRank := 0
MyScore := 0.0
myRank := 0
myScore := 0.0
RL := make(map[int32]*proto.ResPlayerRank, 0)
for k, v := range RankList {
if v.Uid == Uid {
MyRank = k + 1
MyScore = v.Score
if v.Uid == uid {
myRank = k + 1
myScore = v.Score
}
if v.Type == RANK_PLAYER_ROBOT {
Robot := ChampshipData.PreRobot[v.Uid]
if Robot == nil {
robot := ChampshipData.PreRobot[v.Uid]
if robot == nil {
continue
}
last := &proto.ActLog{}
if Robot.ActLog != nil {
if robot.ActLog != nil {
last = &proto.ActLog{
Type: int32(Robot.ActLog.Type),
Time: Robot.ActLog.Time,
Param: Robot.ActLog.Param,
Type: int32(robot.ActLog.Type),
Time: robot.ActLog.Time,
Param: robot.ActLog.Param,
}
}
RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid),
Score: float32(v.Score),
Name: Robot.Name,
Avatar: int32(Robot.Avatar),
Face: int32(Robot.Face),
Level: int32(Robot.Level),
Name: robot.Name,
Avatar: int32(robot.Avatar),
Face: int32(robot.Face),
Level: int32(robot.Level),
Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(Robot.Playroom),
DressSet: GoUtil.MapIntToInt32(Robot.DressSet),
FurSet: int32(Robot.FurSet),
PetName: Robot.PetName,
PlayroomSet: GoUtil.MapIntToInt32(robot.Playroom),
DressSet: GoUtil.MapIntToInt32(robot.DressSet),
FurSet: int32(robot.FurSet),
PetName: robot.PetName,
Last: last,
}
} else {
SimplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if SimplePlayer == nil {
simplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if simplePlayer == nil {
continue
}
last := &proto.ActLog{}
if SimplePlayer.ActLog != nil {
if simplePlayer.ActLog != nil {
last = &proto.ActLog{
Type: int32(SimplePlayer.ActLog.Type),
Time: SimplePlayer.ActLog.Time,
Param: SimplePlayer.ActLog.Param,
Type: int32(simplePlayer.ActLog.Type),
Time: simplePlayer.ActLog.Time,
Param: simplePlayer.ActLog.Param,
}
}
RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid),
Score: float32(v.Score),
Name: SimplePlayer.Name,
Avatar: int32(SimplePlayer.Avatar),
Face: int32(SimplePlayer.Face),
Level: int32(SimplePlayer.Level),
Name: simplePlayer.Name,
Avatar: int32(simplePlayer.Avatar),
Face: int32(simplePlayer.Face),
Level: int32(simplePlayer.Level),
Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(SimplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(SimplePlayer.DressSet),
FurSet: int32(SimplePlayer.PetFur),
PetName: SimplePlayer.PetName,
PlayroomSet: GoUtil.MapIntToInt32(simplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(simplePlayer.DressSet),
FurSet: int32(simplePlayer.PetFur),
PetName: simplePlayer.PetName,
Last: last,
}
}
}
return &proto.ResChampshipPreRank{
MyRank: int32(MyRank),
MyScore: float32(MyScore),
MyRank: int32(myRank),
MyScore: float32(myScore),
RankList: RL,
}
}
// TODO 待优化
func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank {
func (c *ChampshipMgr) GetRankMsg(uid int) *proto.ResChampshipRank {
ChampshipData := c.getData()
ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.GroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.GroupInfo[uid]
if groupId == 0 {
return &proto.ResChampshipRank{}
}
RankList, ok := ChampshipData.Rank[GroupId]
rankList, ok := ChampshipData.Rank[groupId]
if !ok {
return &proto.ResChampshipRank{}
}
MyRank := 0
MyScore := 0.0
myRank := 0
myScore := 0.0
RL := make(map[int32]*proto.ResPlayerRank, 0)
for k, v := range RankList {
if v.Uid == Uid {
MyRank = k + 1
MyScore = v.Score
for k, v := range rankList {
if v.Uid == uid {
myRank = k + 1
myScore = v.Score
}
if v.Type == RANK_PLAYER_ROBOT {
Robot := ChampshipData.Robot[v.Uid]
if Robot == nil {
robot := ChampshipData.Robot[v.Uid]
if robot == nil {
continue
}
last := &proto.ActLog{}
if Robot.ActLog != nil {
if robot.ActLog != nil {
last = &proto.ActLog{
Type: int32(Robot.ActLog.Type),
Time: Robot.ActLog.Time,
Param: Robot.ActLog.Param,
Type: int32(robot.ActLog.Type),
Time: robot.ActLog.Time,
Param: robot.ActLog.Param,
}
}
RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid),
Score: float32(v.Score),
Name: Robot.Name,
Avatar: int32(Robot.Avatar),
Face: int32(Robot.Face),
Level: int32(Robot.Level),
Name: robot.Name,
Avatar: int32(robot.Avatar),
Face: int32(robot.Face),
Level: int32(robot.Level),
Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(Robot.Playroom),
DressSet: GoUtil.MapIntToInt32(Robot.DressSet),
FurSet: int32(Robot.FurSet),
PetName: Robot.PetName,
PlayroomSet: GoUtil.MapIntToInt32(robot.Playroom),
DressSet: GoUtil.MapIntToInt32(robot.DressSet),
FurSet: int32(robot.FurSet),
PetName: robot.PetName,
Last: last,
}
} else {
SimplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if SimplePlayer == nil {
simplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if simplePlayer == nil {
continue
}
last := &proto.ActLog{}
if SimplePlayer.ActLog != nil {
if simplePlayer.ActLog != nil {
last = &proto.ActLog{
Type: int32(SimplePlayer.ActLog.Type),
Time: SimplePlayer.ActLog.Time,
Param: SimplePlayer.ActLog.Param,
Type: int32(simplePlayer.ActLog.Type),
Time: simplePlayer.ActLog.Time,
Param: simplePlayer.ActLog.Param,
}
}
RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid),
Score: float32(v.Score),
Name: SimplePlayer.Name,
Avatar: int32(SimplePlayer.Avatar),
Face: int32(SimplePlayer.Face),
Level: int32(SimplePlayer.Level),
Name: simplePlayer.Name,
Avatar: int32(simplePlayer.Avatar),
Face: int32(simplePlayer.Face),
Level: int32(simplePlayer.Level),
Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(SimplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(SimplePlayer.DressSet),
FurSet: int32(SimplePlayer.PetFur),
PetName: SimplePlayer.PetName,
PlayroomSet: GoUtil.MapIntToInt32(simplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(simplePlayer.DressSet),
FurSet: int32(simplePlayer.PetFur),
PetName: simplePlayer.PetName,
Last: last,
}
}
}
return &proto.ResChampshipRank{
MyRank: int32(MyRank),
MyScore: float32(MyScore),
MyRank: int32(myRank),
MyScore: float32(myScore),
RankList: RL,
}
}
// 分组
func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
Now := GoUtil.Now()
Zero := GoUtil.ZeroTimestamp()
if Now-Zero < 1800 && !iszero { // 0点30分钟内不分组
now := GoUtil.Now()
zero := GoUtil.ZeroTimestamp()
if now-zero < 1800 && !iszero { // 0点30分钟内不分组
return nil, nil
}
c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() { // 30分钟后重新分组
@ -496,35 +495,35 @@ func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
g[i] = g[i][:len(g[i])-remainder]
}
ChampshipData.AutoId++
StartId := ChampshipData.AutoId
startId := ChampshipData.AutoId
for j := 0; j < len(g[i]); j++ {
if len(ChampshipData.Rank[ChampshipData.AutoId]) >= 10 {
log.Error("championship error: more than 10 players in a group")
}
ChampshipData.GroupInfo[g[i][j]] = ChampshipData.AutoId
UserData := ChampshipData.Pool[g[i][j]]
userData := ChampshipData.Pool[g[i][j]]
ChampshipData.Rank[ChampshipData.AutoId] = append(ChampshipData.Rank[ChampshipData.AutoId], &ChampshipRank{
Uid: UserData.Uid,
Score: UserData.Score,
Time: UserData.Time,
Uid: userData.Uid,
Score: userData.Score,
Time: userData.Time,
})
//log.Debug("group AutoId:%d, Uid:%d, Score:%.2f, Time:%d", ChampshipData.AutoId, UserData.Uid, UserData.Score, UserData.Time)
//log.Debug("group AutoId:%d, Uid:%d, Score:%.2f, Time:%d", ChampshipData.AutoId, userData.Uid, userData.Score, userData.Time)
if len(ChampshipData.Rank[ChampshipData.AutoId]) >= 10 && j != len(g[i])-1 {
ChampshipData.AutoId++
}
}
for j := StartId; j <= ChampshipData.AutoId; j++ { // 填充机器人
for j := startId; j <= ChampshipData.AutoId; j++ { // 填充机器人
if len(ChampshipData.Rank[j]) >= 30 || len(ChampshipData.Rank[j]) == 0 {
log.Error("championship error: more than 30 players in a group or no player in a group")
continue
}
RobotNum := 30 - len(ChampshipData.Rank[j])
//log.Debug("group AutoId:%d, player num:%d, need robot num:%d", j, len(ChampshipData.Rank[j]), RobotNum)
RobotList := CreateRobotList(i, RobotNum, j)
for i := 0; i < RobotNum; i++ {
go FormatRobotInfo(RobotList[i], i+1, uids)
robotNum := 30 - len(ChampshipData.Rank[j])
//log.Debug("group AutoId:%d, player num:%d, need robot num:%d", j, len(ChampshipData.Rank[j]), robotNum)
robotList := CreateRobotList(i, robotNum, j)
for i := 0; i < robotNum; i++ {
go FormatRobotInfo(robotList[i], i+1, uids)
}
for _, v := range RobotList {
for _, v := range robotList {
ChampshipData.Robot[ChampshipData.RobotId] = v
ChampshipData.Rank[j] = append(ChampshipData.Rank[j], &ChampshipRank{
Uid: ChampshipData.RobotId,
@ -563,13 +562,13 @@ func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
// 获取分组ID
func (c *ChampshipMgr) getGroupId(Uid int) int {
func (c *ChampshipMgr) getGroupId(uid int) int {
ChampshipData := c.getData()
ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock()
GroupId, ok := ChampshipData.GroupInfo[Uid]
groupId, ok := ChampshipData.GroupInfo[uid]
if ok {
return GroupId
return groupId
}
return 0
}
@ -578,7 +577,7 @@ func (c *ChampshipMgr) getGroupId(Uid int) int {
func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
data := m.Extra.(CRank)
// 在加锁前获取 GroupId，避免在持有写锁时调用会获取读锁的 getGroupId 导致死锁
GroupId := c.getGroupId(data.Uid)
groupId := c.getGroupId(data.Uid)
ChampshipData := c.getData()
ChampshipData.mu.Lock()
@ -586,10 +585,10 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
// 再次检查 GroupId，因为可能在等待锁期间被其他协程修改
if currentGroupId, ok := ChampshipData.GroupInfo[data.Uid]; ok {
GroupId = currentGroupId
groupId = currentGroupId
}
if GroupId == 0 {
if groupId == 0 {
ChampshipData.Pool[data.Uid] = &GroupInfo{
Uid: data.Uid,
Score: data.Score,
@ -599,13 +598,13 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
}
return nil, nil
}
RankList, ok := ChampshipData.Rank[GroupId]
rankList, ok := ChampshipData.Rank[groupId]
if !ok {
ChampshipData.Rank[GroupId] = make([]*ChampshipRank, 0)
ChampshipData.Rank[groupId] = make([]*ChampshipRank, 0)
}
inRank := false
Notify := make(map[int]int)
for k, v := range RankList {
notify := make(map[int]int)
for k, v := range rankList {
if v.Uid == data.Uid {
if v.Score < data.Score {
v.Score = data.Score
@ -615,29 +614,29 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
}
return nil, nil
}
Notify[v.Uid] = k
notify[v.Uid] = k
}
if !inRank {
RankList = append(RankList, &ChampshipRank{
rankList = append(rankList, &ChampshipRank{
Uid: data.Uid,
Score: data.Score,
Time: GoUtil.Now(),
})
}
sort.Slice(RankList, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
if RankList[i].Score > RankList[j].Score {
sort.Slice(rankList, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
if rankList[i].Score > rankList[j].Score {
return true
} else if RankList[i].Score == RankList[j].Score {
return RankList[i].Time < RankList[j].Time
} else if rankList[i].Score == rankList[j].Score {
return rankList[i].Time < rankList[j].Time
}
return false
})
ChampshipData.Rank[GroupId] = RankList
ChampshipData.Rank[groupId] = rankList
// 收集需要通知的玩家
notifyList := make([]int, 0)
for k, v := range RankList {
if Notify[v.Uid] != k && v.Type != RANK_PLAYER_ROBOT {
for k, v := range rankList {
if notify[v.Uid] != k && v.Type != RANK_PLAYER_ROBOT {
c.SetRankCache(v.Uid)
notifyList = append(notifyList, v.Uid)
}
@ -653,75 +652,75 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
return nil, nil
}
func (c *ChampshipMgr) getMyRank(Uid int) int {
func (c *ChampshipMgr) getMyRank(uid int) int {
ChampshipData := c.getData()
ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.GroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.GroupInfo[uid]
if groupId == 0 {
return 0
}
RankList, ok := ChampshipData.Rank[GroupId]
rankList, ok := ChampshipData.Rank[groupId]
if !ok {
return 0
}
for k, v := range RankList {
if v.Uid == Uid {
for k, v := range rankList {
if v.Uid == uid {
return k + 1
}
}
return 0
}
func (c *ChampshipMgr) unsafe_getMyRank(Uid int) int {
func (c *ChampshipMgr) unsafe_getMyRank(uid int) int {
ChampshipData := c.getData()
GroupId := ChampshipData.GroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.GroupInfo[uid]
if groupId == 0 {
return 0
}
RankList, ok := ChampshipData.Rank[GroupId]
rankList, ok := ChampshipData.Rank[groupId]
if !ok {
return 0
}
for k, v := range RankList {
if v.Uid == Uid {
for k, v := range rankList {
if v.Uid == uid {
return k + 1
}
}
return 0
}
func (c *ChampshipMgr) getLastMyRank(Uid int) int {
func (c *ChampshipMgr) getLastMyRank(uid int) int {
ChampshipData := c.getData()
ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.PreGroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.PreGroupInfo[uid]
if groupId == 0 {
return 0
}
RankList, ok := ChampshipData.PreRank[GroupId]
rankList, ok := ChampshipData.PreRank[groupId]
if !ok {
return 0
}
for k, v := range RankList {
if v.Uid == Uid {
for k, v := range rankList {
if v.Uid == uid {
return k + 1
}
}
return 0
}
func (c *ChampshipMgr) unsafe_getLastMyRank(Uid int) int {
func (c *ChampshipMgr) unsafe_getLastMyRank(uid int) int {
ChampshipData := c.getData()
GroupId := ChampshipData.PreGroupInfo[Uid]
if GroupId == 0 {
groupId := ChampshipData.PreGroupInfo[uid]
if groupId == 0 {
return 0
}
RankList, ok := ChampshipData.PreRank[GroupId]
rankList, ok := ChampshipData.PreRank[groupId]
if !ok {
return 0
}
for k, v := range RankList {
if v.Uid == Uid {
for k, v := range rankList {
if v.Uid == uid {
return k + 1
}
}
@ -732,215 +731,215 @@ func (c *ChampshipMgr) getData() *ChampshipData {
return c.data.(*ChampshipData)
}
func CreateRobotList(G, Num, GroupId int) []*ChampshipRobot {
func CreateRobotList(G, num, groupId int) []*ChampshipRobot {
r := make([]*ChampshipRobot, 0)
switch G {
case 1:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
for i := 0; i < 6; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < 5; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 2:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
for i := 0; i < 6; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
n := Num - 10
n := num - 10
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 3:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
for i := 0; i < 6; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
n := Num - 10
n := num - 10
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.15); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 4:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
n := Num - 4
n := num - 4
for i := 0; i < int(float64(n)*0.35); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 5:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
n := Num - 3
n := num - 3
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
}
for i := 0; i < int(float64(n)*0.3); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.2); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 6:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
n := Num - 2
n := num - 2
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
}
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
}
for i := 0; i < int(float64(n)*0.3); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.25); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 7:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
n := Num - 1
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
n := num - 1
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
}
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
}
for i := 0; i < int(float64(n)*0.3); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.2); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
case 8, 9, 10, 11:
M10 := GoUtil.RandMap(map[int]int{0: 98, 1: 2})
if M10 == 1 {
r = append(r, CreateRobot(float64(GoUtil.RandNum(35131, 64980)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(35131, 64980)), groupId))
}
n := Num
n := num
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
}
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(7531, 12180)), groupId))
}
for i := 0; i < int(float64(n)*0.05); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), groupId))
}
for i := 0; i < int(float64(n)*0.1); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(2781, 4630)), groupId))
}
for i := 0; i < int(float64(n)*0.3); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(1731, 2780)), groupId))
}
for i := 0; i < int(float64(n)*0.15); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(581, 1730)), groupId))
}
for i := 0; i < int(float64(n)*0.2); i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(241, 580)), groupId))
}
Last := Num - len(r)
Last := num - len(r)
for i := 0; i < Last; i++ {
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), GroupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(20, 240)), groupId))
}
}
return r
}
func CreateRobot(M float64, GroupId int) *ChampshipRobot {
Type := GoUtil.RandMap(map[int]int{1: 25, 2: 50, 3: 25})
Score := M / 10
PerScore := 0.0
if Type == 2 {
PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/60)*100) / 100
Score = M / 10 * 0.66
func CreateRobot(M float64, groupId int) *ChampshipRobot {
rType := GoUtil.RandMap(map[int]int{1: 25, 2: 50, 3: 25})
score := M / 10
perScore := 0.0
if rType == 2 {
perScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/60)*100) / 100
score = M / 10 * 0.66
}
if Type == 3 {
PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/1800)*100) / 100
Score = 2
if rType == 3 {
perScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/1800)*100) / 100
score = 2
}
return &ChampshipRobot{
Max: M / 10,
Type: Type,
Type: rType,
Name: randnameCfg.GetRandName(),
PetName: randnameCfg.GetRandName(),
Avatar: avatarCfg.GetRandInitId(),
Face: faceCfg.GetRandInitId(),
Level: GoUtil.RandNum(1, 10),
GroupId: GroupId,
GroupId: groupId,
Time: GoUtil.Now(),
Score: Score,
PerScore: PerScore,
Score: score,
PerScore: perScore,
}
}
func FormatRobotInfo(Robot *ChampshipRobot, index int, uids []int) {
func FormatRobotInfo(robot *ChampshipRobot, index int, uids []int) {
x := int(len(uids)) / 30
if index > int(x) {
index = int(x)
@ -956,24 +955,24 @@ func FormatRobotInfo(Robot *ChampshipRobot, index int, uids []int) {
if playerSimpleData == nil {
return
}
Robot.Level = playerSimpleData.Level
Robot.Avatar = playerSimpleData.Avatar
Robot.Face = playerSimpleData.Face
Robot.Playroom = playerSimpleData.Playroom
Robot.DressSet = playerSimpleData.DressSet
Robot.FurSet = playerSimpleData.PetFur
Robot.ActLog = playerSimpleData.ActLog
Robot.PetName = playerSimpleData.PetName
robot.Level = playerSimpleData.Level
robot.Avatar = playerSimpleData.Avatar
robot.Face = playerSimpleData.Face
robot.Playroom = playerSimpleData.Playroom
robot.DressSet = playerSimpleData.DressSet
robot.FurSet = playerSimpleData.PetFur
robot.ActLog = playerSimpleData.ActLog
robot.PetName = playerSimpleData.PetName
}
func (c *ChampshipMgr) SetRankCache(Uid int) {
PreRank := c.unsafe_getLastMyRank(Uid)
Rank := c.unsafe_getMyRank(Uid)
PreGroupId := c.getData().PreGroupInfo[Uid]
GroupId := c.getData().GroupInfo[Uid]
key := fmt.Sprintf("champship_rank_cache_%d", Uid)
log.Debug("SetRankCache key:%s; data:%s", key, fmt.Sprintf("%d_%d_%d_%d", PreRank, Rank, PreGroupId, GroupId))
db.RedisSetKey(key, fmt.Sprintf("%d_%d_%d_%d", PreRank, Rank, PreGroupId, GroupId), time.Second*172800)
func (c *ChampshipMgr) SetRankCache(uid int) {
preRank := c.unsafe_getLastMyRank(uid)
rank := c.unsafe_getMyRank(uid)
preGroupId := c.getData().PreGroupInfo[uid]
groupId := c.getData().GroupInfo[uid]
key := fmt.Sprintf("champship_rank_cache_%d", uid)
log.Debug("SetRankCache key:%s; data:%s", key, fmt.Sprintf("%d_%d_%d_%d", preRank, rank, preGroupId, groupId))
db.RedisSetKey(key, fmt.Sprintf("%d_%d_%d_%d", preRank, rank, preGroupId, groupId), time.Second*172800)
}
func (c *ChampshipMgr) Debug() {
@ -1001,13 +1000,13 @@ func (c *ChampshipMgr) Debug() {
log.Debug("Debug player num:%d", i)
}
func GetRankCache(Uid int) (int, int, int, int) {
key := fmt.Sprintf("champship_rank_cache_%d", Uid)
func GetRankCache(uid int) (int, int, int, int) {
key := fmt.Sprintf("champship_rank_cache_%d", uid)
data, err := db.RedisGetKey(key)
if err != nil || data == "" {
return 0, 0, 0, 0
}
var PreRank, Rank, PreGroupId, GroupId int
fmt.Sscanf(data, "%d_%d_%d_%d", &PreRank, &Rank, &PreGroupId, &GroupId)
return PreRank, Rank, PreGroupId, GroupId
var preRank, rank, preGroupId, groupId int
fmt.Sscanf(data, "%d_%d_%d_%d", &preRank, &rank, &preGroupId, &groupId)
return preRank, rank, preGroupId, groupId
}

136
src/server/game/charge_func.go
View File

@ -22,14 +22,14 @@ import (
"time"
)
func (p *Player) Charge(ChargeId int) {
p.ChargeFire(ChargeId) // 充值
p.EndlessFire(ChargeId) // 无尽礼包
p.PiggyBankFire(ChargeId) // 猪猪银行
p.PlayroomFire(ChargeId) // 游乐场
p.ActivityFire(ChargeId) // 活动礼包
p.ADPetWorkFire(ChargeId) // 广告宠物工作
p.PassFire(ChargeId)
func (p *Player) Charge(chargeId int) {
p.ChargeFire(chargeId) // 充值
p.EndlessFire(chargeId) // 无尽礼包
p.PiggyBankFire(chargeId) // 猪猪银行
p.PlayroomFire(chargeId) // 游乐场
p.ActivityFire(chargeId) // 活动礼包
p.ADPetWorkFire(chargeId) // 广告宠物工作
p.PassFire(chargeId)
OrderMod := p.PlayMod.getOrderMod()
OrderMod.SetIsCharge() // 设置订单模块为充值状态
p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_PURCHASE, A: []interface{}{}})
@ -45,9 +45,9 @@ func (p *Player) SendCharge(d *ChargeExtra) {
})
}
func (p *Player) ADPetWorkFire(ChargeId int) {
func (p *Player) ADPetWorkFire(chargeId int) {
ChargeMod := p.PlayMod.getChargeMod()
items := ChargeMod.FireAdReward(ChargeId)
items := ChargeMod.FireAdReward(chargeId)
if items != nil {
err := p.HandleItem(items, proto.ITEM_POP_LABEL_ActivityGift.String())
if err != nil {
@ -96,27 +96,27 @@ func (p *Player) ActivityFire(chargeId int) {
p.BackDataActivity()
}
func (p *Player) PassFire(ChargeId int) {
ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
if ActivityInfo == nil {
func (p *Player) PassFire(chargeId int) {
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
if activityInfo == nil {
return
}
Now := GoUtil.Now()
if Now < ActivityInfo.StartT || Now > ActivityInfo.EndT {
now := GoUtil.Now()
if now < activityInfo.StartT || now > activityInfo.EndT {
return
}
PassMod := p.PlayMod.getPassMod()
var Items []*item.Item
switch ChargeId {
case passCfg.GetLowChargeId(ActivityInfo.Id):
Items = PassMod.GetLowChargeItems()
case passCfg.GetHighChargeId(ActivityInfo.Id):
Items = PassMod.GetHighChargeItems()
var items []*item.Item
switch chargeId {
case passCfg.GetLowChargeId(activityInfo.Id):
items = PassMod.GetLowChargeItems()
case passCfg.GetHighChargeId(activityInfo.Id):
items = PassMod.GetHighChargeItems()
}
if len(Items) == 0 {
if len(items) == 0 {
return
}
err := p.HandleItem(Items, proto.ITEM_POP_LABEL_PassCharge.String())
err := p.HandleItem(items, proto.ITEM_POP_LABEL_PassCharge.String())
if err != nil {
log.Debug("PassFire err : %s", err)
return
@ -124,13 +124,13 @@ func (p *Player) PassFire(ChargeId int) {
p.PlayMod.save()
}
func (p *Player) PlayroomFire(ChargeId int) {
func (p *Player) PlayroomFire(chargeId int) {
PlayroomMod := p.PlayMod.getPlayroomMod()
Item := PlayroomMod.Fire(ChargeId)
if Item == nil {
items := PlayroomMod.Fire(chargeId)
if items == nil {
return
}
err := p.HandleItem(Item, proto.ITEM_POP_LABEL_Playroom.String())
err := p.HandleItem(items, proto.ITEM_POP_LABEL_Playroom.String())
if err != nil {
log.Debug("PlayroomFire err : %s", err)
}
@ -140,34 +140,34 @@ func (p *Player) PlayroomFire(ChargeId int) {
p.PlayMod.save()
}
func (p *Player) PiggyBankFire(ChargeId int) {
func (p *Player) PiggyBankFire(chargeId int) {
PiggyBankMod := p.PlayMod.getPiggyBankMod()
Item := PiggyBankMod.Fire(ChargeId)
if Item == nil {
items := PiggyBankMod.Fire(chargeId)
if items == nil {
return
}
err := p.HandleItem(Item, proto.ITEM_POP_LABEL_PiggyBank.String())
err := p.HandleItem(items, proto.ITEM_POP_LABEL_PiggyBank.String())
if err != nil {
log.Debug("PiggyBankFire err : %s", err)
}
p.LimitedTimePiggyBankTrigger()
p.TeLog("piggy_bank_open", map[string]interface{}{
"piggy_bank_type": piggyBank.PIGGY_BANK_TYPE_CHARGE,
"item_list": Item,
"open_cost": ChargeId,
"item_list": items,
"open_cost": chargeId,
})
p.PlayMod.save()
}
// 处理玩家充值
func (p *Player) ChargeFire(ChargeId int) {
func (p *Player) ChargeFire(chargeId int) {
ChargeMod := p.PlayMod.getChargeMod()
Item := ChargeMod.Fire(ChargeId)
if Item == nil {
items := ChargeMod.Fire(chargeId)
if items == nil {
return
}
err := p.HandleItem(Item, proto.ITEM_POP_LABEL_Charge.String())
err := p.HandleItem(items, proto.ITEM_POP_LABEL_Charge.String())
if err != nil {
log.Debug("ChargeFire err : %s", err)
}
@ -175,20 +175,20 @@ func (p *Player) ChargeFire(ChargeId int) {
p.ChargeBackData()
}
func (p *Player) ChargeItem(ChargeId int) []*item.Item {
func (p *Player) ChargeItem(chargeId int) []*item.Item {
ChargeMod := p.PlayMod.getChargeMod()
Item := ChargeMod.Fire(ChargeId)
return Item
items := ChargeMod.Fire(chargeId)
return items
}
// 处理无尽礼包充值
func (p *Player) EndlessFire(ChargeId int) {
func (p *Player) EndlessFire(chargeId int) {
EndlessMod := p.PlayMod.getEndlessMod()
Item := EndlessMod.Fire(ChargeId)
if Item == nil {
items := EndlessMod.Fire(chargeId)
if items == nil {
return
}
err := p.HandleItem(Item, proto.ITEM_POP_LABEL_Endless.String())
err := p.HandleItem(items, proto.ITEM_POP_LABEL_Endless.String())
if err != nil {
log.Debug("EndlessFire err : %s", err)
}
@ -198,38 +198,38 @@ func (p *Player) EndlessFire(ChargeId int) {
// 创建订单
func (p *Player) CreateOrderSn(req *proto.ReqCreateOrderSn) (string, error) {
Uid := int(p.M_DwUin)
OrderSn := GoUtil.CreateOrderSn(Uid)
uid := int(p.M_DwUin)
orderSn := GoUtil.CreateOrderSn(uid)
Price, Currency := chargeCfg.GetChargeInfo(int(req.ChargeId))
Extra := &ChargeExtra{
price, currency := chargeCfg.GetChargeInfo(int(req.ChargeId))
extra := &ChargeExtra{
Type: int(req.Type),
Uid: req.Uid,
}
ExtraData, _ := json.Marshal(Extra)
err := db.CreateOrderSn(Uid, int(req.ChargeId), OrderSn, req.PlatForm, req.Channel, Price, Currency, string(ExtraData))
extraData, _ := json.Marshal(extra)
err := db.CreateOrderSn(uid, int(req.ChargeId), orderSn, req.PlatForm, req.Channel, price, currency, string(extraData))
if err != nil {
return "", err
}
return OrderSn, nil
return orderSn, nil
}
func (p *Player) GoogleVerify(OrderSn, ProduceId, Token string) (*db.SqlChargeOrderStruct, error) {
Order, err := db.GetPlayerChargeData(OrderSn)
func (p *Player) GoogleVerify(orderSn, produceId, token string) (*db.SqlChargeOrderStruct, error) {
order, err := db.GetPlayerChargeData(orderSn)
if err != nil {
return nil, err
}
if Order.PayStatus == MergeConst.ORDER_STATUS_SHIP {
if order.PayStatus == MergeConst.ORDER_STATUS_SHIP {
return nil, fmt.Errorf("订单已经发货")
}
if !conf.Server.GoogleVerify {
Order.PayStatus = MergeConst.ORDER_STATUS_PAY
return Order, nil
order.PayStatus = MergeConst.ORDER_STATUS_PAY
return order, nil
}
if Order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
if order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
return nil, fmt.Errorf("订单已经支付")
}
cmd := exec.Command(conf.Server.AppPath+"/script/verifyOrder", ProduceId, Token)
cmd := exec.Command(conf.Server.AppPath+"/script/verifyOrder", produceId, token)
// 获取命令的输出
output, err := cmd.Output()
@ -257,26 +257,26 @@ func (p *Player) GoogleVerify(OrderSn, ProduceId, Token string) (*db.SqlChargeOr
if err == nil {
return nil, fmt.Errorf("订单已支付发货 param: %v", r)
}
// if r.DeveloperPayload != OrderSn {
// if r.DeveloperPayload != orderSn {
// return nil, fmt.Errorf("订单号不匹配")
// }
if r.ConsumptionState != 1 {
return nil, fmt.Errorf("订单未消费")
}
Order.PayStatus = MergeConst.ORDER_STATUS_PAY
Order.PayChannelOrderId = r.OrderId
Order.PayTime = GoUtil.Now()
return Order, nil
order.PayStatus = MergeConst.ORDER_STATUS_PAY
order.PayChannelOrderId = r.OrderId
order.PayTime = GoUtil.Now()
return order, nil
}
func (p *Player) CancelOrder(OrderSn string) error {
Order, err := db.GetPlayerChargeData(OrderSn)
func (p *Player) CancelOrder(orderSn string) error {
order, err := db.GetPlayerChargeData(orderSn)
if err != nil {
return err
}
if Order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
if order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
return fmt.Errorf("订单已支付")
}
Order.PayStatus = MergeConst.ORDER_STATUS_CANCEL
return db.UpdatePlayerChargeData(Order)
order.PayStatus = MergeConst.ORDER_STATUS_CANCEL
return db.UpdatePlayerChargeData(order)
}

4
src/server/game/cluster_mgr.go
View File

@ -49,10 +49,10 @@ func champshipRankInfoHandler(m *msg.Msg) error {
}
func champshipMyRankHandler(m *msg.Msg) error {
MyRank := G_GameLogicPtr.ChampshipMgr.getMyRank(m.From)
myRank := G_GameLogicPtr.ChampshipMgr.getMyRank(m.From)
m.To = m.From
m.From = 0
m.Extra = MyRank
m.Extra = myRank
FriendMgrSend(m)
return nil
}

1
src/server/game/external.go
View File

@ -215,6 +215,7 @@ func HandleClientReq(args []interface{}) {
}
p.(*Player).Recover(backup) //还原Player的数据
}
backup.Reclaim() // 回收备份对象
p.(*Player).lock.Unlock() //解锁
}()
p.(*Player).args = make(map[string]interface{})

104
src/server/game/friend_func.go
View File

@ -11,16 +11,16 @@ import (
func (p *Player) GetVisitorPlayer() int {
PlayroomMod := p.PlayMod.getPlayroomMod()
VisitorList := PlayroomMod.GetVisitor() // 到访用户
TodayVisitedUsers := PlayroomMod.GetTodayVisitedUsers() // 今日已互动用户
visitorList := PlayroomMod.GetVisitor() // 到访用户
todayVisitedUsers := PlayroomMod.GetTodayVisitedUsers() // 今日已互动用户
FriendMod := p.PlayMod.getFriendMod()
type sortData struct {
Uid int
Time int64
}
PlayerList := make([]sortData, 0)
PlayerList2 := make([]sortData, 0)
Now := GoUtil.Now()
playerList := make([]sortData, 0)
playerList2 := make([]sortData, 0)
now := GoUtil.Now()
/**
排除当日玩家已对其发起过交互的用户
优先选择24小时内曾经与玩家进行过宠物交互的好友
@ -30,30 +30,30 @@ func (p *Player) GetVisitorPlayer() int {
若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
若不存在符合条件的用户，则依据以上用户推荐算法，选择一位随机推荐用户，并且在下次触发式订单完成时，不再排除已发起过交互的用户
*/
for k, v := range VisitorList {
if GoUtil.InArray(k, TodayVisitedUsers) {
for k, v := range visitorList {
if GoUtil.InArray(k, todayVisitedUsers) {
continue
}
if v.Time < Now-86400 {
if v.Time < now-86400 {
continue
}
if FriendMod.CheckFriend(k) {
PlayerList = append(PlayerList, sortData{k, v.Time})
playerList = append(playerList, sortData{k, v.Time})
} else {
PlayerList2 = append(PlayerList2, sortData{k, v.Time})
playerList2 = append(playerList2, sortData{k, v.Time})
}
}
if len(PlayerList) != 0 {
sort.Slice(PlayerList, func(i, j int) bool {
return PlayerList[i].Time > PlayerList[j].Time
if len(playerList) != 0 {
sort.Slice(playerList, func(i, j int) bool {
return playerList[i].Time > playerList[j].Time
})
return PlayerList[0].Uid
return playerList[0].Uid
}
if len(PlayerList2) != 0 {
sort.Slice(PlayerList2, func(i, j int) bool {
return PlayerList2[i].Time > PlayerList2[j].Time
if len(playerList2) != 0 {
sort.Slice(playerList2, func(i, j int) bool {
return playerList2[i].Time > playerList2[j].Time
})
return PlayerList2[0].Uid
return playerList2[0].Uid
}
// 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
var recentFriendUid int
@ -62,14 +62,14 @@ func (p *Player) GetVisitorPlayer() int {
if uid == int(p.M_DwUin) {
continue
}
if GoUtil.InArray(uid, TodayVisitedUsers) {
if GoUtil.InArray(uid, todayVisitedUsers) {
continue
}
ps := G_GameLogicPtr.GetSimplePlayerByUid(uid)
if ps == nil {
continue
}
if Now-ps.Loginout > 86400 { // 24小时内登录过
if now-ps.Loginout > 86400 { // 24小时内登录过
continue
}
if ps.Loginout > recentLoginTime {
@ -84,51 +84,51 @@ func (p *Player) GetVisitorPlayer() int {
if err != nil {
return 0
}
var PlayerList4 []int
for _, Uid := range uids {
if Uid == int(p.M_DwUin) {
var playerList4 []int
for _, uid := range uids {
if uid == int(p.M_DwUin) {
continue
}
if G_GameLogicPtr.GetSimplePlayerByUid(Uid) == nil {
if G_GameLogicPtr.GetSimplePlayerByUid(uid) == nil {
continue
}
PlayerList4 = append(PlayerList4, Uid)
playerList4 = append(playerList4, uid)
}
L := GoUtil.RandSliceNum(PlayerList4, 1)
if len(L) == 0 {
lastList := GoUtil.RandSliceNum(playerList4, 1)
if len(lastList) == 0 {
return 0
}
return L[0]
return lastList[0]
}
func GetRecommendPlayer(p *Player, Num int) []int {
func GetRecommendPlayer(p *Player, num int) []int {
uids, err := db.GetCommendPlayerFromDb(p.M_DwUin, GoUtil.Now()-259200, 4)
if err != nil {
log.Debug("GetCommendPlayerFromDb err:%v, uid=%d", err, p.M_DwUin)
return nil
}
PlayerList1 := make([]int, 0, len(uids))
playerList1 := make([]int, 0, len(uids))
FriendMod := p.PlayMod.getFriendMod()
for _, Uid := range uids {
if Uid == int(p.M_DwUin) {
for _, uid := range uids {
if uid == int(p.M_DwUin) {
continue
}
if FriendMod.CheckSendApply(Uid) {
if FriendMod.CheckSendApply(uid) {
continue
}
if FriendMod.CheckAddBefore(Uid) {
if FriendMod.CheckAddBefore(uid) {
continue
}
PlayerList1 = append(PlayerList1, Uid)
playerList1 = append(playerList1, uid)
}
// 按照时间门槛筛选用户
filterByTime := func(excludeSeconds int64) []int {
now := GoUtil.Now()
result := make([]int, 0, len(PlayerList1))
for _, Uid := range PlayerList1 {
recommendTime := FriendMod.GetRecommendTime(Uid)
result := make([]int, 0, len(playerList1))
for _, uid := range playerList1 {
recommendTime := FriendMod.GetRecommendTime(uid)
if recommendTime == 0 || recommendTime <= now-excludeSeconds {
result = append(result, Uid)
result = append(result, uid)
}
}
return result
@ -145,16 +145,16 @@ func GetRecommendPlayer(p *Player, Num int) []int {
}
if len(candidateList) == 0 {
candidateList = append(candidateList, PlayerList1...)
candidateList = append(candidateList, playerList1...)
}
if len(candidateList) == 0 {
candidateList = make([]int, 0, len(uids))
for _, Uid := range uids {
if Uid == int(p.M_DwUin) {
for _, uid := range uids {
if uid == int(p.M_DwUin) {
continue
}
candidateList = append(candidateList, Uid)
candidateList = append(candidateList, uid)
}
}
levelFilterList := make([]*PlayerSimpleData, 0, len(candidateList))
@ -291,9 +291,9 @@ func GetRecommendPlayer(p *Player, Num int) []int {
return res
}
if diffLimit == 10 && len(chargeFilterList) >= 5 {
MaxCharge := p.GetChargeMod().GetMaxCharge()
if MaxCharge > 0 {
endFilterList = chargeFilterFunc(chargeFilterList, MaxCharge)
maxCharge := p.GetChargeMod().GetMaxCharge()
if maxCharge > 0 {
endFilterList = chargeFilterFunc(chargeFilterList, maxCharge)
} else {
if p.GetChargeMod().GetAdWatch() > 5 {
endFilterList = notChargeWatchAdFilterFunc(chargeFilterList)
@ -303,21 +303,21 @@ func GetRecommendPlayer(p *Player, Num int) []int {
}
}
recommendList := GoUtil.RandSliceNum(endFilterList, Num)
for _, Uid := range recommendList {
FriendMod.AddRecommend(Uid)
recommendList := GoUtil.RandSliceNum(endFilterList, num)
for _, uid := range recommendList {
FriendMod.AddRecommend(uid)
}
return recommendList
}
func GetUidByFaceBook(Fb string) (int, error) {
func GetUidByFaceBook(fb string) (int, error) {
sqlStr := "SELECT dwUin FROM t_player_baseinfo WHERE FaceBookId = ?"
type Result struct {
Uid int `db:"dwUin"`
}
R := Result{}
err := db.SqlDb.Get(&R, sqlStr, Fb)
log.Debug("Fb :%s;Uid :%d", Fb, R.Uid)
err := db.SqlDb.Get(&R, sqlStr, fb)
log.Debug("Fb :%s;Uid :%d", fb, R.Uid)
return R.Uid, err
}

11
src/server/game/gm_handler.go
View File

@ -665,6 +665,17 @@ func ReqGmCommand_(player *Player, Command string) error {
From: uid,
Extra: []int{2, 145},
})
case "debugBeckmarkMsg":
for i := 0; i < 1000000; i++ {
for j := 0; j < 10; j++ {
FriendMgrSend(&MsgMod.Msg{
Type: MsgMod.HANDLE_TYPE_APPLY,
SendT: GoUtil.ZeroTimestamp(),
To: 10000 + i,
From: 10000 + j,
})
}
}
case "debugLogoutMsg":
ToUid, _ := strconv.Atoi(arg[1])
uidList, err := db.GetDebugPlayer(ToUid)

180
src/server/game/limited_time_trigger.go
View File

@ -16,20 +16,20 @@ import (
)
// 限时事件触发器
func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
Lv := p.GetPlayerBaseMod().GetLevel()
EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(Lv)
func (p *Player) LimitedTimeEventTrigger(addEventId int) {
lv := p.GetPlayerBaseMod().GetLevel()
endTime, timeoutEvent, addEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(lv)
remainingTime := GoUtil.NextHourRemain()
if EndTime <= 0 {
EndTime = int(remainingTime)
if endTime <= 0 {
endTime = int(remainingTime)
} else {
EndTime = min(EndTime, int(remainingTime))
endTime = min(endTime, int(remainingTime))
}
if AddEventId != 0 {
AddEvent = append(AddEvent, AddEventId)
if addEventId != 0 {
addEvent = append(addEvent, addEventId)
}
if EndTime > 0 {
p.CallEvent(time.Duration(EndTime)*time.Second, func() {
if endTime > 0 {
p.CallEvent(time.Duration(endTime)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
p.LimitedTimeEventTrigger(0)
@ -37,7 +37,7 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
}, "LimitedTimeEvent")
}
for _, v := range TimeoutEvent { // 事件到期处理
for _, v := range timeoutEvent { // 事件到期处理
p.PushClientRes(&msg.LimitEventNotify{
Id: int32(v),
Type: limitedTimeEvent.EVENT_NOTIFY_TYPE_DEL,
@ -45,15 +45,15 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
switch v {
case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
BaseMod := p.PlayMod.getBaseMod()
EnergyMul := BaseMod.GetEnergyMul()
energyMul := BaseMod.GetEnergyMul()
OrderMod := p.PlayMod.getOrderMod()
Emit := p.PlayMod.getChessMod().GetOrderEmit()
ChessList := p.PlayMod.getChessMod().GetUnlockChessList()
OrderMod.ChangeEnergyMul(Lv, Emit, EnergyMul, ChessList)
emit := p.PlayMod.getChessMod().GetOrderEmit()
chessList := p.PlayMod.getChessMod().GetUnlockChessList()
OrderMod.ChangeEnergyMul(lv, emit, energyMul, chessList)
p.PushClientRes(OrderMod.BackData())
p.TeLog("mutil_merge_change", map[string]interface{}{
"change_from": math.Pow(2, float64(EnergyMul)),
"change_to": math.Pow(2, float64(EnergyMul)),
"change_from": math.Pow(2, float64(energyMul)),
"change_to": math.Pow(2, float64(energyMul)),
"is_auto": true,
})
p.PushClientRes(p.PlayMod.getBaseMod().BackData())
@ -68,13 +68,13 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
}
}
for _, v := range AddEvent { // 增加事件处理
for _, v := range addEvent { // 增加事件处理
switch v {
case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
Emit := p.PlayMod.getChessMod().GetOrderEmit()
Lv := p.GetPlayerBaseMod().GetLevel()
EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit, EnergyMul)
emit := p.PlayMod.getChessMod().GetOrderEmit()
lv := p.GetPlayerBaseMod().GetLevel()
energyMul := p.PlayMod.getBaseMod().GetEnergyMul()
p.PlayMod.getOrderMod().CreateSuperOrder(lv, emit, energyMul)
p.PushClientRes(p.PlayMod.getOrderMod().BackData())
case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
p.PlayMod.getCardMod().CreateCardFestival()
@ -95,9 +95,9 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
// 限时猪猪存钱罐触发器
func (p *Player) LimitedTimePiggyBankTrigger() {
Remain := p.PlayMod.getPiggyBankMod().TimeOut()
if Remain > 0 {
p.CallEvent(time.Duration(Remain)*time.Second, func() {
remain := p.PlayMod.getPiggyBankMod().TimeOut()
if remain > 0 {
p.CallEvent(time.Duration(remain)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
p.LimitedTimePiggyBankTrigger()
@ -111,10 +111,10 @@ func (p *Player) LimitedTimePiggyBankTrigger() {
func (p *Player) LimitedTimeCardTrigger() {
FriendMod := p.PlayMod.getFriendMod()
CardMod := p.PlayMod.getCardMod()
Now := GoUtil.Now()
var EndTime int64
now := GoUtil.Now()
var endTime int64
for k, v := range FriendMod.Card {
if v.EndTime > 0 && v.EndTime <= Now {
if v.EndTime > 0 && v.EndTime <= now {
switch v.Status {
case card.STATUS_CARD_EX_1:
delete(FriendMod.Card, k)
@ -137,12 +137,12 @@ func (p *Player) LimitedTimeCardTrigger() {
}
continue
}
if v.EndTime > 0 && (EndTime == 0 || v.EndTime < EndTime) {
EndTime = v.EndTime
if v.EndTime > 0 && (endTime == 0 || v.EndTime < endTime) {
endTime = v.EndTime
}
}
if EndTime > 0 {
p.CallEvent(time.Duration(EndTime-Now)*time.Second, func() {
if endTime > 0 {
p.CallEvent(time.Duration(endTime-now)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
p.LimitedTimeCardTrigger()
@ -159,58 +159,58 @@ func (p *Player) LimitedTimePlayroomTrigger() {
}
}
func (p *Player) LimitedTimePlayroomTrigger_(Id int) {
func (p *Player) LimitedTimePlayroomTrigger_(id int) {
PlayroomMod := p.PlayMod.getPlayroomMod()
Physiology := PlayroomMod.GetPhysiology(Id)
if Physiology == nil {
physiology := PlayroomMod.GetPhysiology(id)
if physiology == nil {
return
}
NewTime, NextSecond, Num := PlayroomTrigger(Physiology.Id, Physiology.Time, Physiology.Num)
Physiology.Time = NewTime
DiffValue := Physiology.Num - Num
MType, MEffect := playroomCfg.GetMoodEffect(Physiology.Id)
CleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN)
PlayroomMod.AddMood(MType, -MEffect*DiffValue)
newTime, nextSecond, num := PlayroomTrigger(physiology.Id, physiology.Time, physiology.Num)
physiology.Time = newTime
diffValue := physiology.Num - num
mType, mEffect := playroomCfg.GetMoodEffect(physiology.Id)
cleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN)
PlayroomMod.AddMood(mType, -mEffect*diffValue)
// 上厕所数值为0 且清洁度大于50时，清洁度降至50
if CleanMood != nil && Id == playroom.PHYSIOLOGY_TYPE_TOLIET && Num == 0 && CleanMood.Num > 50 {
CleanMood.Num = 50
if cleanMood != nil && id == playroom.PHYSIOLOGY_TYPE_TOLIET && num == 0 && cleanMood.Num > 50 {
cleanMood.Num = 50
}
Physiology.Num = Num
if PlayroomMod.GetMoodInfo(MType).Num == 0 { // 心情值为0时，重置生理状态
PlayroomMod.ResetPhysiology(MType)
NewTime = 0
physiology.Num = num
if PlayroomMod.GetMoodInfo(mType).Num == 0 { // 心情值为0时，重置生理状态
PlayroomMod.ResetPhysiology(mType)
newTime = 0
}
p.PlayMod.save()
ResNotifyMood := PlayroomMod.NotifyMood()
p.PushClientRes(ResNotifyMood)
if NextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
if nextSecond > 0 {
p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
p.LimitedTimePlayroomTrigger_(Id)
p.LimitedTimePlayroomTrigger_(id)
p.SendClientRes()
}, fmt.Sprintf("Playroom_%d", Id))
}, fmt.Sprintf("Playroom_%d", id))
}
}
func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
if Num == 0 {
func PlayroomTrigger(id int, time int64, num int) (int64, int64, int) {
if num == 0 {
return 0, 0, 0
}
Now := GoUtil.Now()
NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
if Time+int64(NeedDuration) > Now {
return Time, int64(NeedDuration), Num
now := GoUtil.Now()
needDuration := playroomCfg.GetPhysiologyDuration(id, num)
if time+int64(needDuration) > now {
return time, int64(needDuration), num
}
n := 0
for n <= 100 {
Num--
NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
Time += int64(NeedDuration)
if Time >= Now {
return Now, int64(NeedDuration), Num
num--
needDuration := playroomCfg.GetPhysiologyDuration(id, num)
time += int64(needDuration)
if time >= now {
return now, int64(needDuration), num
}
if Num == 0 {
if num == 0 {
return 0, 0, 0
}
n++
@ -220,18 +220,18 @@ func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
func LimitedTimePlayroomWorkTrigger(p *Player) {
PlayroomMod := p.PlayMod.getPlayroomMod()
EndTime := PlayroomMod.Endtime
Now := GoUtil.Now()
if EndTime > 0 && EndTime <= Now {
endTime := PlayroomMod.Endtime
now := GoUtil.Now()
if endTime > 0 && endTime <= now {
PlayroomMod.ResetWork()
p.PlayMod.save()
p.PlayroomBackData()
p.SendClientRes()
return
}
NextSecond := EndTime - Now
if NextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
nextSecond := endTime - now
if nextSecond > 0 {
p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
LimitedTimePlayroomWorkTrigger(p)
@ -245,50 +245,50 @@ func LimitedTimeEnergyAdd(p *Player) {
PlayerBaseMod := p.GetPlayerBaseMod()
BaseMod := p.PlayMod.getBaseMod()
delta := curtime - BaseMod.GetRecoverTime()
Recover := userCfg.GetRecover(BaseMod.GetLevel())
if Recover <= 0 {
recover := userCfg.GetRecover(BaseMod.GetLevel())
if recover <= 0 {
return
}
Addsta := int(delta) / Recover
if Addsta <= 0 {
addsta := int(delta) / recover
if addsta <= 0 {
return
}
Energy := BaseMod.GetEnergy()
MaxEnergy := PlayerBaseMod.GetMaxEnergy()
if MaxEnergy > Energy {
E := MaxEnergy - Energy
Energy += Addsta
if Energy > MaxEnergy {
Energy = MaxEnergy
energy := BaseMod.GetEnergy()
maxEnergy := PlayerBaseMod.GetMaxEnergy()
if maxEnergy > energy {
e := maxEnergy - energy
energy += addsta
if energy > maxEnergy {
energy = maxEnergy
}
p.TeLog("asset_change", map[string]interface{}{
"item_id": item.ITEM_ENERGY_ID,
"change_type": "gain",
"change_num": min(Addsta, E),
"change_after": Energy,
"change_num": min(addsta, e),
"change_after": energy,
"change_reason": "recover_server",
})
p.CallEvent(time.Duration(Recover)*time.Second, func() {
p.CallEvent(time.Duration(recover)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
LimitedTimeEnergyAdd(p)
}, "AddEnergy")
}
BaseMod.SetEnergy(Energy)
BaseMod.SetEnergy(energy)
BaseMod.SetRecoverTime(curtime)
p.SendErrClienRes(PlayerBaseMod.BackAsset())
}
func GuideTaskTrigger(p *Player) {
GuideTaskMod := p.PlayMod.getGuideTaskMod()
UnlockTime := GuideTaskMod.UnlockTime
if UnlockTime == 0 {
unlockTime := GuideTaskMod.UnlockTime
if unlockTime == 0 {
return
}
Now := GoUtil.Now()
NextSecond := 86400 - (Now-UnlockTime)%86400
if NextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
now := GoUtil.Now()
nextSecond := 86400 - (now-unlockTime)%86400
if nextSecond > 0 {
p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock()
defer p.lock.Unlock()
GuideTaskMod.Login()

20
src/server/game/mail_mgr.go
View File

@ -57,12 +57,12 @@ func (m *MailMgr) Init() {
}
func (m *MailMgr) AddMail(msg *msg.Msg) (interface{}, error) {
ServerMail, ok := msg.Extra.(*ServerMail)
serverMail, ok := msg.Extra.(*ServerMail)
if !ok {
log.Error("AddMail error: invalid mail data")
return nil, nil
}
m.list[ServerMail.Id] = ServerMail
m.list[serverMail.Id] = serverMail
return nil, nil
}
@ -76,10 +76,10 @@ func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
return nil, err
}
for _, v := range data {
Uids := make([]int, 0)
UidArr := strings.Split(v.To_uids, ",")
for _, v := range UidArr {
Uids = append(Uids, GoUtil.Int(v))
uids := make([]int, 0)
uidArr := strings.Split(v.To_uids, ",")
for _, v := range uidArr {
uids = append(uids, GoUtil.Int(v))
}
var items []interface{}
json.Unmarshal([]byte(v.Items), &items)
@ -99,7 +99,7 @@ func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
End_time: v.End_time,
Mail_type: v.Mail_type,
Send_type: v.Send_type,
To_uids: Uids,
To_uids: uids,
}
}
return nil, nil
@ -107,13 +107,13 @@ func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
func (r *MailMgr) Sync(Uid int, Register int64) []ServerMail {
// 同步邮件
Now := GoUtil.Now()
now := GoUtil.Now()
list := make([]ServerMail, 0)
for _, v := range r.list {
if v.Start_time > 0 && v.Start_time > Now {
if v.Start_time > 0 && v.Start_time > now {
continue
}
if v.End_time > 0 && v.End_time < Now {
if v.End_time > 0 && v.End_time < now {
continue
}
if v.Register_time > 0 && v.Register_time < Register {

845
src/server/game/message_handler.go
View File

File diff suppressed because it is too large Load Diff

8
src/server/game/mod/activity/activity_gift.go
View File

@ -7,16 +7,16 @@ import (
)
// 活动礼包
func (a *Activity) Fire(Id int, atype int) ([]*item.Item, error) {
// AId := activityCfg.GetActivityGiftId(Id)
func (a *Activity) Fire(id int, atype int) ([]*item.Item, error) {
// AId := activityCfg.GetActivityGiftId(id)
// Var := a.getGiftVar(AId)
// if Var.Buy {
// return nil, fmt.Errorf("Id%d已购买", Id)
// return nil, fmt.Errorf("Id%d已购买", id)
// }
// Var.Buy = true
// Var.Time = GoUtil.Now()
if atype == ACT_TYPE_ADD_GIFT {
a.AddEnd = GoUtil.Now() + 7*86400
}
return activityCfg.GetActivityGiftItems(Id), nil
return activityCfg.GetActivityGiftItems(id), nil
}

31
src/server/game/mod/avatar/Avatar.go
View File

@ -17,10 +17,10 @@ type Avatar struct {
AddTime int64
}
func (f *AvatarMod) Login(RegisterTime int64) {
func (f *AvatarMod) Login(registerTime int64) {
for k, v := range f.List {
if v.AddTime == 0 {
v.AddTime = RegisterTime
v.AddTime = registerTime
f.List[k] = v
}
}
@ -28,10 +28,9 @@ func (f *AvatarMod) Login(RegisterTime int64) {
func (a *AvatarMod) InitData() {
now := GoUtil.Now()
if a.List == nil {
a.List = make(map[int]*Avatar)
InitId := avatarCfg.GetInitList()
a.List = make(map[int]*Avatar, len(InitId))
for _, v := range InitId {
initId := avatarCfg.GetInitList()
a.List = make(map[int]*Avatar, len(initId))
for _, v := range initId {
a.List[v] = &Avatar{
AddTime: now,
}
@ -43,30 +42,30 @@ func (a *AvatarMod) GetAvatarNum() int {
return len(a.List)
}
func (a *AvatarMod) SetAvatar(Id int) error {
if _, ok := a.List[Id]; !ok {
return fmt.Errorf("avatar id:%d not exist", Id)
func (a *AvatarMod) SetAvatar(id int) error {
if _, ok := a.List[id]; !ok {
return fmt.Errorf("avatar id:%d not exist", id)
}
a.SetId = Id
a.SetId = id
return nil
}
func (a *AvatarMod) Unlock(Id, Time int) error {
v, ok := a.List[Id]
func (a *AvatarMod) Unlock(id, duration int) error {
v, ok := a.List[id]
if ok {
if v.Ts == 0 {
return nil
}
v.Ts += int64(Time)
v.Ts += int64(duration)
return nil
}
now := GoUtil.Now()
ts := int64(0)
if Time > 0 {
ts = now + int64(Time)
if duration > 0 {
ts = now + int64(duration)
}
a.List[Id] = &Avatar{
a.List[id] = &Avatar{
Ts: ts,
AddTime: now,
}

63
src/server/game/mod/base/Base.go
View File

@ -55,15 +55,15 @@ func (b *Base) InitData(Uid int, Ip string) {
b.CountryCode = code
}
if b.AddCode == "" && Ip != "" {
Code, _ := GoUtil.GetCountryByIP(Ip)
CountryCode := conf.Server.CountryCode
if CountryCode == "" {
CountryCode = "000"
code, _ := GoUtil.GetCountryByIP(Ip)
countryCode := conf.Server.CountryCode
if countryCode == "" {
countryCode = "000"
}
if Code != "" && len(Code) == 3 {
CountryCode = Code
if code != "" && len(code) == 3 {
countryCode = code
}
b.AddCode = fmt.Sprintf("MMM-%s-%s", CountryCode, GoUtil.UniqueStringFromInt(Uid))
b.AddCode = fmt.Sprintf("MMM-%s-%s", countryCode, GoUtil.UniqueStringFromInt(Uid))
}
if b.NickName == "" {
b.NickName = fmt.Sprintf("Player_%d", Uid)
@ -71,15 +71,15 @@ func (b *Base) InitData(Uid int, Ip string) {
}
func (b *Base) Login() int64 {
Now := GoUtil.Now()
if !GoUtil.IsSameDay(b.LoginTime, Now) {
now := GoUtil.Now()
if !GoUtil.IsSameDay(b.LoginTime, now) {
b.LoginDay += 1
}
logoutDuration := int64(0)
if b.LogoutTime != 0 {
logoutDuration = Now - b.LogoutTime
logoutDuration = now - b.LogoutTime
}
b.LoginTime = Now
b.LoginTime = now
b.LogoutTime = 0
return logoutDuration
}
@ -231,16 +231,16 @@ func (b *Base) SetLang(lang msg.LANG_TYPE) {
b.Lang = lang
}
func (b *Base) BuyEnergy(Energy int) ([]*item.Item, int, int) {
func (b *Base) BuyEnergy(energy int) ([]*item.Item, int, int) {
b.EnergyBuy += 1
Mul := baseCfg.GetEnergyByMul(b.EnergyBuy)
Diamond := int(float64(Energy) / Mul)
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -Diamond}, {Id: item.ITEM_ENERGY_ID, Num: Energy}}, Energy, Diamond
mul := baseCfg.GetEnergyByMul(b.EnergyBuy)
diamond := int(float64(energy) / mul)
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -diamond}, {Id: item.ITEM_ENERGY_ID, Num: energy}}, energy, diamond
}
// HighRoller 结束时重置能量倍数
func (b *Base) ResetEnergyMul(Mul int) {
b.EnergyMul = Mul
func (b *Base) ResetEnergyMul(mul int) {
b.EnergyMul = mul
}
func (b *Base) BackData() *msg.BaseInfo {
@ -259,10 +259,10 @@ func (b *Base) ZeroUpdate() {
b.TodayCumulative = 0
}
func (b *Base) Outline(Time int) {
func (b *Base) Outline(duration int) {
b.LogoutTime = GoUtil.Now()
b.TodayCumulative += Time
b.Cumulative += Time
b.TodayCumulative += duration
b.Cumulative += duration
}
func (b *Base) GetEnergyByAD() ([]*item.Item, error) {
@ -273,24 +273,7 @@ func (b *Base) GetEnergyByAD() ([]*item.Item, error) {
return baseCfg.GetEnergyByADNum(), nil
}
func (b *Base) FormatEnergyMul(Energy int) {
for {
if b.EnergyMul <= 0 {
b.EnergyMul = 0
return
}
EnergyLimit := baseCfg.GetLimitEnergyMul(b.Level)
if EnergyLimit == 0 {
return
}
if Energy > EnergyLimit {
return
}
b.EnergyMul--
}
}
func (b *Base) SetId2Verify(UserName, Num string) {
b.IdCardName = UserName
b.IdCardNum = Num
func (b *Base) SetId2Verify(userName, num string) {
b.IdCardName = userName
b.IdCardNum = num
}

250
src/server/game/mod/card/Card.go
View File

@ -118,10 +118,10 @@ func (c *CardMod) InitData() {
卡牌系统-登录：赛季结束则重置
*/
func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
Now := GoUtil.Now()
Duration := cardCfg.GetCardDuration()
HandbookItemNum := 0
if c.EndTime < Now {
now := GoUtil.Now()
duration := cardCfg.GetCardDuration()
handbookItemNum := 0
if c.EndTime < now {
c.CardList = make(map[int]int)
c.ExchangeStar = 0
c.CollectReward = make(map[int]struct{})
@ -132,57 +132,57 @@ func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
if v == HANDBOOK_STATUS_GET {
continue
}
Round := cardCfg.GetRoundById(k)
if Round < c.Round {
round := cardCfg.GetRoundById(k)
if round < c.Round {
continue
}
HandbookItemNum += cardCfg.GetStarById(k)
handbookItemNum += cardCfg.GetStarById(k)
}
c.Handbook = make(map[int]int)
}
if c.EndTime == 0 {
c.EndTime = ((Now-ServerOpenTime)/Duration+1)*Duration + ServerOpenTime
c.EndTime = ((now-ServerOpenTime)/duration+1)*duration + ServerOpenTime
}
return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: HandbookItemNum}}
return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: handbookItemNum}}
}
// 零点更新
func (c *CardMod) ZeroUpdate(ServerOpenTime int64) []*item.Item {
func (c *CardMod) ZeroUpdate(serverOpenTime int64) []*item.Item {
c.ReqTimes = cardCfg.GetReqTimes()
c.ExTimes = cardCfg.GetExTimes()
c.GoldTimes = 2
return c.Login(ServerOpenTime)
return c.Login(serverOpenTime)
}
// 增加卡牌
func (c *CardMod) AddCard(Id int) {
_, ok := c.CardList[Id]
func (c *CardMod) AddCard(id int) {
_, ok := c.CardList[id]
if ok {
star := cardCfg.GetStarById(Id)
star := cardCfg.GetStarById(id)
c.ExchangeStar += star
c.Cache.ExStar += star
c.CardList[Id]++
c.CardList[id]++
} else {
c.CardList[Id] = 1
c.CardList[id] = 1
}
_, ok = c.Handbook[Id]
_, ok = c.Handbook[id]
if !ok {
c.Handbook[Id] = HANDBOOK_STATUS_IDLE
c.Cache.Handbook[Id] = 1
c.Handbook[id] = HANDBOOK_STATUS_IDLE
c.Cache.Handbook[id] = 1
}
c.Cache.Card[Id]++
c.Cache.Card[id]++
}
// 开启卡包
func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
func (c *CardMod) OpenCardPack(star int) ([]int, error) {
cardId := 0
newCard := make([]int, 0)
cnt := cardCfg.GetPackRewardCnt(Star)
cnt := cardCfg.GetPackRewardCnt(star)
if cnt == 0 {
return newCard, fmt.Errorf("open star %d card pack cfg err cnt == 0", Star)
return newCard, fmt.Errorf("open star %d card pack cfg err cnt == 0", star)
}
mustHaveStar := cardCfg.GetPackMustHave(Star)
mustHaveStar := cardCfg.GetPackMustHave(star)
if mustHaveStar != 0 {
cardId = randCard(c.Round, mustHaveStar, 0, newCard)
if cardId == 0 {
@ -197,7 +197,7 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
Extra := max(1, int(total/2))
cnt += Extra
}
randList := cardCfg.GetRandListByStar(Star)
randList := cardCfg.GetRandListByStar(star)
for i := 0; i < cnt; i++ {
CardStar := GoUtil.RandMap(randList)
switch CardStar {
@ -222,10 +222,10 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
// cleanExpired 清理过期的请求和交换记录，返回有效 uid 列表
func (c *CardMod) cleanExpired() (reqUid, exUid []int64) {
Now := GoUtil.Now()
now := GoUtil.Now()
reqUid = make([]int64, 0, len(c.ReqFriend))
for k, v := range c.ReqFriend {
if v.EndTime < Now {
if v.EndTime < now {
delete(c.ReqFriend, k)
continue
}
@ -233,7 +233,7 @@ func (c *CardMod) cleanExpired() (reqUid, exUid []int64) {
}
exUid = make([]int64, 0, len(c.ExCard))
for k, v := range c.ExCard {
if v.EndTime < Now {
if v.EndTime < now {
delete(c.ExCard, k)
continue
}
@ -251,7 +251,7 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
}
cardList = append(cardList, &msg.Card{Id: int32(k), Count: int32(v)})
}
ReqUid, ExUid := c.cleanExpired()
reqUid, exUid := c.cleanExpired()
if c.EndTime < GoUtil.Now() {
log.Debug("CardMod BackData EndTime < Now, reset card data")
@ -265,8 +265,8 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
ExTimes: int32(c.ExTimes),
ReqTimes: int32(c.ReqTimes),
AllCard: GoUtil.MapIntToInt32(c.AllCard),
ReqUid: ReqUid,
ExUid: ExUid,
ReqUid: reqUid,
ExUid: exUid,
Round: int32(c.Round),
Handbook: GoUtil.MapIntToInt32(c.Handbook),
SeasonFirst: c.SeasonFirst,
@ -274,35 +274,35 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
}
// 领取卡牌收集奖励
func (c *CardMod) GetCollectReward(Id int) ([]*item.Item, int, error) {
_, ok := c.CollectReward[Id]
func (c *CardMod) GetCollectReward(id int) ([]*item.Item, int, error) {
_, ok := c.CollectReward[id]
if ok {
return nil, 0, fmt.Errorf("CollectReward id:%d already collect", Id)
return nil, 0, fmt.Errorf("CollectReward id:%d already collect", id)
}
cardList := cardCfg.GetCardListByColor(Id)
cardList := cardCfg.GetCardListByColor(id)
for _, v := range cardList {
count, ok := c.CardList[v]
if !ok || count <= 0 {
return nil, 0, fmt.Errorf("card not collect all ,id : %d", Id)
return nil, 0, fmt.Errorf("card not collect all ,id : %d", id)
}
}
c.CollectReward[Id] = struct{}{}
Item, Chess := cardCfg.GetCollectReward(Id)
c.CollectReward[id] = struct{}{}
Item, Chess := cardCfg.GetCollectReward(id)
return Item, Chess, nil
}
// 兑换星星奖励
func (c *CardMod) ExStarReward(Id int) ([]*item.Item, int, error) {
if c.ExchangeStar < Id {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", Id)
func (c *CardMod) ExStarReward(id int) ([]*item.Item, int, error) {
if c.ExchangeStar < id {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", id)
}
CostStar, itemList := cardCfg.GetExchangeCfg(Id)
if c.ExchangeStar < CostStar {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", Id)
costStar, items := cardCfg.GetExchangeCfg(id)
if c.ExchangeStar < costStar {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", id)
}
c.ExchangeStar -= CostStar
c.Cache.ExStar -= CostStar
return itemList, CostStar, nil
c.ExchangeStar -= costStar
c.Cache.ExStar -= costStar
return items, costStar, nil
}
// 领取全收集奖励
@ -310,8 +310,8 @@ func (c *CardMod) AllCollectReward() ([]*item.Item, []*item.Item, error) {
if c.AllCollect == 1 {
return nil, nil, fmt.Errorf("AllCollectReward already collect")
}
AllCardId := cardCfg.GetAllCardId(c.Round)
for _, v := range AllCardId {
allCardId := cardCfg.GetAllCardId(c.Round)
for _, v := range allCardId {
count, ok := c.CardList[v]
if !ok || count <= 0 {
return nil, nil, fmt.Errorf("card not fully collect for all collect reward, card id : %d", v)
@ -319,26 +319,26 @@ func (c *CardMod) AllCollectReward() ([]*item.Item, []*item.Item, error) {
}
c.AllCollect = 0
c.CollectReward = make(map[int]struct{})
ExStar := 0
exStar := 0
for k, v := range c.CardList {
star := cardCfg.GetStarById(k)
ExStar += star * (v - 1)
exStar += star * (v - 1)
c.CardList[k] = v - 1
}
c.CardList = make(map[int]int)
c.ExchangeStar += ExStar
c.Cache.ExStar += ExStar
Item := cardCfg.GetAllCollectReward()
HandbookItemNum := 0
c.ExchangeStar += exStar
c.Cache.ExStar += exStar
items := cardCfg.GetAllCollectReward()
handbookItemNum := 0
for k, v := range c.Handbook {
if v == HANDBOOK_STATUS_GET {
continue
}
HandbookItemNum += cardCfg.GetStarById(k)
handbookItemNum += cardCfg.GetStarById(k)
}
c.Round++
c.Handbook = make(map[int]int)
return Item, []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: HandbookItemNum}}, nil
return items, []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: handbookItemNum}}, nil
}
func (c *CardMod) ResetCardFestival() {
@ -353,8 +353,8 @@ func (c *CardMod) CreateCardFestival() {
c.CardLimit = true
}
func (c *CardMod) GetCardNum(Card int) int {
return c.CardList[Card]
func (c *CardMod) GetCardNum(card int) int {
return c.CardList[card]
}
func (c *CardMod) SubCard(id int) error {
@ -376,19 +376,19 @@ func (c *CardMod) RequestCard() error {
}
// 增加请求卡牌记录
func (c *CardMod) AddRequestCard(CardInfo *CardInfo) error {
_, ok := c.ReqFriend[CardInfo.BUid]
func (c *CardMod) AddRequestCard(cardInfo *CardInfo) error {
_, ok := c.ReqFriend[cardInfo.BUid]
if ok {
return fmt.Errorf("AddRequestCard already request card to this friend, BUid: %d", CardInfo.BUid)
return fmt.Errorf("AddRequestCard already request card to this friend, BUid: %d", cardInfo.BUid)
}
c.ReqFriend[CardInfo.BUid] = CardInfo
c.ReqFriend[cardInfo.BUid] = cardInfo
return nil
}
func (c *CardMod) DelRequestCard(Uid int) (map[int]*CardInfo, error) {
ci, ok := c.ReqFriend[Uid]
func (c *CardMod) DelRequestCard(uid int) (map[int]*CardInfo, error) {
ci, ok := c.ReqFriend[uid]
if !ok {
return nil, fmt.Errorf("DelRequestCard not find request card, Uid: %d", Uid)
return nil, fmt.Errorf("DelRequestCard not find request card, Uid: %d", uid)
}
r := make(map[int]*CardInfo)
for k, v := range c.ReqFriend {
@ -397,106 +397,106 @@ func (c *CardMod) DelRequestCard(Uid int) (map[int]*CardInfo, error) {
continue
}
}
delete(c.ReqFriend, Uid)
delete(c.ReqFriend, uid)
return r, nil
}
func (c *CardMod) AddReqTimes(Id string, Time int64) {
func (c *CardMod) AddReqTimes(id string, time int64) {
n := 0
for _, v := range c.ReqFriend {
if v.Id == Id {
if v.Id == id {
n++
}
}
Zero := GoUtil.ZeroTime(Time)
ZeroTime := GoUtil.ZeroTimestamp()
if n == 0 && Zero == ZeroTime {
zero := GoUtil.ZeroTime(time)
zeroTime := GoUtil.ZeroTimestamp()
if n == 0 && zero == zeroTime {
c.ReqTimes = min(cardCfg.GetReqTimes(), c.ReqTimes+1)
}
}
func (c *CardMod) AddExTimes(CardInfo *CardInfo) {
Zero := GoUtil.ZeroTime(CardInfo.StartTime)
ZeroTime := GoUtil.ZeroTimestamp()
if Zero == ZeroTime {
func (c *CardMod) AddExTimes(cardInfo *CardInfo) {
zero := GoUtil.ZeroTime(cardInfo.StartTime)
zeroTime := GoUtil.ZeroTimestamp()
if zero == zeroTime {
c.ExTimes++
c.ExTimes = min(cardCfg.GetExTimes(), c.ExTimes)
}
if cardCfg.CheckCardIsGold(CardInfo.CardId) {
if cardCfg.CheckCardIsGold(cardInfo.CardId) {
c.GoldTimes--
}
}
// 交换卡牌
func (c *CardMod) ExchangeCard(From, To, CardId int) (*CardInfo, error) {
func (c *CardMod) ExchangeCard(from, to, cardId int) (*CardInfo, error) {
if c.ExTimes <= 0 {
return nil, fmt.Errorf("ExchangeCard times not enough, CardId: %d", CardId)
return nil, fmt.Errorf("ExchangeCard times not enough, CardId: %d", cardId)
}
err := c.SubCard(CardId)
err := c.SubCard(cardId)
if err != nil {
return nil, err
}
c.ExTimes--
Now := GoUtil.Now()
Id := GoUtil.CreateCardId(From, To, CardId)
now := GoUtil.Now()
id := GoUtil.CreateCardId(from, to, cardId)
CardInfo := &CardInfo{
Id: Id,
AUid: From,
BUid: To,
CardId: CardId,
Id: id,
AUid: from,
BUid: to,
CardId: cardId,
Type: TYPE_CARD_EX,
Status: STATUS_CARD_EX_1,
StartTime: Now,
EndTime: Now + 86400,
StartTime: now,
EndTime: now + 86400,
}
c.ExCard[To] = CardInfo
c.ExCard[to] = CardInfo
return CardInfo, nil
}
func (c *CardMod) SendCard(From, To, CardId int) (*CardInfo, error) {
func (c *CardMod) SendCard(from, to, cardId int) (*CardInfo, error) {
if c.ExTimes <= 0 {
return nil, fmt.Errorf("SendCard times not enough, CardId: %d", CardId)
return nil, fmt.Errorf("SendCard times not enough, CardId: %d", cardId)
}
err := c.SubCard(CardId)
err := c.SubCard(cardId)
if err != nil {
return nil, err
}
c.ExTimes--
Now := GoUtil.Now()
Id := GoUtil.CreateCardId(From, To, CardId)
now := GoUtil.Now()
id := GoUtil.CreateCardId(from, to, cardId)
CardInfo := &CardInfo{
Id: Id,
AUid: From,
BUid: To,
CardId: CardId,
Id: id,
AUid: from,
BUid: to,
CardId: cardId,
Type: TYPE_CARD_SEND,
StartTime: Now,
StartTime: now,
Status: STATUS_CARD_SEND_1,
}
return CardInfo, nil
}
func (c *CardMod) DelExCard(CardInfo *CardInfo) {
delete(c.ExCard, CardInfo.BUid)
func (c *CardMod) DelExCard(cardInfo *CardInfo) {
delete(c.ExCard, cardInfo.BUid)
}
func (c *CardMod) AddMasterCard(Id int) {
c.Cache.Master[Id]++
c.AllCard[Id]++
func (c *CardMod) AddMasterCard(id int) {
c.Cache.Master[id]++
c.AllCard[id]++
}
func (c *CardMod) MasterCardEx(Id, CardId int) error {
if c.AllCard[Id] <= 0 {
return fmt.Errorf("MasterCardEx card not enough, Id: %d", Id)
func (c *CardMod) MasterCardEx(id, cardId int) error {
if c.AllCard[id] <= 0 {
return fmt.Errorf("MasterCardEx card not enough, Id: %d", id)
}
if Id == MASTER_CARD_NORMAL && cardCfg.CheckCardIsGold(CardId) {
return fmt.Errorf("MasterCardEx card type err, Id: %d, CardId: %d", Id, CardId)
if id == MASTER_CARD_NORMAL && cardCfg.CheckCardIsGold(cardId) {
return fmt.Errorf("MasterCardEx card type err, Id: %d, CardId: %d", id, cardId)
}
c.AllCard[Id]--
c.Cache.Master[Id]--
c.AddCard(CardId)
c.AllCard[id]--
c.Cache.Master[id]--
c.AddCard(cardId)
return nil
}
@ -517,12 +517,12 @@ func (c *CardMod) NotifyCard() *msg.ResNotifyCard {
}
func (c *CardMod) NotifyTimes() *msg.ResNotifyCardTimes {
ReqUid, ExUid := c.cleanExpired()
reqUid, exUid := c.cleanExpired()
return &msg.ResNotifyCardTimes{
ExTimes: int32(c.ExTimes),
ReqTimes: int32(c.ReqTimes),
ExUid: ExUid,
ReqUid: ReqUid,
ExUid: exUid,
ReqUid: reqUid,
GoldTimes: int32(c.GoldTimes),
}
}
@ -551,21 +551,21 @@ func (c *CardMod) AddGoldTimes() {
c.GoldTimes = min(2, c.GoldTimes)
}
func (c *CardMod) GetHandbookReward(CardId int) ([]*item.Item, error) {
if v, ok := c.Handbook[CardId]; ok {
func (c *CardMod) GetHandbookReward(cardId int) ([]*item.Item, error) {
if v, ok := c.Handbook[cardId]; ok {
if v == HANDBOOK_STATUS_GET {
return nil, fmt.Errorf("GetHandbookReward already get reward, CardId: %d", CardId)
return nil, fmt.Errorf("GetHandbookReward already get reward, CardId: %d", cardId)
}
Star := cardCfg.GetStarById(CardId)
c.Handbook[CardId] = HANDBOOK_STATUS_GET
c.Cache.Handbook[CardId] = HANDBOOK_STATUS_GET
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, Star)}, nil
star := cardCfg.GetStarById(cardId)
c.Handbook[cardId] = HANDBOOK_STATUS_GET
c.Cache.Handbook[cardId] = HANDBOOK_STATUS_GET
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, star)}, nil
}
return nil, fmt.Errorf("GetHandbookReward not find card in handbook, CardId: %d", CardId)
return nil, fmt.Errorf("GetHandbookReward not find card in handbook, CardId: %d", cardId)
}
func (c *CardMod) RandCard(Star int) int {
return randCard(c.Round, Star, 0, []int{})
func (c *CardMod) RandCard(star int) int {
return randCard(c.Round, star, 0, []int{})
}
func (c *CardMod) SeasonFirstReward() ([]*item.Item, error) {

12
src/server/game/mod/card/card_func.go
View File

@ -6,16 +6,16 @@ import (
)
// 随机卡牌
func randCard(Round, Star, IsGold int, Except []int) int {
cardList := cardCfg.GetCardListByStar(Round, Star, IsGold)
cardList = GoUtil.SubSlices(cardList, Except)
func randCard(round, star, isGold int, except []int) int {
cardList := cardCfg.GetCardListByStar(round, star, isGold)
cardList = GoUtil.SubSlices(cardList, except)
cardId := GoUtil.RandSlice(cardList)
return cardId
}
// 排位赛金卡
func RankGoldCard() (int, int) {
Card1 := randCard(0, 4, 1, []int{})
Card2 := randCard(0, 5, 1, []int{Card1})
return Card1, Card2
card1 := randCard(0, 4, 1, []int{})
card2 := randCard(0, 5, 1, []int{card1})
return card1, card2
}

166
src/server/game/mod/catnip/Catnip.go
View File

@ -51,24 +51,24 @@ func (c *CatnipMod) InitData() {
}
// 登录 判断是否需要重置数据
func (c *CatnipMod) Login(Id int) (int, []*item.Item) {
OldId := c.Id
if Id == 0 {
func (c *CatnipMod) Login(id int) (int, []*item.Item) {
oldId := c.Id
if id == 0 {
c.Id = 0
return OldId, nil
return oldId, nil
}
if c.Id == Id {
if c.Id == id {
return 0, nil
}
Items := c.GetUnGetReward()
c.Id = Id
items := c.GetUnGetReward()
c.Id = id
c.IsGetGrandReward = false // Reset grand reward status on login
c.Game = make(map[int]*CatnipGame)
c.Mul = 1 // Default multiplier
GameNum := catnipCfg.GetGameNum(c.Id) // Assuming 1 is the default game ID
gameNum := catnipCfg.GetGameNum(c.Id) // Assuming 1 is the default game ID
c.InviteList = make(map[int]*InviteInfo)
c.BeInvitedList = make(map[int]*InviteInfo)
for i := 1; i <= GameNum; i++ {
for i := 1; i <= gameNum; i++ {
c.Game[i] = &CatnipGame{
Id: i,
Partner: 0, // No partner initially
@ -76,50 +76,50 @@ func (c *CatnipMod) Login(Id int) (int, []*item.Item) {
Status: GAME_STATUS_IDLE, // Not started
}
}
return OldId, Items
return oldId, items
}
func (c *CatnipMod) ZeroUpdate(Id int) {
c.Login(Id)
func (c *CatnipMod) ZeroUpdate(id int) {
c.Login(id)
}
// 邀请好友
func (c *CatnipMod) Invite(Uid, Id int) error {
if c.InviteList[Uid] != nil {
return fmt.Errorf("user with ID %d is already invited", Uid)
func (c *CatnipMod) Invite(uid, id int) error {
if c.InviteList[uid] != nil {
return fmt.Errorf("user with ID %d is already invited", uid)
}
c.InviteList[Uid] = &InviteInfo{
InviteId: Id,
c.InviteList[uid] = &InviteInfo{
InviteId: id,
Time: GoUtil.Now(),
}
return nil
}
// 被邀请
func (c *CatnipMod) BeInvited(Uid int, Time int64) error {
func (c *CatnipMod) BeInvited(uid int, time int64) error {
// Check if the user is already invited
invite := c.BeInvitedList[Uid]
invite := c.BeInvitedList[uid]
if invite != nil {
return fmt.Errorf("user with ID %d has already been invited ", Uid)
return fmt.Errorf("user with ID %d has already been invited ", uid)
}
c.BeInvitedList[Uid] = &InviteInfo{
InviteId: Uid,
Time: Time,
c.BeInvitedList[uid] = &InviteInfo{
InviteId: uid,
Time: time,
}
return nil
}
// 同意邀请
func (c *CatnipMod) Agree(Id, Uid int) ([]int, error) {
_, exists := c.BeInvitedList[Uid]
func (c *CatnipMod) Agree(id, uid int) ([]int, error) {
_, exists := c.BeInvitedList[uid]
if !exists {
return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", uid, id)
}
delete(c.BeInvitedList, Uid)
delete(c.BeInvitedList, uid)
for _, GameInfo := range c.Game {
if GameInfo.Partner == 0 {
GameInfo.Partner = Uid
GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil
}
@ -128,22 +128,22 @@ func (c *CatnipMod) Agree(Id, Uid int) ([]int, error) {
}
// 同意邀请-指定格子
func (c *CatnipMod) BeAgree(Id, Uid int) ([]int, error) {
info, exists := c.InviteList[Uid]
func (c *CatnipMod) BeAgree(id, uid int) ([]int, error) {
info, exists := c.InviteList[uid]
if !exists {
return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", uid, id)
}
delete(c.InviteList, Uid)
delete(c.InviteList, uid)
GameInfo := c.Game[info.InviteId]
if GameInfo.Partner == 0 {
GameInfo.Partner = Uid
GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil
}
// 目标格子已有伙伴，分配到第一个空闲格
for _, GameInfo := range c.Game {
if GameInfo.Partner == 0 {
GameInfo.Partner = Uid
GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil
}
@ -152,58 +152,58 @@ func (c *CatnipMod) BeAgree(Id, Uid int) ([]int, error) {
}
// 删除邀请
func (c *CatnipMod) DelInvited(Id, Uid int) error {
delete(c.InviteList, Uid)
func (c *CatnipMod) DelInvited(id, uid int) error {
delete(c.InviteList, uid)
return nil
}
// 设置倍数
func (c *CatnipMod) Multiply(Mul int) error {
c.Mul = Mul
func (c *CatnipMod) Multiply(mul int) error {
c.Mul = mul
return nil
}
// 拒绝邀请
func (c *CatnipMod) Refuse(Id, Uid int) error {
delete(c.BeInvitedList, Uid)
func (c *CatnipMod) Refuse(id, uid int) error {
delete(c.BeInvitedList, uid)
return nil
}
// 玩游戏
func (c *CatnipMod) Play(Id int) (int, int, int, []*item.Item, []*item.Item, int, error) {
GameInfo, ok := c.Game[Id]
func (c *CatnipMod) Play(id int) (int, int, int, []*item.Item, []*item.Item, int, error) {
gameInfo, ok := c.Game[id]
if !ok {
return 0, 0, 0, nil, nil, 0, fmt.Errorf("game with ID %d does not exist", Id)
return 0, 0, 0, nil, nil, 0, fmt.Errorf("game with ID %d does not exist", id)
}
if GameInfo.Status != GAME_STATUS_IN_PROGRESS {
return 0, 0, 0, nil, nil, 0, fmt.Errorf("game with ID %d is not in progress", Id)
if gameInfo.Status != GAME_STATUS_IN_PROGRESS {
return 0, 0, 0, nil, nil, 0, fmt.Errorf("game with ID %d is not in progress", id)
}
Id, Items, Growth, FriendItems := catnipCfg.GetJackpotItem(c.Mul)
Growth = Growth * c.Mul
if Growth > 0 {
c.Growth(Id, Growth)
id, items, growth, friendItems := catnipCfg.GetJackpotItem(c.Mul)
growth = growth * c.Mul
if growth > 0 {
c.Growth(id, growth)
}
ItemCost := catnipCfg.GetItemCost(c.Id, c.Mul)
GameInfo.Progress += Growth
return Id, Growth, GameInfo.Partner, Items, ItemCost, FriendItems, nil
gameInfo.Progress += growth
return id, growth, gameInfo.Partner, items, ItemCost, friendItems, nil
}
// 领取奖励
func (c *CatnipMod) Reward(Id int) ([]*item.Item, *CatnipGame, error) {
GameInfo, ok := c.Game[Id]
func (c *CatnipMod) Reward(id int) ([]*item.Item, *CatnipGame, error) {
gameInfo, ok := c.Game[id]
if !ok {
return nil, nil, fmt.Errorf("game with Progress %d does not exist", Id)
return nil, nil, fmt.Errorf("game with Progress %d does not exist", id)
}
Items, Ids := catnipCfg.GetProgressReward(c.Id, GameInfo.Reward, GameInfo.Progress)
ProgressNum := catnipCfg.GetProgressNum(c.Id)
GameInfo.Reward = append(GameInfo.Reward, Ids...)
if len(GameInfo.Reward) == ProgressNum {
GameInfo.Status = GAME_STATUS_COMPLETED
items, ids := catnipCfg.GetProgressReward(c.Id, gameInfo.Reward, gameInfo.Progress)
progressNum := catnipCfg.GetProgressNum(c.Id)
gameInfo.Reward = append(gameInfo.Reward, ids...)
if len(gameInfo.Reward) == progressNum {
gameInfo.Status = GAME_STATUS_COMPLETED
}
if Items == nil {
return nil, nil, fmt.Errorf("no reward found for progress %d in game ID %d", GameInfo.Progress, Id)
if items == nil {
return nil, nil, fmt.Errorf("no reward found for progress %d in game ID %d", gameInfo.Progress, id)
}
return Items, GameInfo, nil
return items, gameInfo, nil
}
// 领取大奖励
@ -221,26 +221,26 @@ func (c *CatnipMod) GrandReward() ([]*item.Item, error) {
}
// 进度增加
func (c *CatnipMod) Growth(Id, Growth int) {
GameInfo, ok := c.Game[Id]
func (c *CatnipMod) Growth(id, growth int) {
gameInfo, ok := c.Game[id]
if !ok {
return // Game does not exist
}
if GameInfo.Status != GAME_STATUS_IN_PROGRESS {
if gameInfo.Status != GAME_STATUS_IN_PROGRESS {
return // Game is not in progress
}
GameInfo.Progress += Growth
if GameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
GameInfo.Status = GAME_STATUS_COMPLETED
gameInfo.Progress += growth
if gameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
gameInfo.Status = GAME_STATUS_COMPLETED
}
}
// 伙伴贡献增加
func (c *CatnipMod) GrowthByUid(Uid, Growth int) {
func (c *CatnipMod) GrowthByUid(uid, growth int) {
for _, v := range c.Game {
if v.Partner == Uid {
v.Progress += Growth
v.PartnerAdd += Growth
if v.Partner == uid {
v.Progress += growth
v.PartnerAdd += growth
if v.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
v.Status = GAME_STATUS_COMPLETED
}
@ -250,10 +250,10 @@ func (c *CatnipMod) GrowthByUid(Uid, Growth int) {
}
// 设置表情
func (c *CatnipMod) SetEmoji(Uid, EmojiId int) {
func (c *CatnipMod) SetEmoji(uid, emojiId int) {
for _, v := range c.Game {
if v.Partner == Uid {
v.EmojiId = EmojiId
if v.Partner == uid {
v.EmojiId = emojiId
return
}
}
@ -263,24 +263,24 @@ func (c *CatnipMod) GetMultiple() int {
return c.Mul
}
func (c *CatnipMod) GetGameInfo(Id int) *CatnipGame {
return c.Game[Id]
func (c *CatnipMod) GetGameInfo(id int) *CatnipGame {
return c.Game[id]
}
func (c *CatnipMod) SetSendEmoji(Id, EmojiId int) {
c.Game[Id].SendEmoji = EmojiId
func (c *CatnipMod) SetSendEmoji(id, emojiId int) {
c.Game[id].SendEmoji = emojiId
}
// 获取未领取的奖励
func (c *CatnipMod) GetUnGetReward() []*item.Item {
var rewards []*item.Item
for _, v := range c.Game {
Items, _, _ := c.Reward(v.Id)
rewards = append(rewards, Items...)
items, _, _ := c.Reward(v.Id)
rewards = append(rewards, items...)
}
BigReward, err := c.GrandReward()
bigReward, err := c.GrandReward()
if err == nil {
rewards = append(rewards, BigReward...)
rewards = append(rewards, bigReward...)
}
return rewards
}

16
src/server/game/mod/champship/Champship.go
View File

@ -43,12 +43,12 @@ func (c *ChampshipMod) GetRankReward(Rank, yesterdayActivityId int) ([]*item.Ite
return champshipCfg.GetRankReward(Rank, yesterdayActivityId), nil
}
func (c *ChampshipMod) AddScore(Chess []int) {
func (c *ChampshipMod) AddScore(chess []int) {
if !c.isActive() {
return
}
score := 0
for _, v := range Chess {
for _, v := range chess {
Lv := mergeDataCfg.GetLvById(v)
ChessScore := champshipCfg.GetChessScore(Lv)
score += ChessScore
@ -57,17 +57,17 @@ func (c *ChampshipMod) AddScore(Chess []int) {
}
func (c *ChampshipMod) GetReward(activityId, orderFactor int) []*item.Item {
Reward, Items := champshipCfg.GetReward(c.Reward, c.Score, activityId, orderFactor)
c.Reward = Reward
reward, items := champshipCfg.GetReward(c.Reward, c.Score, activityId, orderFactor)
c.Reward = reward
c.Max = max(c.Max, c.Reward)
return Items
return items
}
func (c *ChampshipMod) BackData(MyRank, MyPreRank, todayActivityId, yesterdayActivityId int) *msg.ResChampship {
func (c *ChampshipMod) BackData(myRank, myPreRank, todayActivityId, yesterdayActivityId int) *msg.ResChampship {
rankReward := 0
if c.RankReward {
rankReward = 2
} else if MyPreRank > 0 {
} else if myPreRank > 0 {
rankReward = 1
}
status := 0
@ -79,7 +79,7 @@ func (c *ChampshipMod) BackData(MyRank, MyPreRank, todayActivityId, yesterdayAct
Reward: int32(c.Reward),
EndTime: int32(GoUtil.ZeroTimestamp() + 86400),
Period: int32(GoUtil.GetServerOpenDay()),
Rank: int32(MyRank),
Rank: int32(myRank),
RankReward: int32(rankReward),
Status: int32(status),
TodayActivityId: int32(todayActivityId),

278
src/server/game/mod/charge/Charge.go
View File

@ -112,8 +112,8 @@ func (c *ChargeMod) GetMaxCharge() float64 {
return c.MaxCharge
}
func (c *ChargeMod) Login(LogoutTime int64) {
c.LastWorkTime = min(LogoutTime, c.PetWorkTime)
func (c *ChargeMod) Login(logoutTime int64) {
c.LastWorkTime = min(logoutTime, c.PetWorkTime)
c.PetWorkTime -= c.LastWorkTime
}
@ -125,147 +125,147 @@ func (c *ChargeMod) resetSpecialChargeIfExpired(now int64) {
}
// 零点更新
func (c *ChargeMod) ZeroUpdate(Emit []int) {
Now := GoUtil.Now()
c.resetSpecialChargeIfExpired(Now)
func (c *ChargeMod) ZeroUpdate(emit []int) {
now := GoUtil.Now()
c.resetSpecialChargeIfExpired(now)
if GoUtil.IsFirstDayOfMonth() {
c.MonthCharge = 0
}
c.FreeShop = 0
SpecialGrade := 1
specialGrade := 1
c.TodayCharge = 0
c.AdWatch = 0
c.SpecialShop = make(map[int]*SepcialShop)
SpecialShopCount := chargeCfg.GetSpecialShopCount()
specialShopCount := chargeCfg.GetSpecialShopCount()
for i := 1; i <= 2; i++ {
if c.Total == 0 {
c.SpecialShop[i] = &SepcialShop{Grade: SpecialGrade, Count: 1}
c.SpecialShop[i] = &SepcialShop{Grade: specialGrade, Count: 1}
continue
}
m := c.SpecialCharge
M := chargeCfg.GetSpecialShopGrade(m, i)
a := min(2, GoUtil.FullWeeksSince(c.LastSpecialCharge))
SpecialGrade = max(1, M-a)
c.SpecialShop[i] = &SepcialShop{Grade: SpecialGrade, Count: SpecialShopCount}
specialGrade = max(1, M-a)
c.SpecialShop[i] = &SepcialShop{Grade: specialGrade, Count: specialShopCount}
}
if c.WishList != nil {
c.WishList.SendList = nil
}
if c.IsWeeklyDiscountDay() && c.WeeklyEndTime < Now {
if c.IsWeeklyDiscountDay() && c.WeeklyEndTime < now {
c.WeeklyDiscount = make(map[int]int)
c.WeeklyEndTime = GoUtil.ZeroTimestamp() + secondsIn7Days
}
c.InitChessShop(Emit)
c.InitChessShop(emit)
}
// 十二点更新 重置商店
func (c *ChargeMod) NoonUpdate(Emit []int) {
c.InitChessShop(Emit)
func (c *ChargeMod) NoonUpdate(emit []int) {
c.InitChessShop(emit)
}
func (c *ChargeMod) FixBug(Emit []int) {
func (c *ChargeMod) FixBug(emit []int) {
if len(c.ChessShop) < 5 {
c.InitChessShop(Emit)
c.InitChessShop(emit)
}
}
// 充值
func (c *ChargeMod) Fire(ChargeId int) (Item []*item.Item) {
Money := chargeCfg.GetMoneyCharge(ChargeId)
if Money == 0 {
func (c *ChargeMod) Fire(chargeId int) (Item []*item.Item) {
money := chargeCfg.GetMoneyCharge(chargeId)
if money == 0 {
return
}
c.Charge += Money
c.TodayCharge += Money
c.MonthCharge += Money
c.Charge += money
c.TodayCharge += money
c.MonthCharge += money
c.Total++
Now := GoUtil.Now()
now := GoUtil.Now()
if c.FirstCharge == 0 {
c.FirstCharge = Now
c.FirstCharge = now
}
c.resetSpecialChargeIfExpired(Now)
c.LastCharge = Now
if Money > c.MaxCharge {
c.MaxCharge = Money
c.resetSpecialChargeIfExpired(now)
c.LastCharge = now
if money > c.MaxCharge {
c.MaxCharge = money
}
if Money > c.SpecialCharge {
c.LastSpecialCharge = Now
c.SpecialCharge = Money
if money > c.SpecialCharge {
c.LastSpecialCharge = now
c.SpecialCharge = money
}
Item = c.FireDiamondShop(ChargeId)
Item = c.FireDiamondShop(chargeId)
if Item != nil {
return
}
Item = c.FireEnergyShop(ChargeId)
Item = c.FireEnergyShop(chargeId)
if Item != nil {
return
}
Item = c.FireSpecialShop(ChargeId)
Item = c.FireSpecialShop(chargeId)
if Item != nil {
return
}
Item = c.FirePetCoinShop(ChargeId)
Item = c.FirePetCoinShop(chargeId)
if Item != nil {
return
}
Item = c.FireGift(ChargeId)
c.FireAd(ChargeId)
Item = c.FireGift(chargeId)
c.FireAd(chargeId)
return
}
// 钻石商店
func (c *ChargeMod) FireDiamondShop(ChargeId int) []*item.Item {
return chargeCfg.GetDiamondShopReward(ChargeId)
func (c *ChargeMod) FireDiamondShop(chargeId int) []*item.Item {
return chargeCfg.GetDiamondShopReward(chargeId)
}
// 宠物币商店
func (c *ChargeMod) FirePetCoinShop(ChargeId int) []*item.Item {
return chargeCfg.GetPetCoinShopReward(ChargeId)
func (c *ChargeMod) FirePetCoinShop(chargeId int) []*item.Item {
return chargeCfg.GetPetCoinShopReward(chargeId)
}
// 能量商店
func (c *ChargeMod) FireEnergyShop(ChargeId int) []*item.Item {
id := chargeCfg.GetEnergyShopId(ChargeId)
func (c *ChargeMod) FireEnergyShop(chargeId int) []*item.Item {
id := chargeCfg.GetEnergyShopId(chargeId)
_, ok := c.EnergyShop[id]
c.EnergyShop[id] = struct{}{}
return chargeCfg.GetEnergyShopReward(ChargeId, ok)
return chargeCfg.GetEnergyShopReward(chargeId, ok)
}
// 特惠礼包
func (c *ChargeMod) FireSpecialShop(ChargeId int) []*item.Item {
Type := chargeCfg.GetSpecialShopType(ChargeId)
if _, ok := c.SpecialShop[Type]; !ok {
func (c *ChargeMod) FireSpecialShop(chargeId int) []*item.Item {
cType := chargeCfg.GetSpecialShopType(chargeId)
if _, ok := c.SpecialShop[cType]; !ok {
return nil
}
if c.SpecialShop[Type].Count < 1 {
log.Debug("special shop recharge max, type: %d, charge id: %d", Type, ChargeId)
if c.SpecialShop[cType].Count < 1 {
log.Debug("special shop recharge max, type: %d, charge id: %d", cType, chargeId)
return nil
}
c.SpecialShop[Type].Count--
return chargeCfg.GetSpecialShopReward(ChargeId)
c.SpecialShop[cType].Count--
return chargeCfg.GetSpecialShopReward(chargeId)
}
// 通用礼包
func (c *ChargeMod) FireGift(ChargeId int) []*item.Item {
Limit := chargeCfg.GetGiftLimit(ChargeId)
if Limit == 0 {
func (c *ChargeMod) FireGift(chargeId int) []*item.Item {
limit := chargeCfg.GetGiftLimit(chargeId)
if limit == 0 {
return nil
}
Id := chargeCfg.GetGiftId(ChargeId)
id := chargeCfg.GetGiftId(chargeId)
if v, ok := c.Gift[Id]; ok {
if v >= Limit {
if v, ok := c.Gift[id]; ok {
if v >= limit {
return nil
}
}
c.Gift[Id]++
return chargeCfg.GetGiftReward(ChargeId)
c.Gift[id]++
return chargeCfg.GetGiftReward(chargeId)
}
// 免广告礼包
func (c *ChargeMod) FireAd(ChargeId int) []*item.Item {
AdChargeId := chargeCfg.GetAdChargeId()
if ChargeId != AdChargeId {
func (c *ChargeMod) FireAd(chargeId int) []*item.Item {
adChargeId := chargeCfg.GetAdChargeId()
if chargeId != adChargeId {
return nil
}
c.Ad = true
@ -273,30 +273,30 @@ func (c *ChargeMod) FireAd(ChargeId int) []*item.Item {
}
// 免广告礼包
func (c *ChargeMod) FireAdReward(ChargeId int) []*item.Item {
Items, PetWorkDay := chargeCfg.GetADReward(ChargeId)
if PetWorkDay != 0 {
Now := GoUtil.Now()
if c.AdEndTime < Now {
c.AdEndTime = Now + int64(PetWorkDay*secondsIn1Day)
func (c *ChargeMod) FireAdReward(chargeId int) []*item.Item {
items, petWorkDay := chargeCfg.GetADReward(chargeId)
if petWorkDay != 0 {
now := GoUtil.Now()
if c.AdEndTime < now {
c.AdEndTime = now + int64(petWorkDay*secondsIn1Day)
} else {
c.AdEndTime += int64(PetWorkDay * secondsIn1Day)
c.AdEndTime += int64(petWorkDay * secondsIn1Day)
}
c.PetWorkTime += int64(PetWorkDay * secondsIn1Day)
c.PetWorkTime += int64(petWorkDay * secondsIn1Day)
c.Ad = true
}
return Items
return items
}
func (c *ChargeMod) AddAdTime(PetWorkDay int) {
if PetWorkDay > 0 {
Now := GoUtil.Now()
if c.AdEndTime < Now {
c.AdEndTime = Now + int64(PetWorkDay*secondsIn1Day)
func (c *ChargeMod) AddAdTime(petWorkDay int) {
if petWorkDay > 0 {
now := GoUtil.Now()
if c.AdEndTime < now {
c.AdEndTime = now + int64(petWorkDay*secondsIn1Day)
} else {
c.AdEndTime += int64(PetWorkDay * secondsIn1Day)
c.AdEndTime += int64(petWorkDay * secondsIn1Day)
}
c.PetWorkTime += int64(PetWorkDay * secondsIn1Day)
c.PetWorkTime += int64(petWorkDay * secondsIn1Day)
c.Ad = true
}
}
@ -323,53 +323,51 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
return
}
c.ChessShop = make(map[int]*ChessShop)
//ColorList := make([]string, 0)
RandList := make([]*Rand, 0)
randList := make([]*Rand, 0)
for _, v := range Emit {
ProduceList := mergeDataCfg.GetEmitProduceType(v)
for _, p := range ProduceList {
ChessList := order.GetChessByDiff(v, 1, order.DIFF_MID, p)
if len(ChessList) == 1 {
ChessList = append(ChessList, ChessList[0]-1)
produceList := mergeDataCfg.GetEmitProduceType(v)
for _, p := range produceList {
chessList := order.GetChessByDiff(v, 1, order.DIFF_MID, p)
if len(chessList) == 1 {
chessList = append(chessList, chessList[0]-1)
}
for _, c := range ChessList {
for _, c := range chessList {
if c == 0 {
continue
}
ChessLv := mergeDataCfg.GetLvById(c)
DynamicLv := mergeDataCfg.GetAdjust(v, p, 0)
ChessLv += DynamicLv
Diamond := math.Round(math.Pow(2, float64(ChessLv-1)) / 5)
Diamond = max(1, Diamond)
RandList = append(RandList, &Rand{ChessId: c, Diamond: int(Diamond)})
chessLv := mergeDataCfg.GetLvById(c)
dynamicLv := mergeDataCfg.GetAdjust(v, p, 0)
chessLv += dynamicLv
diamond := math.Round(math.Pow(2, float64(chessLv-1)) / 5)
diamond = max(1, diamond)
randList = append(randList, &Rand{ChessId: c, Diamond: int(diamond)})
}
}
}
randList := make([]interface{}, len(RandList))
for k, v := range RandList {
randList[k] = v
randList2 := make([]interface{}, len(randList))
for k, v := range randList {
randList2[k] = v
}
L := GoUtil.RandSliceNum2(randList, 5)
for k, v := range L {
Diamond := v.(*Rand).Diamond
ChessId := v.(*Rand).ChessId
if ChessId == 0 {
newList := GoUtil.RandSliceNum2(randList2, 5)
for k, v := range newList {
diamond := v.(*Rand).Diamond
chessId := v.(*Rand).ChessId
if chessId == 0 {
continue
}
c.ChessShop[k+1] = &ChessShop{Diamond: Diamond, Count: 5, Id: ChessId}
c.ChessShop[k+1] = &ChessShop{Diamond: diamond, Count: 5, Id: chessId}
}
}
// 购买能量
func (c *ChargeMod) BuyEnergy(IsWeeklyDiscount bool) ([]*item.Item, []*item.Item, int) {
func (c *ChargeMod) BuyEnergy(isWeeklyDiscount bool) ([]*item.Item, []*item.Item, int) {
diamond := 40
if IsWeeklyDiscount {
LimitNum := c.WeeklyDiscount[0]
Discount, WeeklyLimit := chargeCfg.GetWeeklyInfo(0)
if LimitNum < WeeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(Discount) / 100.0))
c.WeeklyDiscount[0] = LimitNum + 1
if isWeeklyDiscount {
limitNum := c.WeeklyDiscount[0]
discount, weeklyLimit := chargeCfg.GetWeeklyInfo(0)
if limitNum < weeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(discount) / 100.0))
c.WeeklyDiscount[0] = limitNum + 1
}
}
return []*item.Item{
@ -381,27 +379,27 @@ func (c *ChargeMod) BuyEnergy(IsWeeklyDiscount bool) ([]*item.Item, []*item.Item
}
// 购买棋子
func (c *ChargeMod) BuyChess(Chess int, IsWeeklyDiscount bool) ([]*item.Item, []*item.Item, int, error) {
v, ok := c.ChessShop[Chess]
func (c *ChargeMod) BuyChess(chess int, isWeeklyDiscount bool) ([]*item.Item, []*item.Item, int, error) {
v, ok := c.ChessShop[chess]
if !ok {
return nil, nil, 0, fmt.Errorf("BuyChess chess id not exist id:%d", Chess)
return nil, nil, 0, fmt.Errorf("BuyChess chess id not exist id:%d", chess)
}
if v.Count <= 0 {
return nil, nil, 0, fmt.Errorf("BuyChess chess count less zero id:%d", Chess)
return nil, nil, 0, fmt.Errorf("BuyChess chess count less zero id:%d", chess)
}
v.Count--
diamond := v.Diamond
if IsWeeklyDiscount {
LimitNum := c.WeeklyDiscount[Chess]
Discount, WeeklyLimit := chargeCfg.GetWeeklyInfo(Chess)
if LimitNum < WeeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(Discount) / 100))
if isWeeklyDiscount {
limitNum := c.WeeklyDiscount[chess]
discount, weeklyLimit := chargeCfg.GetWeeklyInfo(chess)
if limitNum < weeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(discount) / 100))
if diamond == v.Diamond {
diamond -= 1
}
diamond = max(1, diamond)
c.WeeklyDiscount[Chess] = LimitNum + 1
c.WeeklyDiscount[chess] = limitNum + 1
}
}
return []*item.Item{
@ -412,30 +410,30 @@ func (c *ChargeMod) BuyChess(Chess int, IsWeeklyDiscount bool) ([]*item.Item, []
}
// 棋子商店解锁
func (c *ChargeMod) TriggerChargeUnlock(Lv int, Emit []int) {
c.InitChessShop(Emit)
func (c *ChargeMod) TriggerChargeUnlock(lv int, emit []int) {
c.InitChessShop(emit)
}
// 添加心愿单
func (c *ChargeMod) AddWish(Id, Type int) ([]*item.Item, error) {
ItemId := 0
switch Type {
func (c *ChargeMod) AddWish(id, wType int) ([]*item.Item, error) {
itemId := 0
switch wType {
case PLAYROOM_SHOP:
ItemId, _, _, _ = playroomCfg.GetShopItem(Id)
itemId, _, _, _ = playroomCfg.GetShopItem(id)
}
if ItemId == 0 {
return nil, fmt.Errorf("AddWish itemid not exist id:%d", Id)
if itemId == 0 {
return nil, fmt.Errorf("AddWish itemid not exist id:%d", id)
}
var Items []*item.Item
var items []*item.Item
if c.WishList.ItemId != 0 {
if c.WishList.ItemId == ItemId {
return nil, fmt.Errorf("AddWish itemid already exist id:%d", Id)
if c.WishList.ItemId == itemId {
return nil, fmt.Errorf("AddWish itemid already exist id:%d", id)
}
Items = append(Items, item.NewItem(item.ITEM_ENERGY_ID, c.WishList.Count))
items = append(items, item.NewItem(item.ITEM_ENERGY_ID, c.WishList.Count))
c.WishList.Count = 0
}
c.WishList.ItemId = ItemId
return Items, nil
c.WishList.ItemId = itemId
return items, nil
}
// 获取心愿单奖励
@ -443,8 +441,8 @@ func (c *ChargeMod) GetWish() ([]*item.Item, error) {
if c.WishList.ItemId == 0 {
return nil, fmt.Errorf("AddWishCount itemid not exist")
}
Max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count < Max {
max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count < max {
return nil, fmt.Errorf("AddWishCount count max")
}
rewardItemId := c.WishList.ItemId
@ -469,8 +467,8 @@ func (c *ChargeMod) AddWishCount() {
if c.WishList.ItemId == 0 {
return
}
Max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count >= Max {
max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count >= max {
return
}
c.WishList.Count++
@ -478,12 +476,12 @@ func (c *ChargeMod) AddWishCount() {
// 是否在每周折扣日
func (c *ChargeMod) IsWeeklyDiscountDay() bool {
Day := chargeCfg.GetWeeklyDiscountDay()
if Day == -1 {
day := chargeCfg.GetWeeklyDiscountDay()
if day == -1 {
return false
}
Weekday, _ := GoUtil.GetWeekdayAndHour()
return Weekday == Day || c.WeeklyEndTime > GoUtil.Now()
return Weekday == day || c.WeeklyEndTime > GoUtil.Now()
}
// 重置每周折扣

8
src/server/game/mod/charge/charge_func.go
View File

@ -5,12 +5,12 @@ import (
)
// 弃用
func GetChessDiamond(Lv, Type int) int {
func GetChessDiamond(lv, cType int) int {
Diamond := 0.0
if Type == 1 {
Diamond = 0.27 * math.Exp(float64(Lv)*0.56)
if cType == 1 {
Diamond = 0.27 * math.Exp(float64(lv)*0.56)
} else {
Diamond = 2.64 * math.Pow(float64(Lv), 2.43)
Diamond = 2.64 * math.Pow(float64(lv), 2.43)
}
d := int(Diamond)
if d > 10 {

357
src/server/game/mod/chess/Chess.go
View File

@ -74,9 +74,9 @@ func (cb *ChessBorad) IsEmpty() bool {
// 初始化棋盘
func (cb *ChessBorad) InitData() {
StartMerge := startMergeCfg.GetStartChessList()
startMerge := startMergeCfg.GetStartChessList()
cb.EmitList = make(map[int]int)
cb.ChessList = StartMerge
cb.ChessList = startMerge
if cb.ChessBag.List == nil {
cb.ChessBag.List = make(map[int]ChessBagGrid)
InitNum := mergeDataCfg.GetChessBagInitNum()
@ -110,8 +110,8 @@ func (cb *ChessBorad) ver() {
}
if cb.ChessBag.List == nil {
cb.ChessBag.List = make(map[int]ChessBagGrid)
InitNum := mergeDataCfg.GetChessBagInitNum()
for i := 1; i <= InitNum; i++ {
initNum := mergeDataCfg.GetChessBagInitNum()
for i := 1; i <= initNum; i++ {
cb.ChessBag.List[i] = ChessBagGrid{}
}
}
@ -141,11 +141,11 @@ func (cb *ChessBorad) GetChessBuf() []int {
// 棋子合成
func (cb *ChessBorad) ComposeChess(id int) (int, error) {
CfgRecord, err := mergeDataCfg.GetOne(id)
cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil {
return 0, errors.New("配置错误")
}
if CfgRecord.Lv == CfgRecord.MaxLv {
if cfgRecord.Lv == cfgRecord.MaxLv {
return 0, errors.New("已达最大等级")
}
count := 0
@ -161,8 +161,8 @@ func (cb *ChessBorad) ComposeChess(id int) (int, error) {
if count < 2 {
return 0, errors.New("次数不足" + fmt.Sprintf("Id: %d", id))
}
ChessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" {
chessType := mergeDataCfg.GetTypeById(id)
if chessType == "Emitter" {
cb.EmitList[id+1]++
cb.EmitList[id] -= 2
}
@ -199,8 +199,8 @@ func (cb *ChessBorad) AddChess(id int) error {
cb.ChessBuff = append(cb.ChessBuff, id)
return nil
}
ChessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" {
chessType := mergeDataCfg.GetTypeById(id)
if chessType == "Emitter" {
cb.EmitList[id]++
}
cb.ChessList = append(cb.ChessList, id)
@ -209,21 +209,21 @@ func (cb *ChessBorad) AddChess(id int) error {
// 购买棋子
func (cb *ChessBorad) BuyChess(id int) (int, error) {
CfgRecord, err := mergeDataCfg.GetOne(id)
cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil {
return 0, errors.New("配置错误")
}
cb.ChessList = append(cb.ChessList, id)
ChessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" {
chessType := mergeDataCfg.GetTypeById(id)
if chessType == "Emitter" {
cb.EmitList[id]++
}
return CfgRecord.SellNum, nil
return cfgRecord.SellNum, nil
}
// 出售棋子
func (cb *ChessBorad) SellChess(id int) ([]*item.Item, error) {
CfgRecord, err := mergeDataCfg.GetOne(id)
cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil {
return nil, errors.New("配置错误")
}
@ -243,24 +243,24 @@ func (cb *ChessBorad) SellChess(id int) ([]*item.Item, error) {
cb.ChessList = newList
var items []*item.Item
switch CfgRecord.SellType {
switch cfgRecord.SellType {
case "star":
items = append(items, &item.Item{Id: item.ITEM_STAR_ID, Num: CfgRecord.SellNum})
items = append(items, &item.Item{Id: item.ITEM_STAR_ID, Num: cfgRecord.SellNum})
case "diamond":
items = append(items, &item.Item{Id: item.ITEM_DIAMOND_ID, Num: CfgRecord.SellNum})
items = append(items, &item.Item{Id: item.ITEM_DIAMOND_ID, Num: cfgRecord.SellNum})
case "energy":
items = append(items, &item.Item{Id: item.ITEM_ENERGY_ID, Num: CfgRecord.SellNum})
items = append(items, &item.Item{Id: item.ITEM_ENERGY_ID, Num: cfgRecord.SellNum})
case "Racing Battery":
items = append(items, &item.Item{Id: item.ITEM_RACING_BATTERY_ID, Num: CfgRecord.SellNum})
items = append(items, &item.Item{Id: item.ITEM_RACING_BATTERY_ID, Num: cfgRecord.SellNum})
}
return items, nil
}
// 移除棋子
func (cb *ChessBorad) RemoveChess(Id int) error {
func (cb *ChessBorad) RemoveChess(id int) error {
find := false
for k, v := range cb.ChessList {
if v == Id {
if v == id {
cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...)
find = true
break
@ -269,11 +269,11 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
if !find {
return errors.New("chess id not exist")
}
ChessType := mergeDataCfg.GetTypeById(Id)
if ChessType == "Emitter" {
v, ok := cb.EmitList[Id]
chessType := mergeDataCfg.GetTypeById(id)
if chessType == "Emitter" {
v, ok := cb.EmitList[id]
if v > 0 && ok {
cb.EmitList[Id]--
cb.EmitList[id]--
}
}
return nil
@ -282,39 +282,39 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
// emitListToSlice 将 EmitList 过滤并转换为发射器 ID 列表。
// retireFilter 为 true 时过滤已退役的发射器。
func (cb *ChessBorad) emitListToSlice(retireFilter bool) []int {
EM := make(map[string]int)
emitMap := make(map[string]int)
for k, v := range cb.EmitList {
if v <= 0 {
delete(cb.EmitList, k)
continue
}
EmitID := mergeDataCfg.GetEmitId(k)
if EmitID == "" {
emitID := mergeDataCfg.GetEmitId(k)
if emitID == "" {
continue
}
if retireFilter && cb.Retire[EmitID] >= EMIT_RETIRE_START {
if retireFilter && cb.Retire[emitID] >= EMIT_RETIRE_START {
continue
}
if mergeDataCfg.GetEmitType(k) == "sub" {
continue
}
EM[EmitID] = max(EM[EmitID], k)
emitMap[emitID] = max(emitMap[emitID], k)
}
for _, v := range cb.ChessBag.List {
EmitID := mergeDataCfg.GetEmitId(v.ChessId)
if EmitID == "" {
emitID := mergeDataCfg.GetEmitId(v.ChessId)
if emitID == "" {
continue
}
if retireFilter && cb.Retire[EmitID] >= EMIT_RETIRE_START {
if retireFilter && cb.Retire[emitID] >= EMIT_RETIRE_START {
continue
}
if mergeDataCfg.GetEmitType(v.ChessId) == "sub" {
continue
}
EM[EmitID] = max(EM[EmitID], (v.ChessId))
emitMap[emitID] = max(emitMap[emitID], (v.ChessId))
}
result := make([]int, 0, len(EM))
for _, v := range EM {
result := make([]int, 0, len(emitMap))
for _, v := range emitMap {
result = append(result, v)
}
if !retireFilter {
@ -336,7 +336,7 @@ func (cb *ChessBorad) GetEmitList() []int {
}
// 完成订单 移除棋子
func (cb *ChessBorad) FinishOrder(ChessId []int) error {
func (cb *ChessBorad) FinishOrder(chessId []int) error {
unlockChessList := cb.GetUnlockChessList()
unlockChessMap := make(map[int]int)
for _, v := range unlockChessList {
@ -344,13 +344,13 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
}
var boardChess []int
var BagChess []int
for _, v := range ChessId {
var bagChess []int
for _, v := range chessId {
if unlockChessMap[v] > 0 {
unlockChessMap[v]--
boardChess = append(boardChess, v)
} else {
BagChess = append(BagChess, v)
bagChess = append(bagChess, v)
}
}
for _, v := range boardChess {
@ -359,7 +359,7 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
return err
}
}
for _, v := range BagChess {
for _, v := range bagChess {
err := cb.FinishOrderChessByBag(v)
if err != nil {
return err
@ -369,37 +369,47 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
}
// 完成订单 移除棋子
func (cb *ChessBorad) FinishOrderChess(Chess int) error {
func (cb *ChessBorad) FinishOrderChess(chess int) error {
for k, v := range cb.ChessList {
if v == Chess {
if v == chess {
cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...)
return nil
}
}
return fmt.Errorf("order finish board chess id：%d not exist", Chess)
return fmt.Errorf("order finish board chess id：%d not exist", chess)
}
func (cb *ChessBorad) GetChessBagList() []int {
var chessBag []int
for _, v := range cb.ChessBag.List {
if v.ChessId > 0 {
chessBag = append(chessBag, v.ChessId)
}
}
return chessBag
}
// 完成订单 移除棋子
func (cb *ChessBorad) FinishOrderChessByBag(Chess int) error {
func (cb *ChessBorad) FinishOrderChessByBag(chess int) error {
for k, v := range cb.ChessBag.List {
if v.ChessId == Chess {
if v.ChessId == chess {
cb.ChessBag.List[k] = ChessBagGrid{}
return nil
}
}
return fmt.Errorf("order finish bag chess id：%d not exist", Chess)
return fmt.Errorf("order finish bag chess id：%d not exist", chess)
}
// 棋子转换
func (cb *ChessBorad) ExChess(OldChessId, NewChessId int) error {
if OldChessId > 0 {
newList, b := GoUtil.PopElemSlice(cb.ChessList, OldChessId)
func (cb *ChessBorad) ExChess(oldChessId, newChessId int) error {
if oldChessId > 0 {
newList, b := GoUtil.PopElemSlice(cb.ChessList, oldChessId)
if !b {
return fmt.Errorf("ExChess chess id not exist")
}
cb.ChessList = newList
}
return cb.AddChess(NewChessId)
return cb.AddChess(newChessId)
}
// 增加棋盘缓冲器
@ -407,82 +417,82 @@ func (cb *ChessBorad) AddChessBuff(chess int) {
cb.ChessBuff = append(cb.ChessBuff, chess)
}
func (cb *ChessBorad) AddHonor(Id int) {
cb.Honor[Id] = 1
func (cb *ChessBorad) AddHonor(id int) {
cb.Honor[id] = 1
}
func (cb *ChessBorad) RemoveHonor(Id int) {
delete(cb.Honor, Id)
func (cb *ChessBorad) RemoveHonor(id int) {
delete(cb.Honor, id)
}
// 从暂存区添加棋子到棋盘
func (cb *ChessBorad) GetChessFromBuff(Chess int) error {
func (cb *ChessBorad) GetChessFromBuff(chess int) error {
for i, v := range cb.ChessBuff {
if v == Chess {
if v == chess {
cb.ChessBuff = append(cb.ChessBuff[:i], cb.ChessBuff[i+1:]...)
return cb.AddChess(Chess)
return cb.AddChess(chess)
}
}
return errors.New("chess id not exist")
}
// 扣除零件
func (cb *ChessBorad) LosePart(PartId int, Num int) error {
v, ok := cb.PartBag.List[PartId]
if !ok || v.Num < Num {
return errors.New("part id not exist or num not enough" + fmt.Sprintf("PartId: %d, Num: %d, ok: %v", PartId, Num, ok))
func (cb *ChessBorad) LosePart(partId int, num int) error {
v, ok := cb.PartBag.List[partId]
if !ok || v.Num < num {
return errors.New("part id not exist or num not enough" + fmt.Sprintf("PartId: %d, Num: %d, ok: %v", partId, num, ok))
}
v.Num -= Num
cb.PartBag.List[PartId] = v
v.Num -= num
cb.PartBag.List[partId] = v
return nil
}
// 返回数据
func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
var ChessBagGrids []*msg.ChessBagGrid
var chessBagGrids []*msg.ChessBagGrid
for k, v := range cb.ChessBag.List {
ChessBagGrids = append(ChessBagGrids, &msg.ChessBagGrid{
chessBagGrids = append(chessBagGrids, &msg.ChessBagGrid{
Id: int32(k),
ChessId: int32(v.ChessId),
EmitId: int32(v.EmitId),
})
}
var PartBagGrids []*msg.PartBagGrid
var partBagGrids []*msg.PartBagGrid
for k, v := range cb.PartBag.List {
PartBagGrids = append(PartBagGrids, &msg.PartBagGrid{
partBagGrids = append(partBagGrids, &msg.PartBagGrid{
PartId: int32(k),
Count: int32(v.Num),
})
}
Re := make([]string, 0, len(cb.Retire))
retire := make([]string, 0, len(cb.Retire))
for k, v := range cb.Retire {
if v == EMIT_RETIRE_END {
Re = append(Re, k)
retire = append(retire, k)
}
}
Ho := make([]int32, 0, len(cb.Honor))
honor := make([]int32, 0, len(cb.Honor))
for k := range cb.Honor {
Ho = append(Ho, int32(k))
honor = append(honor, int32(k))
}
Rw := make([]string, 0, len(cb.RetireReward))
retireReward := make([]string, 0, len(cb.RetireReward))
for k, v := range cb.RetireReward {
if v {
Rw = append(Rw, k)
retireReward = append(retireReward, k)
}
}
return &msg.ResPlayerChessInfo{
ChessList: GoUtil.SliceIntToInt32(cb.ChessList),
ChessBuff: GoUtil.SliceIntToInt32(cb.ChessBuff),
RetireEmit: Re,
RetireReward: Rw,
Honor: Ho,
RetireEmit: retire,
RetireReward: retireReward,
Honor: honor,
ChessBag: &msg.ChessBag{
ChessBagGrids: ChessBagGrids,
ChessBagGrids: chessBagGrids,
ChessBuyCnt: int32(cb.ChessBag.Buy),
ChessFreeCnt: int32(cb.ChessBag.Free),
},
PartBag: &msg.PartBag{
PartBagGrids: PartBagGrids,
PartBagGrids: partBagGrids,
},
}
}
@ -494,8 +504,8 @@ func (cb *ChessBorad) BuyChessBagGrid() error {
cb.ChessBag.Free--
return nil
}
MaxBuy := mergeDataCfg.GetChessBagBugNum()
if cb.ChessBag.Buy >= MaxBuy {
maxBuy := mergeDataCfg.GetChessBagBugNum()
if cb.ChessBag.Buy >= maxBuy {
return fmt.Errorf("ChessBag can buy is full")
}
cb.ChessBag.Buy++
@ -507,31 +517,31 @@ func (cb *ChessBorad) GetBuyChessBagGridCost() []*item.Item {
if cb.ChessBag.Free > 0 {
return nil
}
NeedDiamond := 10 + 15*cb.ChessBag.Buy
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -NeedDiamond}}
needDiamond := 10 + 15*cb.ChessBag.Buy
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -needDiamond}}
}
// 升级触发解锁棋盘背包
func (cb *ChessBorad) TriggerChessBagUnlock(Lv int) bool {
UnlockPack := userCfg.GetUnlockPack(Lv)
if UnlockPack > 0 {
cb.ChessBag.Free += UnlockPack
func (cb *ChessBorad) TriggerChessBagUnlock(lv int) bool {
unlockPack := userCfg.GetUnlockPack(lv)
if unlockPack > 0 {
cb.ChessBag.Free += unlockPack
return true
}
return false
}
// 将棋子放入背包
func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error {
err := cb.RemoveChess(ChessId)
func (cb *ChessBorad) PutChessInBag(grid, chessId, emitId int) error {
err := cb.RemoveChess(chessId)
if err != nil {
return err
}
if Grid == 0 { // 背包id为0且发射器已退役奖励已领取 直接放入荣誉室
cb.AddHonor(ChessId)
if grid == 0 { // 背包id为0且发射器已退役奖励已领取 直接放入荣誉室
cb.AddHonor(chessId)
return nil
}
v, ok := cb.ChessBag.List[Grid]
v, ok := cb.ChessBag.List[grid]
if !ok {
return errors.New("ChessBag Grid unlock")
}
@ -539,132 +549,157 @@ func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error {
if v.ChessId > 0 {
return errors.New("ChessBag Grid is not empty")
}
cb.ChessBag.List[Grid] = ChessBagGrid{
ChessId: ChessId,
EmitId: EmitId,
cb.ChessBag.List[grid] = ChessBagGrid{
ChessId: chessId,
EmitId: emitId,
}
return nil
}
// 将零件放入背包
func (cb *ChessBorad) PutPartInBag(ChessId int) error {
err := cb.RemoveChess(ChessId)
func (cb *ChessBorad) PutPartInBag(chessId int) error {
err := cb.RemoveChess(chessId)
if err != nil {
return err
}
ChessLv := mergeDataCfg.GetLvById(ChessId)
ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId)
if ChessLv != ChessMaxLv { // 零件只能放入满级棋子
chessLv := mergeDataCfg.GetLvById(chessId)
chessMaxLv := mergeDataCfg.GetMaxLvById(chessId)
if chessLv != chessMaxLv { // 零件只能放入满级棋子
return errors.New("part Lv is not max")
}
if cb.PartBag.List == nil {
cb.PartBag.List = make(map[int]PartBagGrid)
}
Num := cb.PartBag.List[ChessId].Num
cb.PartBag.List[ChessId] = PartBagGrid{
PartId: ChessId,
Num: Num + 1,
num := cb.PartBag.List[chessId].Num
cb.PartBag.List[chessId] = PartBagGrid{
PartId: chessId,
Num: num + 1,
}
return nil
}
// 将棋子从背包取出
func (cb *ChessBorad) TakeChessOutBag(Grid int) (int, error) {
if Grid < 0 {
cb.RemoveHonor(-Grid)
cb.AddChess(-Grid)
func (cb *ChessBorad) TakeChessOutBag(grid int) (int, error) {
if grid < 0 {
cb.RemoveHonor(-grid)
cb.AddChess(-grid)
return 0, nil
}
GridInfo, ok := cb.ChessBag.List[Grid]
gridInfo, ok := cb.ChessBag.List[grid]
if !ok {
return 0, errors.New("ChessBag Grid unlock")
}
if GridInfo.ChessId == 0 {
if gridInfo.ChessId == 0 {
return 0, errors.New("ChessBag Grid is empty")
}
cb.ChessBag.List[Grid] = ChessBagGrid{}
return GridInfo.ChessId, cb.AddChess(GridInfo.ChessId)
cb.ChessBag.List[grid] = ChessBagGrid{}
return gridInfo.ChessId, cb.AddChess(gridInfo.ChessId)
}
// 将棋子从背包放入荣誉室
func (cb *ChessBorad) TakeChessOutBagToHonor(grid int) (int, error) {
gridInfo, ok := cb.ChessBag.List[grid]
if !ok {
return 0, errors.New("ChessBag Grid unlock")
}
if gridInfo.ChessId == 0 {
return 0, errors.New("ChessBag Grid is empty")
}
cb.ChessBag.List[grid] = ChessBagGrid{}
cb.AddHonor(gridInfo.ChessId)
return gridInfo.ChessId, nil
}
func (cb *ChessBorad) GetOrderEmit() []int {
return cb.GetEmitList()
}
// 生成零件订单的发射器列表[去除自动发射器]
func (cb *ChessBorad) GetOrderPartEmit() []int {
emitList := cb.GetEmitList()
newEmitList := make([]int, 0, len(emitList))
for _, v := range emitList {
if mergeDataCfg.GetEmitType(v) != "auto" {
newEmitList = append(newEmitList, v)
}
}
return newEmitList
}
func (cb *ChessBorad) GetRetireEmit() map[string]int {
return cb.Retire
}
// 获取退役发射器的棋子列表
func (cb *ChessBorad) GetRetireChess(EmitType string) []int {
v, ok := cb.RetireChessMap[EmitType]
func (cb *ChessBorad) GetRetireChess(emitType string) []int {
v, ok := cb.RetireChessMap[emitType]
if !ok {
return nil
}
if len(v) == 1 {
cb.RetireChessMap[EmitType] = nil
cb.RetireChessMap[emitType] = nil
return v
}
if len(v) == 0 {
return nil
}
cb.RetireChessMap[EmitType] = v[2:]
cb.RetireChessMap[emitType] = v[2:]
return v[:2]
}
// 开始退役
func (cb *ChessBorad) BeginRetire(EmitType string) error {
func (cb *ChessBorad) BeginRetire(emitType string) error {
if cb.Retire == nil {
cb.Retire = make(map[string]int)
}
_, ok := cb.Retire[EmitType]
_, ok := cb.Retire[emitType]
if ok {
return errors.New("chess has been retired")
}
cb.Retire[EmitType] = EMIT_RETIRE_START
cb.Retire[emitType] = EMIT_RETIRE_START
return nil
}
// 退役棋子处理
func (cb *ChessBorad) RetireOrder(EmitType string) error {
if cb.Retire[EmitType] != 1 {
func (cb *ChessBorad) RetireOrder(emitType string) error {
if cb.Retire[emitType] != 1 {
return errors.New("chess has not been retired")
}
chess := make([]int, 0, len(cb.ChessMap))
EmitProduct := mergeDataCfg.GetEmitOrderProduce(EmitType)
for k, v := range cb.ChessMap {
arr := strings.Split(k, "@")
Color := mergeDataCfg.GetColorById(int(v))
if arr[2] == "0" && GoUtil.InStringArray(Color, EmitProduct) {
emitProduct := mergeDataCfg.GetEmitOrderProduce(emitType)
for _, v := range cb.ChessMap {
color := mergeDataCfg.GetColorById(int(v))
if GoUtil.InStringArray(color, emitProduct) {
chess = append(chess, int(v))
}
}
sort.Sort(sort.Reverse(sort.IntSlice(chess)))
cb.RetireChessMap[EmitType] = chess
cb.Retire[EmitType] = EMIT_RETIRE_ING
cb.RetireChessMap[emitType] = chess
cb.Retire[emitType] = EMIT_RETIRE_ING
return nil
}
// 完成退役
func (cb *ChessBorad) FinishRetire(EmitType string) error {
_, ok := cb.Retire[EmitType]
func (cb *ChessBorad) FinishRetire(emitType string) error {
_, ok := cb.Retire[emitType]
if !ok {
return errors.New("chess has not been retired")
}
cb.Retire[EmitType] = EMIT_RETIRE_END
cb.Retire[emitType] = EMIT_RETIRE_END
return nil
}
// 获取资源宝箱奖励
func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) {
err := cb.RemoveChess(ChessId)
func (cb *ChessBorad) SourceChest(chessId int) ([]*item.Item, error) {
err := cb.RemoveChess(chessId)
if err != nil {
return nil, err
}
if ChessId == CHESS_SOURCE_CHEST {
if chessId == CHESS_SOURCE_CHEST {
return mergeDataCfg.GetSourceChestItem(), nil
}
if ChessId == CHESS_HIGH_SOURCE_CHEST {
if chessId == CHESS_HIGH_SOURCE_CHEST {
return mergeDataCfg.GetHighSourceChestItem(), nil
}
@ -672,16 +707,16 @@ func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) {
}
// 降低棋子等级
func (cb *ChessBorad) SeparateChess(ChessId int) (int, error) {
ChessLv := mergeDataCfg.GetLvById(ChessId)
if ChessLv == 1 {
func (cb *ChessBorad) SeparateChess(chessId int) (int, error) {
chessLv := mergeDataCfg.GetLvById(chessId)
if chessLv == 1 {
return 0, errors.New("chess lv is 1")
}
ChessType := mergeDataCfg.GetTypeById(ChessId)
if ChessType != "Product" {
chessType := mergeDataCfg.GetTypeById(chessId)
if chessType != "Product" {
return 0, errors.New("chess type is not product")
}
err := cb.RemoveChess(ChessId)
err := cb.RemoveChess(chessId)
if err != nil {
return 0, err
}
@ -689,25 +724,25 @@ func (cb *ChessBorad) SeparateChess(ChessId int) (int, error) {
if err != nil {
return 0, err
}
ChessColor := mergeDataCfg.GetColorById(ChessId)
NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv-1, ChessColor)
cb.AddChess(NewChess)
cb.AddChess(NewChess)
return NewChess, nil
chessColor := mergeDataCfg.GetColorById(chessId)
newChess := mergeDataCfg.GetChessIdByLvAndColor(chessLv-1, chessColor)
cb.AddChess(newChess)
cb.AddChess(newChess)
return newChess, nil
}
// 提高棋子等级
func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) {
ChessLv := mergeDataCfg.GetLvById(ChessId)
ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId)
if ChessLv == ChessMaxLv {
func (cb *ChessBorad) UpgradeChess(chessId int) (int, error) {
chessLv := mergeDataCfg.GetLvById(chessId)
chessMaxLv := mergeDataCfg.GetMaxLvById(chessId)
if chessLv == chessMaxLv {
return 0, errors.New("chess lv is max")
}
ChessType := mergeDataCfg.GetTypeById(ChessId)
if ChessType != "Product" {
chessType := mergeDataCfg.GetTypeById(chessId)
if chessType != "Product" {
return 0, errors.New("chess type is not product")
}
err := cb.RemoveChess(ChessId)
err := cb.RemoveChess(chessId)
if err != nil {
return 0, err
}
@ -715,9 +750,9 @@ func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) {
if err != nil {
return 0, err
}
NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv+1, mergeDataCfg.GetColorById(ChessId))
cb.AddChess(NewChess)
return NewChess, nil
newChess := mergeDataCfg.GetChessIdByLvAndColor(chessLv+1, mergeDataCfg.GetColorById(chessId))
cb.AddChess(newChess)
return newChess, nil
}
func (cb *ChessBorad) GetPartBag() map[int]int {
@ -728,14 +763,14 @@ func (cb *ChessBorad) GetPartBag() map[int]int {
return res
}
func (cb *ChessBorad) GetRetireReward(Id string) ([]*item.Item, error) {
if cb.RetireReward[Id] == true {
func (cb *ChessBorad) GetRetireReward(id string) ([]*item.Item, error) {
if cb.RetireReward[id] == true {
return nil, errors.New("emit retire reward has been get")
}
if cb.Retire[Id] != EMIT_RETIRE_END {
if cb.Retire[id] != EMIT_RETIRE_END {
return nil, errors.New("emit not finish retire")
}
cb.RetireReward[Id] = true
cb.RetireReward[id] = true
return mergeDataCfg.GetRetireReward(), nil
}

4
src/server/game/mod/compensation/compensation.go
View File

@ -21,12 +21,12 @@ func (c *Compensation) Set20250910() {
c.C20250910 = true
}
func (c *Compensation) Compensation20250910(UserName string) []*item.Item {
func (c *Compensation) Compensation20250910(userName string) []*item.Item {
c.Set20250910()
// 获取补偿物品
items := make([]*item.Item, 0, len(Compensation20250910_UserList))
for i := 1; i <= len(Compensation20250910_UserList); i++ {
if GoUtil.InStringArray(UserName, Compensation20250910_UserList[i]) {
if GoUtil.InStringArray(userName, Compensation20250910_UserList[i]) {
return Compensation20250910_Mail_Item[i]
}
}

21
src/server/game/mod/daily_task/DailyFunc.go
View File

@ -8,12 +8,11 @@ import (
"sort"
)
func getTaskReward(Id, AreaId, activityId int) []*item.Item {
switch Id {
func getTaskReward(id, areaId, activityId int) []*item.Item {
switch id {
case 2:
StarNum := int(50 * math.Pow(1.04, float64(AreaId)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: StarNum}}
starNum := int(50 * math.Pow(1.04, float64(areaId)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: starNum}}
case 3:
return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 10}}
default: // case 1 及其他
@ -24,16 +23,16 @@ func getTaskReward(Id, AreaId, activityId int) []*item.Item {
// randJackpot 随机选取 num 个奖池项，约束：不允许连续两个 is_card=1 的项相邻。
// 最多尝试 100 次，超时则返回最后一次结果。
func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.Item {
Ids := GoUtil.GetMapKey(jackpot)
ids := GoUtil.GetMapKey(jackpot)
var lastIds1 []int
for t := 0; t <= 100; t++ {
Ids1 := GoUtil.RandSliceNum(Ids, num)
sort.Ints(Ids1)
lastIds1 = Ids1
ids1 := GoUtil.RandSliceNum(ids, num)
sort.Ints(ids1)
lastIds1 = ids1
prevIsCard := 0
valid := true
cardCount := 0
for _, k := range Ids1 {
for _, k := range ids1 {
curIsCard := jackpot[k].Is_card
if prevIsCard == 1 && curIsCard == 1 {
valid = false
@ -49,7 +48,7 @@ func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.
}
if valid {
r := make(map[int][]*item.Item, num)
for _, k := range Ids1 {
for _, k := range ids1 {
r[k] = jackpot[k].Items
}
return r

206
src/server/game/mod/decorate/Decorate.go
View File

@ -65,16 +65,16 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
if _, ok := d.FinishList[decorateId]; ok {
return nil, fmt.Errorf("decorateId already finished")
}
SortList := decorateCfg.GetAllSortIdByAreaId(areaId)
if !GoUtil.InArray(decorateId, SortList) {
sortList := decorateCfg.GetAllSortIdByAreaId(areaId)
if !GoUtil.InArray(decorateId, sortList) {
return nil, fmt.Errorf("decorateId not in areaId")
}
d.FinishList[decorateId] = struct{}{}
d.Progress++
Item := decorateCfg.GetProgressReward(areaId, d.Progress)
Item1 := decorateCfg.GetDecoarteReward(areaId, decorateId)
Item = append(Item, Item1...)
if d.Progress >= len(SortList) {
items := decorateCfg.GetProgressReward(areaId, d.Progress)
items1 := decorateCfg.GetDecoarteReward(areaId, decorateId)
items = append(items, items1...)
if d.Progress >= len(sortList) {
d.AreaId++
d.Progress = 0
d.FinishList = make(map[int]struct{})
@ -82,31 +82,31 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
}
d.DecorateNum++
return Item, nil
return items, nil
}
// 获取装饰增加体力
func (d *Decorate) GetDecorateAddEnergy(cnt int) []*item.Item {
EnergyNum := decorateCfg.GetDecorateAddEnergy()
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, EnergyNum*cnt)}
energyNum := decorateCfg.GetDecorateAddEnergy()
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, energyNum*cnt)}
}
// 获取装饰消耗
func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExist bool) ([]*item.Item, int, []*item.Item) {
Item := decorateCfg.GetStarCost(AreaId, DecorateId)
PetExp := decorateCfg.GetDecoratePExp(AreaId, DecorateId)
Id := decorateCfg.GetIdBySenceAndLv(AreaId, DecorateId)
if DecorateOffIsExist {
OffRate := limitedTimeEventCfg.GetDecorateOffDiscount(AreaId, DecorateId)
Item = int(math.Ceil(float64(Item) * float64(OffRate)))
func (d *Decorate) GetDecorateCostItem(areaId, decorateId int, decorateOffIsExist bool) ([]*item.Item, int, []*item.Item) {
itemNum := decorateCfg.GetStarCost(areaId, decorateId)
petExp := decorateCfg.GetDecoratePExp(areaId, decorateId)
id := decorateCfg.GetIdBySenceAndLv(areaId, decorateId)
if decorateOffIsExist {
offRate := limitedTimeEventCfg.GetDecorateOffDiscount(areaId, decorateId)
itemNum = int(math.Ceil(float64(itemNum) * float64(offRate)))
}
Items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, Item)}
PartItem := d.PartCost[Id]
PartItemList := make([]*item.Item, 0)
if PartItem != nil {
Items = append(Items, PartItem.Items...)
PartItemList = PartItem.Items
delete(d.PartCost, Id)
items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, itemNum)}
partCostInfo := d.PartCost[id]
partItems := make([]*item.Item, 0)
if partCostInfo != nil {
items = append(items, partCostInfo.Items...)
partItems = partCostInfo.Items
delete(d.PartCost, id)
}
// 清理旧区域零件；若当前区域全部消耗完则预加载下一区域
for k := range d.PartCost {
@ -117,17 +117,17 @@ func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExis
if len(d.PartCost) == 0 {
d.initPartCost(d.AreaId + 1)
}
return Items, PetExp, PartItemList
return items, petExp, partItems
}
func (d *Decorate) GetNextNeedStar() int {
DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
decorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
subAlice := GoUtil.SubSlices(decorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
orderFactor := orderCfg.GetOrderFactor(d.GetAreaId())
sort.Ints(SubAlice)
if len(SubAlice) > 0 {
NeedStar := decorateCfg.GetStarCost(d.AreaId, SubAlice[0])
return (NeedStar*orderFactor)/1000 + NeedStar
sort.Ints(subAlice)
if len(subAlice) > 0 {
needStar := decorateCfg.GetStarCost(d.AreaId, subAlice[0])
return (needStar*orderFactor)/1000 + needStar
}
return 0
}
@ -137,73 +137,73 @@ func (d *Decorate) GetAreaCost() int {
}
// 一键装饰
func (d *Decorate) DecorateAll(Star int, DecorateOffIsExist bool) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
sort.Ints(SubAlice)
SubItem := 0
SubItems := make([]*item.Item, 0)
AddItem := make([]*item.Item, 0)
DecorateList := make([]int, 0)
Log := make([]interface{}, 0)
Num := 0
PetExp := 0
for _, v := range SubAlice {
Id := decorateCfg.GetIdBySenceAndLv(d.AreaId, v)
PartItem := d.PartCost[Id]
if PartItem != nil {
func (d *Decorate) DecorateAll(star int, decorateOffIsExist bool) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
decorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
subAlice := GoUtil.SubSlices(decorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
sort.Ints(subAlice)
subItem := 0
subItems := make([]*item.Item, 0)
addItem := make([]*item.Item, 0)
decorateList := make([]int, 0)
logList := make([]interface{}, 0)
num := 0
petExp := 0
for _, v := range subAlice {
id := decorateCfg.GetIdBySenceAndLv(d.AreaId, v)
partItem := d.PartCost[id]
if partItem != nil {
break
}
NeedStar := decorateCfg.GetStarCost(d.AreaId, v)
if DecorateOffIsExist {
OffRate := limitedTimeEventCfg.GetDecorateOffDiscount(d.AreaId, v)
NeedStar = int(math.Ceil(float64(NeedStar) * float64(OffRate)))
needStar := decorateCfg.GetStarCost(d.AreaId, v)
if decorateOffIsExist {
offRate := limitedTimeEventCfg.GetDecorateOffDiscount(d.AreaId, v)
needStar = int(math.Ceil(float64(needStar) * float64(offRate)))
}
if Star < NeedStar {
if star < needStar {
break
}
Star -= NeedStar
SubItem += NeedStar
star -= needStar
subItem += needStar
d.FinishList[v] = struct{}{}
d.Progress++
d.DecorateNum++
Num++
Item := decorateCfg.GetProgressReward(d.AreaId, d.Progress)
Item = append(Item, decorateCfg.GetDecoarteReward(d.AreaId, v)...)
if len(Item) > 0 {
if d.Progress >= len(DecorateAll) {
Log = append(Log, map[string]interface{}{
num++
items := decorateCfg.GetProgressReward(d.AreaId, d.Progress)
items = append(items, decorateCfg.GetDecoarteReward(d.AreaId, v)...)
if len(items) > 0 {
if d.Progress >= len(decorateAll) {
logList = append(logList, map[string]interface{}{
"deco_step_id": fmt.Sprintf("%d_%d", d.AreaId+1, 0),
"item_list": Item,
"item_list": items,
})
} else {
Log = append(Log, map[string]interface{}{
logList = append(logList, map[string]interface{}{
"deco_step_id": fmt.Sprintf("%d_%d", d.AreaId, d.Progress),
"item_list": Item,
"item_list": items,
})
}
}
PetExp += decorateCfg.GetDecoratePExp(d.AreaId, v)
AddItem = append(AddItem, Item...)
DecorateList = append(DecorateList, v)
petExp += decorateCfg.GetDecoratePExp(d.AreaId, v)
addItem = append(addItem, items...)
decorateList = append(decorateList, v)
}
if d.Progress >= len(DecorateAll) {
if d.Progress >= len(decorateAll) {
d.AreaId++
d.Progress = 0
d.FinishList = make(map[int]struct{})
d.prunePartCost()
}
SubItems = append(SubItems, item.NewItem(item.ITEM_STAR_ID, SubItem))
return SubItems, AddItem, Num, DecorateList, Log, PetExp
subItems = append(subItems, item.NewItem(item.ITEM_STAR_ID, subItem))
return subItems, addItem, num, decorateList, logList, petExp
}
// 获取装饰信息
func (d *Decorate) BackData() *msg.ResDecorateInfo {
var PartRes []*msg.DecoratePart
var partRes []*msg.DecoratePart
for k, v := range d.PartCost {
PartRes = append(PartRes, &msg.DecoratePart{
partRes = append(partRes, &msg.DecoratePart{
Id: int32(k),
Items: item.ItemToMsg(v.Items),
})
@ -212,7 +212,7 @@ func (d *Decorate) BackData() *msg.ResDecorateInfo {
AreaId: int32(d.AreaId),
MFinishList: GoUtil.MapIntToSlice(d.FinishList),
RewardArea: GoUtil.IntToInt32(d.AreaReward),
Parts: PartRes,
Parts: partRes,
}
}
@ -238,49 +238,49 @@ func (d *Decorate) GetDecorateNum() int {
}
// 获取零件
func (d *Decorate) GetPart(Num int) map[int]int {
func (d *Decorate) GetPart(num int) map[int]int {
d.initPartPool()
res := make(map[int]int)
ClassNum := min(Num, 3)
ClassList := d.GetPartClass(ClassNum)
NewClassList := d.sortClass(ClassList)
for i := range Num {
Class := NewClassList[i%ClassNum]
d.PartPool[Class]--
res[Class]++
classNum := min(num, 3)
classList := d.GetPartClass(classNum)
newClassList := d.sortClass(classList)
for i := range num {
class := newClassList[i%classNum]
d.PartPool[class]--
res[class]++
}
return res
}
func (d *Decorate) sortClass(Class []int) []int {
func (d *Decorate) sortClass(class []int) []int {
d.initPartPool()
type sortItem struct {
Id int
Num int
}
sortList := make([]sortItem, len(Class))
for i, v := range Class {
sortList := make([]sortItem, len(class))
for i, v := range class {
sortList[i] = sortItem{Id: v, Num: d.PartPool[v]}
}
sort.Slice(sortList, func(i, j int) bool {
return sortList[i].Num > sortList[j].Num
})
res := make([]int, len(Class))
res := make([]int, len(class))
for i, v := range sortList {
res[i] = v.Id
}
return res
}
func (d *Decorate) GetPartClass(Num int) []int {
res := make([]int, 0, Num)
for range Num {
func (d *Decorate) GetPartClass(num int) []int {
res := make([]int, 0, num)
for i := 0; i < num; i++ {
if len(d.PartClassPool) == 0 {
d.initPartClassPool()
}
Id, newPool := GoUtil.PopSlice(d.PartClassPool)
id, newPool := GoUtil.PopSlice(d.PartClassPool)
d.PartClassPool = newPool
res = append(res, Id)
res = append(res, id)
}
return res
}
@ -288,35 +288,35 @@ func (d *Decorate) GetPartClass(Num int) []int {
// 初始化零件类别池，优先保证每个类别至少出现一次
func (d *Decorate) initPartClassPool() {
if len(d.PartClassPool) == 0 {
ClassList := decorateCfg.GetAllPartId()
r1 := GoUtil.SubSlices(ClassList, d.LastPart)
classList := decorateCfg.GetAllPartId()
r1 := GoUtil.SubSlices(classList, d.LastPart)
c1 := GoUtil.RandSlice(r1)
r2 := GoUtil.SubSlices(ClassList, []int{c1})
r2 := GoUtil.SubSlices(classList, []int{c1})
r3 := GoUtil.ShuffleArray(r2)
d.PartClassPool = append([]int{c1}, r3...)
}
}
func (d *Decorate) initPartPool() {
IsEmpty := true
isEmpty := true
for _, v := range d.PartPool {
if v > 0 {
IsEmpty = false
isEmpty = false
break
}
}
if IsEmpty {
PartList := decorateCfg.GetAllPartId()
for _, v := range PartList {
if isEmpty {
partList := decorateCfg.GetAllPartId()
for _, v := range partList {
d.PartPool[v] = 7
}
}
}
// 初始化零件消耗，预加载当前区域和下一区域的零件消耗，减少玩家装饰时的卡顿感
func (d *Decorate) initPartCost(AreaId int) {
AllPartList := decorateCfg.GetPartNumByAreaId(AreaId)
for k, v := range AllPartList {
func (d *Decorate) initPartCost(areaId int) {
allPartList := decorateCfg.GetPartNumByAreaId(areaId)
for k, v := range allPartList {
// 初始零件消耗写死
if k == 33 {
d.PartCost[k] = &PartCostInfo{
@ -336,13 +336,13 @@ func (d *Decorate) initPartCost(AreaId int) {
}
continue
}
PartList := d.GetPart(v)
Items := make([]*item.Item, 0)
for k1, v1 := range PartList {
Items = append(Items, item.NewItem(k1, v1))
partList := d.GetPart(v)
items := make([]*item.Item, 0)
for k1, v1 := range partList {
items = append(items, item.NewItem(k1, v1))
}
d.PartCost[k] = &PartCostInfo{
Items: Items,
Items: items,
}
}
}

20
src/server/game/mod/emoji/emoji.go
View File

@ -45,31 +45,31 @@ func (e *EmojiMod) GetEmojiNum() int {
}
// 设置表情，Id为0表示清空该类型表情
func (e *EmojiMod) SetEmoji(Id, Type int) error {
if Id == 0 {
e.Set[Type] = Id
func (e *EmojiMod) SetEmoji(id, eType int) error {
if id == 0 {
e.Set[eType] = id
return nil
}
if _, ok := e.List[Id]; !ok {
if _, ok := e.List[id]; !ok {
return fmt.Errorf("emoji id not exist")
}
e.Set[Type] = Id
e.Set[eType] = id
return nil
}
// 解锁表情，Time为解锁时长，单位为秒
func (e *EmojiMod) Unlock(Id, Time int) error {
v, ok := e.List[Id]
func (e *EmojiMod) Unlock(id, time int) error {
v, ok := e.List[id]
if ok {
if v.Ts == 0 {
return nil
}
v.Ts += int64(Time)
v.Ts += int64(time)
return nil
}
now := GoUtil.Now()
e.List[Id] = &Emoji{
Ts: now + int64(Time),
e.List[id] = &Emoji{
Ts: now + int64(time),
AddTime: now,
}
return nil

36
src/server/game/mod/endless/Endless.go
View File

@ -35,19 +35,19 @@ func (e *EndlessMod) InitData() {
}
// 零点更新 重置礼包
func (e *EndlessMod) ZeroUpdate(MaxMoney float64, Lv int) {
func (e *EndlessMod) ZeroUpdate(maxMoney float64, lv int) {
e.List = make(map[int]*Endless)
e.Auto = 1
FirstMoney := 0.0
if MaxMoney > 0 {
m := MaxMoney / 10
GradeList := []float64{1.99, 3.99, 5.99, 7.99, 9.99}
firstMoney := 0.0
if maxMoney > 0 {
m := maxMoney / 10
gradeList := []float64{1.99, 3.99, 5.99, 7.99, 9.99}
type duch struct {
Grade float64
Num float64
}
duchList := make([]duch, 0, len(GradeList))
for _, v := range GradeList {
duchList := make([]duch, 0, len(gradeList))
for _, v := range gradeList {
duchList = append(duchList, duch{
Grade: v,
Num: math.Abs(v - m),
@ -57,23 +57,23 @@ func (e *EndlessMod) ZeroUpdate(MaxMoney float64, Lv int) {
sort.Slice(duchList, func(i, j int) bool {
return duchList[i].Num < duchList[j].Num
})
FirstMoney = duchList[0].Grade
if FirstMoney == 0 {
FirstMoney = 9.99
firstMoney = duchList[0].Grade
if firstMoney == 0 {
firstMoney = 9.99
}
}
money := FirstMoney
money := firstMoney
for range 3 {
e.appendGrade(money, Lv)
e.appendGrade(money, lv)
money = endlessCfg.NextMoney(money)
}
e.Id = 1
}
// appendGrade 初始化一档礼包并合并到列表
func (e *EndlessMod) appendGrade(money float64, Lv int) {
r, autoNext := initGrade(money, e.Auto, Lv)
func (e *EndlessMod) appendGrade(money float64, lv int) {
r, autoNext := initGrade(money, e.Auto, lv)
e.Auto = autoNext
for k, v := range r {
e.List[k] = v
@ -82,7 +82,7 @@ func (e *EndlessMod) appendGrade(money float64, Lv int) {
}
// 领取免费礼包
func (e *EndlessMod) GetReward(Lv int) ([]*item.Item, error) {
func (e *EndlessMod) GetReward(lv int) ([]*item.Item, error) {
v, ok := e.List[e.Id]
if !ok {
return nil, fmt.Errorf("EndlessMod Reward Id:%d not found", e.Id)
@ -93,7 +93,7 @@ func (e *EndlessMod) GetReward(Lv int) ([]*item.Item, error) {
delete(e.List, e.Id)
e.Id++
if v1 := e.List[e.Id]; v1 != nil && v1.Type == ENDLESS_TYPE_CHARGE { //领完一阶段 随机新的一阶段
e.appendGrade(endlessCfg.NextMoney(e.LastMoney), Lv)
e.appendGrade(endlessCfg.NextMoney(e.LastMoney), lv)
}
return v.Items, nil
}
@ -114,12 +114,12 @@ func (e *EndlessMod) BackData() *msg.ResEndless {
}
// 处理充值礼包
func (e *EndlessMod) Fire(ChargeId int) []*item.Item {
func (e *EndlessMod) Fire(chargeId int) []*item.Item {
v, ok := e.List[e.Id]
if !ok {
return nil
}
if v.ChargeId != ChargeId {
if v.ChargeId != chargeId {
return nil
}
delete(e.List, e.Id)

86
src/server/game/mod/endless/endless_func.go
View File

@ -8,78 +8,78 @@ import (
)
// 初始化奖励
func InitReward(Energy float64, Lv int) []*item.Item {
func InitReward(energy float64, lv int) []*item.Item {
numRand := map[int]int{1: 30, 2: 60, 3: 10}
Num := Util.RandMap(numRand)
PerEnergy := endlessCfg.GetPerEnergy(item.ITEM_ENERGY_ID)
getNum := func(energy, preEnergy float64) int {
num := int(energy / preEnergy)
num := Util.RandMap(numRand)
perEnergy := endlessCfg.GetPerEnergy(item.ITEM_ENERGY_ID)
getNum := func(energy, perEnergy float64) int {
num := int(energy / perEnergy)
num = int(math.Round(float64(num)/5.0) * 5)
return max(num, 5) // 最少5个能量
}
if Num == 1 {
ItemNum := getNum(Energy, PerEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum)}
if num == 1 {
itemNum := getNum(energy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum)}
}
if Num == 2 {
ItemId := endlessCfg.GetItemId(Energy, 0, Lv)
if len(ItemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(Energy, PerEnergy))}
if num == 2 {
itemId := endlessCfg.GetItemId(energy, 0, lv)
if len(itemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(energy, perEnergy))}
}
RandItem := Util.RandSlice(ItemId)
ItemEnergy := endlessCfg.GetEnergyByItemId(RandItem)
LastEnergy := Energy - ItemEnergy
ItemNum := getNum(LastEnergy, PerEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem, 1)}
randItem := Util.RandSlice(itemId)
itemEnergy := endlessCfg.GetEnergyByItemId(randItem)
lastEnergy := energy - itemEnergy
itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem, 1)}
}
if Num == 3 {
ItemId := endlessCfg.GetItemId(Energy, 0, Lv)
if len(ItemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(Energy, PerEnergy))}
if num == 3 {
itemId := endlessCfg.GetItemId(energy, 0, lv)
if len(itemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(energy, perEnergy))}
}
RandItem1 := Util.RandSlice(ItemId)
Type := endlessCfg.GetType(RandItem1)
ItemEnergy := endlessCfg.GetEnergyByItemId(RandItem1)
LastEnergy := Energy - ItemEnergy
ItemId = endlessCfg.GetItemId(LastEnergy, Type, Lv)
if len(ItemId) == 0 {
ItemNum := getNum(LastEnergy, PerEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem1, 1)}
randItem1 := Util.RandSlice(itemId)
itemType := endlessCfg.GetType(randItem1)
itemEnergy := endlessCfg.GetEnergyByItemId(randItem1)
lastEnergy := energy - itemEnergy
itemId = endlessCfg.GetItemId(lastEnergy, itemType, lv)
if len(itemId) == 0 {
itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem1, 1)}
}
RandItem2 := Util.RandSlice(ItemId)
ItemEnergy = endlessCfg.GetEnergyByItemId(RandItem2)
LastEnergy = LastEnergy - ItemEnergy
ItemNum := getNum(LastEnergy, PerEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem1, 1), item.NewItem(RandItem2, 1)}
randItem2 := Util.RandSlice(itemId)
itemEnergy = endlessCfg.GetEnergyByItemId(randItem2)
lastEnergy = lastEnergy - itemEnergy
itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem1, 1), item.NewItem(randItem2, 1)}
}
return nil
}
// 初始化档次奖励
func initGrade(Money float64, Auto, Lv int) (map[int]*Endless, int) {
Energy := endlessCfg.GetEnergy(Money)
Per := []float64{0.5, 0.3, 0.2, 0.1}
func initGrade(money float64, auto, lv int) (map[int]*Endless, int) {
energy := endlessCfg.GetEnergy(money)
per := []float64{0.5, 0.3, 0.2, 0.1}
result := make(map[int]*Endless)
for i := 1; i < 5; i++ {
Type := ENDLESS_TYPE_FREE
Charge := 0
if i == 1 {
if Money > 0 {
if money > 0 {
Type = ENDLESS_TYPE_CHARGE
Charge = endlessCfg.GetChargeId(Money)
Charge = endlessCfg.GetChargeId(money)
} else {
Type = ENDLESS_TYPE_AD
}
}
result[Auto] = &Endless{
result[auto] = &Endless{
ChargeId: Charge,
Type: Type,
Items: InitReward(Energy*Per[i-1], Lv),
Items: InitReward(energy*per[i-1], lv),
}
Auto++
auto++
}
return result, Auto
return result, auto
}

26
src/server/game/mod/face/Face.go
View File

@ -18,10 +18,10 @@ type Face struct {
AddTime int64
}
func (f *FaceMod) Login(RegisterTime int64) {
func (f *FaceMod) Login(registerTime int64) {
for _, v := range f.List {
if v.AddTime == 0 {
v.AddTime = RegisterTime
v.AddTime = registerTime
}
}
}
@ -33,8 +33,8 @@ func (f *FaceMod) InitData() {
f.List = make(map[int]*Face)
f.SetId = 1
}
InitId := faceCfg.GetInitList()
for _, v := range InitId {
initId := faceCfg.GetInitList()
for _, v := range initId {
if _, ok := f.List[v]; ok {
continue
}
@ -51,29 +51,29 @@ func (f *FaceMod) GetFaceNum() int {
}
// 设置表情，Id为0表示清空表情
func (f *FaceMod) SetFace(Id int) error {
if Id != 0 {
if _, ok := f.List[Id]; !ok {
func (f *FaceMod) SetFace(id int) error {
if id != 0 {
if _, ok := f.List[id]; !ok {
return fmt.Errorf("face id not exist")
}
}
f.SetId = Id
f.SetId = id
return nil
}
// 解锁表情
func (f *FaceMod) Unlock(Id, Time int) error {
v, ok := f.List[Id]
func (f *FaceMod) Unlock(id, time int) error {
v, ok := f.List[id]
if ok {
if v.Ts == 0 {
return nil
}
v.Ts += int64(Time)
v.Ts += int64(time)
return nil
}
now := GoUtil.Now()
f.List[Id] = &Face{
Ts: now + int64(Time),
f.List[id] = &Face{
Ts: now + int64(time),
AddTime: now,
}
return nil

166
src/server/game/mod/friend/Friend.go
View File

@ -189,7 +189,7 @@ type LogInfo struct {
}
// 初始化数据
func (f *FriendMod) InitData(M_DwUin int64) {
func (f *FriendMod) InitData(m_DwUin int64) {
if f.FriendList == nil {
f.FriendList = make(map[int]struct{})
}
@ -225,11 +225,11 @@ func (f *FriendMod) InitData(M_DwUin int64) {
f.NewApplyList = make(map[int]*ApplyInfo)
}
for k, v := range f.Card {
if v.AUid != 0 && !f.CheckFriend(v.AUid) && v.AUid != int(M_DwUin) {
if v.AUid != 0 && !f.CheckFriend(v.AUid) && v.AUid != int(m_DwUin) {
delete(f.Card, k)
continue
}
if v.BUid != 0 && !f.CheckFriend(v.BUid) && v.BUid != int(M_DwUin) {
if v.BUid != 0 && !f.CheckFriend(v.BUid) && v.BUid != int(m_DwUin) {
delete(f.Card, k)
continue
}
@ -259,16 +259,16 @@ func (f *FriendMod) version() {
Uid int
Time int64
}
PlayerList := make([]sortData, 0)
playerList := make([]sortData, 0)
for k, v := range f.NewApplyList {
PlayerList = append(PlayerList, sortData{k, v.Time})
playerList = append(playerList, sortData{k, v.Time})
}
sort.Slice(PlayerList, func(i, j int) bool {
return PlayerList[i].Time > PlayerList[j].Time
sort.Slice(playerList, func(i, j int) bool {
return playerList[i].Time > playerList[j].Time
})
for i := 0; i < len(PlayerList); i++ {
for i := 0; i < len(playerList); i++ {
if i >= friendCfg.GetApplyListLimit() {
delete(f.NewApplyList, PlayerList[i].Uid)
delete(f.NewApplyList, playerList[i].Uid)
}
}
}
@ -308,18 +308,18 @@ func (f *FriendMod) SetSyncId(Id int64) {
}
// 好友交互
func (f *FriendMod) Interact(id, t int, T int64) {
func (f *FriendMod) Interact(id, t int, visitTime int64) {
if _, ok := f.NewFriendList[id]; !ok {
return
}
for _, v := range f.NewFriendList[id].Interact {
if v.Type == t && v.VisitTime < T {
v.VisitTime = T
if v.Type == t && v.VisitTime < visitTime {
v.VisitTime = visitTime
return
}
}
f.NewFriendList[id].Interact = append(f.NewFriendList[id].Interact, &Interact{
VisitTime: T,
VisitTime: visitTime,
Type: t,
})
if len(f.NewFriendList[id].Interact) > 30 {
@ -332,14 +332,14 @@ func (f *FriendMod) GetInteractTime(id int) int64 {
if _, ok := f.NewFriendList[id]; !ok {
return 0
}
var LastTime int64
var lastTime int64
// 获取最近一次拜访或点赞的时间
for _, v := range f.NewFriendList[id].Interact {
if v.VisitTime > LastTime {
LastTime = v.VisitTime
if v.VisitTime > lastTime {
lastTime = v.VisitTime
}
}
return LastTime
return lastTime
}
// 获取好友添加时间
@ -368,13 +368,13 @@ func (f *FriendMod) GetCardInfo(Id string) *card.CardInfo {
}
// 设置卡牌交换信息
func (f *FriendMod) SetCardInfo(CardInfo *card.CardInfo) {
f.Card[CardInfo.Id] = CardInfo
func (f *FriendMod) SetCardInfo(cardInfo *card.CardInfo) {
f.Card[cardInfo.Id] = cardInfo
}
// 删除卡牌交换信息
func (f *FriendMod) DelCardInfo(Id string) {
delete(f.Card, Id)
func (f *FriendMod) DelCardInfo(id string) {
delete(f.Card, id)
}
// 删除好友
@ -389,8 +389,8 @@ func (f *FriendMod) DelFriend(id int) {
}
// 检查是否好友
func (f *FriendMod) CheckFriend(Uid int) bool {
v, ok := f.NewFriendList[Uid]
func (f *FriendMod) CheckFriend(uid int) bool {
v, ok := f.NewFriendList[uid]
return ok && v.DelTime == 0
}
@ -433,14 +433,14 @@ func (f *FriendMod) GetFriendList() map[int]*FriendInfo {
// 获取好友uid列表
func (f *FriendMod) GetSimpleFriendList() []int {
rs := make([]int, 0, len(f.NewFriendList))
res := make([]int, 0, len(f.NewFriendList))
for k, v := range f.NewFriendList {
if v.DelTime != 0 {
continue
}
rs = append(rs, k)
res = append(res, k)
}
return rs
return res
}
// 检查是否有新的好友
@ -450,7 +450,7 @@ func (f *FriendMod) CheckAddBefore(uid int) bool {
}
// 收到申请
func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
func (f *FriendMod) AddFriendApply(uid, aType int, sendTime int64) bool {
if f.DailyGetApply >= friendCfg.GetDailyGetApplyLimit() {
return true
}
@ -461,7 +461,7 @@ func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
}
}
// 好友申请列表只保留十条，好友码申请不受数量限制
if code_type >= friendCfg.GetApplyListLimit() && Type != APPLY_TYPE_FRIEND_CODE {
if code_type >= friendCfg.GetApplyListLimit() && aType != APPLY_TYPE_FRIEND_CODE {
return true
}
var minTime int64
@ -478,8 +478,8 @@ func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
}
}
}
f.NewApplyList[Uid] = &ApplyInfo{
Type: Type,
f.NewApplyList[uid] = &ApplyInfo{
Type: aType,
Time: sendTime,
}
f.DailyGetApply++
@ -487,29 +487,29 @@ func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
}
// 发送申请
func (f *FriendMod) AddSendApply(Uid int) bool {
f.SendApply[Uid] = GoUtil.Now()
func (f *FriendMod) AddSendApply(uid int) bool {
f.SendApply[uid] = GoUtil.Now()
return false
}
func (f *FriendMod) CheckSendApply(Id int) bool {
_, ok := f.SendApply[Id]
func (f *FriendMod) CheckSendApply(uid int) bool {
_, ok := f.SendApply[uid]
return ok
}
// 获取发送申请时间
func (f *FriendMod) GetSendApplyTime(Id int) int64 {
if t, ok := f.SendApply[Id]; ok {
func (f *FriendMod) GetSendApplyTime(uid int) int64 {
if t, ok := f.SendApply[uid]; ok {
return t
}
return 0
}
// 同意申请
func (f *FriendMod) AgreeApply(UId int) {
f.AddFriend(UId)
delete(f.SendApply, UId)
delete(f.NewApplyList, UId)
func (f *FriendMod) AgreeApply(uid int) {
f.AddFriend(uid)
delete(f.SendApply, uid)
delete(f.NewApplyList, uid)
}
// 增加好友日志
@ -526,9 +526,9 @@ func (f *FriendMod) AddLog(uid, ltype int, param string, send int64) int {
case LOG_TYPE_HANDBOOK_UPVOTE, LOG_TYPE_PLAYROOM_UPVOTE:
f.AddBubble(f.AutoId, ltype, nil)
case LOG_TYPE_TREASURE_HELP:
ItemNum := GoUtil.RandNum(2, 5)
ItemList := []*item.Item{item.NewItem(item.ITEM_STAR_ID, ItemNum)}
f.AddBubble(f.AutoId, ltype, ItemList)
itemNum := GoUtil.RandNum(2, 5)
items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, itemNum)}
f.AddBubble(f.AutoId, ltype, items)
}
if len(f.Log) > 30 {
f.Log = f.Log[len(f.Log)-30:]
@ -537,18 +537,18 @@ func (f *FriendMod) AddLog(uid, ltype int, param string, send int64) int {
}
// 增加气泡
func (f *FriendMod) AddBubble(Id, Type int, ItemList []*item.Item) {
f.Bubble[Id] = &BubbleInfo{
Id: Id,
func (f *FriendMod) AddBubble(id, bType int, items []*item.Item) {
f.Bubble[id] = &BubbleInfo{
Id: id,
Time: GoUtil.Now(),
Type: Type,
ItemList: ItemList,
Type: bType,
ItemList: items,
}
}
// 获取气泡信息
func (f *FriendMod) GetBubble(Id int) *msg.FriendBubbleInfo {
if v, ok := f.Bubble[Id]; ok {
func (f *FriendMod) GetBubble(id int) *msg.FriendBubbleInfo {
if v, ok := f.Bubble[id]; ok {
return &msg.FriendBubbleInfo{
Id: int32(v.Id),
Type: int32(v.Type),
@ -559,16 +559,16 @@ func (f *FriendMod) GetBubble(Id int) *msg.FriendBubbleInfo {
}
func (f *FriendMod) BubbleBackData() *msg.ResFriendBubble {
rs := make([]*msg.FriendBubbleInfo, 0, len(f.Bubble))
res := make([]*msg.FriendBubbleInfo, 0, len(f.Bubble))
for _, v := range f.Bubble {
rs = append(rs, &msg.FriendBubbleInfo{
res = append(res, &msg.FriendBubbleInfo{
Id: int32(v.Id),
Type: int32(v.Type),
Items: item.ItemToMsg(v.ItemList),
})
}
return &msg.ResFriendBubble{
Bubble: rs,
Bubble: res,
}
}
@ -582,11 +582,11 @@ func (f *FriendMod) ResetGoldCardEx() {
}
// 增加活动日志
func (f *FriendMod) AddActLog(Type int, Param string) {
func (f *FriendMod) AddActLog(actType int, param string) {
f.ActivityLog = append(f.ActivityLog, &ActLogInfo{
Type: Type,
Type: actType,
Time: GoUtil.Now(),
Param: Param,
Param: param,
})
if len(f.ActivityLog) > 20 {
f.ActivityLog = f.ActivityLog[len(f.ActivityLog)-20:]
@ -594,10 +594,10 @@ func (f *FriendMod) AddActLog(Type int, Param string) {
}
// 时间线点赞
func (f *FriendMod) Upvote(Id int) ([]*item.Item, int, error) {
func (f *FriendMod) Upvote(id int) ([]*item.Item, int, error) {
info := &LogInfo{}
for _, v := range f.Log {
if v.Id == Id {
if v.Id == id {
info = v
break
}
@ -613,8 +613,8 @@ func (f *FriendMod) Upvote(Id int) ([]*item.Item, int, error) {
}
// 获取时间线点赞奖励
func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
info, ok := f.Bubble[Id]
func (f *FriendMod) GetReward(id int) ([]*item.Item, error) {
info, ok := f.Bubble[id]
if !ok {
return nil, fmt.Errorf("bubble not exist")
}
@ -627,13 +627,12 @@ func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
default:
return nil, fmt.Errorf("log type not support")
}
delete(f.Bubble, Id)
delete(f.Bubble, id)
return reward, nil
}
// 增加心愿单申请
func (f *FriendMod) AddWishApply(Uid int64) error {
func (f *FriendMod) AddWishApply(uid int64) error {
return nil
}
@ -649,8 +648,7 @@ func (f *FriendMod) GetWishApply() []*ApplyInfo {
}
// 同意心愿单申请
func (f *FriendMod) ApplyWish(Uid int64) error {
func (f *FriendMod) ApplyWish(uid int64) error {
return fmt.Errorf("wish apply not exist")
}
@ -663,28 +661,28 @@ func (f *FriendMod) GetActLogLast() *ActLogInfo {
}
// 增加待回复请求
func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64, Items []*item.Item) *ReplyInfo {
func (f *FriendMod) AddReplyInfo(uid int, rType int, param string, endTime int64, items []*item.Item) *ReplyInfo {
f.AutoId++
Reply := &ReplyInfo{
reply := &ReplyInfo{
Id: f.AutoId,
Uid: Uid,
Type: Type,
Param: Param,
Uid: uid,
Type: rType,
Param: param,
AddTime: GoUtil.Now(),
EndTime: EndTime,
Items: Items,
EndTime: endTime,
Items: items,
}
f.ReplyList = append(f.ReplyList, Reply)
f.ReplyList = append(f.ReplyList, reply)
if len(f.ReplyList) > 20 {
f.ReplyList = f.ReplyList[len(f.ReplyList)-20:]
}
return Reply
return reply
}
// 回复请求
func (f *FriendMod) ReplyFriend(LogId int) *ReplyInfo {
func (f *FriendMod) ReplyFriend(logId int) *ReplyInfo {
for _, v := range f.ReplyList {
if v.Id == LogId {
if v.Id == logId {
v.Status = 1
v.ReplyTime = GoUtil.Now()
return v
@ -721,14 +719,14 @@ func (f *FriendMod) GetSponsorReward() ([]*item.Item, error) {
}
// 增加好友推荐记录
func (f *FriendMod) AddRecommend(Uid int) {
func (f *FriendMod) AddRecommend(uid int) {
now := GoUtil.Now()
if v, ok := f.RecommendList[Uid]; ok {
if v, ok := f.RecommendList[uid]; ok {
v.Time = now
return
}
f.RecommendList[Uid] = &Recommend{
Uid: Uid,
f.RecommendList[uid] = &Recommend{
Uid: uid,
Time: now,
}
}
@ -749,14 +747,14 @@ func (f *FriendMod) AddDailyRecommend() error {
return nil
}
func (f *FriendMod) GreetingFriend(Uid int) {
if v, ok := f.NewFriendList[Uid]; ok {
func (f *FriendMod) GreetingFriend(uid int) {
if v, ok := f.NewFriendList[uid]; ok {
v.Greeting = true
}
}
func (f *FriendMod) CheckGreeting(Uid int) bool {
if v, ok := f.NewFriendList[Uid]; ok {
func (f *FriendMod) CheckGreeting(uid int) bool {
if v, ok := f.NewFriendList[uid]; ok {
return v.Greeting
}
return false

12
src/server/game/mod/friend_treasure.go/friend_treasure.go
View File

@ -6,7 +6,6 @@ import (
"server/game/mod/item"
GoUtil "server/game_util"
"server/msg"
"server/pkg/github.com/name5566/leaf/log"
)
type FriendTreasureMod struct {
@ -47,11 +46,11 @@ func (f *FriendTreasureMod) ZeroUpdate() {
}
// 初始化游戏数据
func (f *FriendTreasureMod) InitGame(List []*msg.TreasureInfo, List2 []int32) {
for _, v := range List {
func (f *FriendTreasureMod) InitGame(list []*msg.TreasureInfo, list2 []int32) {
for _, v := range list {
f.List[int(v.Pos)] = v
}
f.List2 = List2
f.List2 = list2
f.Status = GAME_STATUS_START
}
@ -62,18 +61,17 @@ func (f *FriendTreasureMod) AddStar(star, factor int) {
}
// 翻牌
func (f *FriendTreasureMod) Flip(Pos int) ([]*item.Item, int64, error) {
func (f *FriendTreasureMod) Flip(pos int) ([]*item.Item, int64, error) {
if f.Status == GAME_STATUS_IDLE {
return nil, 0, fmt.Errorf("game not start")
}
f.Shift++
info, ok := f.List[Pos]
info, ok := f.List[pos]
if !ok {
return nil, 0, fmt.Errorf("invalid position")
}
info.Status = GAME_STATUS_START
if info.Uid != 0 {
log.Debug("uid:%v", info.Uid)
f.Uids = append(f.Uids, info.Uid)
}
if info.Type == FRIEND_TYPE_ALIVE {

44
src/server/game/mod/guess_color/guess_color.go
View File

@ -51,16 +51,16 @@ func (g *GuessColorMod) InitData() {
}
}
func (g *GuessColorMod) Login(Id int) int {
OldId := g.Id
if Id == 0 {
func (g *GuessColorMod) Login(id int) int {
oldId := g.Id
if id == 0 {
g.Id = 0
return 0
}
if g.Id == Id {
if g.Id == id {
return 0
}
g.Id = Id
g.Id = id
g.Pass = 1
g.Opponent = simplePlayer{
Name: randnameCfg.GetRandName(),
@ -71,11 +71,11 @@ func (g *GuessColorMod) Login(Id int) int {
g.MapList = nil
g.OMap = nil
g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
return OldId
return oldId
}
func (g *GuessColorMod) ZeroUpdate(Id int) {
g.Login(Id)
func (g *GuessColorMod) ZeroUpdate(id int) {
g.Login(id)
}
func (g *GuessColorMod) FirstIn() []*item.Item {
@ -87,27 +87,27 @@ func (g *GuessColorMod) FirstIn() []*item.Item {
}
// 进行猜色
func (g *GuessColorMod) Take(Map map[int32]int32, OMap map[int32]int32) {
if len(Map) > 0 {
g.MapList = append(g.MapList, Map)
func (g *GuessColorMod) Take(guessMap map[int32]int32, oMap map[int32]int32) {
if len(guessMap) > 0 {
g.MapList = append(g.MapList, guessMap)
g.Guess++
}
g.OMap = OMap
g.OMap = oMap
}
// 获取失败奖励
func (g *GuessColorMod) GetLoseItem() []*item.Item {
Items := guesscolorCfg.GetLoseItem(g.Id)
Num := guesscolorCfg.GetPassNum(g.Pass)
items := guesscolorCfg.GetLoseItem(g.Id)
num := guesscolorCfg.GetPassNum(g.Pass)
if len(g.MapList) > 0 {
LastMap := g.MapList[len(g.MapList)-1]
for _, v := range LastMap {
lastMap := g.MapList[len(g.MapList)-1]
for _, v := range lastMap {
if v > 10 {
Num--
num--
}
}
}
return item.MutilItem(Items, Num)
return item.MutilItem(items, num)
}
// 获取奖励
@ -118,15 +118,15 @@ func (g *GuessColorMod) GetReward() ([]*item.Item, error) {
if g.Guess < g.WinTime {
return nil, fmt.Errorf("guess process not finish")
}
Type := GAME_STATUS_FAIL
gType := GAME_STATUS_FAIL
if g.Guess == guesscolorCfg.GetPassNum(g.Pass) {
Type = GAME_STATUS_SUCCESS
gType = GAME_STATUS_SUCCESS
}
Item := guesscolorCfg.GetRewardItem(g.Pass, Type)
items := guesscolorCfg.GetRewardItem(g.Pass, gType)
g.Pass++
g.Guess = 0
g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
g.MapList = nil
g.OMap = nil
return Item, nil
return items, nil
}

14
src/server/game/mod/guide/Guide.go
View File

@ -22,14 +22,14 @@ func (g *Guide) InitData() {
}
}
func (g *Guide) GetReward(Id int) ([]*item.Item, error) {
Items, Num := guidecfg.GetGuideReward(Id)
n := g.Reward[Id]
if n >= Num {
return nil, fmt.Errorf("Guide GetReward Id:%v has been received", Id)
func (g *Guide) GetReward(id int) ([]*item.Item, error) {
items, num := guidecfg.GetGuideReward(id)
n := g.Reward[id]
if n >= num {
return nil, fmt.Errorf("Guide GetReward Id:%v has been received", id)
}
g.Reward[Id]++
return Items, nil
g.Reward[id]++
return items, nil
}
func (g *Guide) BackData() *msg.ResGuideInfo {

34
src/server/game/mod/guide_task/guide_task.go
View File

@ -51,15 +51,15 @@ func (gt *GuideTaskMod) Login() {
if gt.UnlockTime == 0 {
return
}
LoginDay := (GoUtil.Now()-gt.UnlockTime)/86400 + 1
gt.LoginDay[int(LoginDay)] = struct{}{}
loginDay := (GoUtil.Now()-gt.UnlockTime)/86400 + 1
gt.LoginDay[int(loginDay)] = struct{}{}
gt.Trigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_GUIDE_LOGIN, A: []interface{}{len(gt.LoginDay)}})
}
// 解锁引导任务
func (gt *GuideTaskMod) Unlock(lv int) bool {
UnLockLv := GuideTaskCfg.GetUnlockLv()
if lv >= UnLockLv && gt.UnlockTime == 0 {
unLockLv := GuideTaskCfg.GetUnlockLv()
if lv >= unLockLv && gt.UnlockTime == 0 {
gt.UnlockTime = GoUtil.Now()
gt.Login()
return true
@ -77,7 +77,7 @@ func (gt *GuideTaskMod) CheckOpen() bool {
return GoUtil.Now()-gt.UnlockTime <= guideTaskOpenSeconds
}
func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
func (gt *GuideTaskMod) Trigger(tr *quest.Trigger) bool {
if !gt.CheckOpen() {
return false
}
@ -89,7 +89,7 @@ func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
if v.Quest.Label == quest.TRIGGER_LABEL_GUIDE_LOGIN {
v.Quest.A = []interface{}{gt.UnlockTime}
}
update = quest.TriggerQuestProgress(&v.Quest, Tr) || update
update = quest.TriggerQuestProgress(&v.Quest, tr) || update
if v.Quest.Status {
v.Status = quest.QUEST_STATUS_FINISH
}
@ -98,34 +98,34 @@ func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
}
// 获取任务奖励
func (gt *GuideTaskMod) GetTaskReward(Id int) ([]*item.Item, error) {
task, ok := gt.Tasks[Id]
func (gt *GuideTaskMod) GetTaskReward(id int) ([]*item.Item, error) {
task, ok := gt.Tasks[id]
if !ok {
return nil, fmt.Errorf("guide task %d not found", Id)
return nil, fmt.Errorf("guide task %d not found", id)
}
if task.Status != quest.QUEST_STATUS_FINISH {
return nil, fmt.Errorf("guide task %d not finished or already claimed", Id)
return nil, fmt.Errorf("guide task %d not finished or already claimed", id)
}
task.Status = quest.QUEST_STATUS_REWARD
gt.Active += GuideTaskCfg.GetTaskActive(Id)
return GuideTaskCfg.GetTaskRewardById(Id), nil
gt.Active += GuideTaskCfg.GetTaskActive(id)
return GuideTaskCfg.GetTaskRewardById(id), nil
}
// 获取活跃度奖励
func (gt *GuideTaskMod) GetActiveReward(Id int) ([]*item.Item, error) {
func (gt *GuideTaskMod) GetActiveReward(id int) ([]*item.Item, error) {
for _, v := range gt.Reward {
if v == Id {
if v == id {
return nil, fmt.Errorf("active reward already got")
}
}
items, needActive := GuideTaskCfg.GetActiveReward(Id)
items, needActive := GuideTaskCfg.GetActiveReward(id)
if items == nil {
return nil, fmt.Errorf("no active reward id %d", Id)
return nil, fmt.Errorf("no active reward id %d", id)
}
if gt.Active < needActive {
return nil, fmt.Errorf("active not enough")
}
gt.Reward = append(gt.Reward, Id)
gt.Reward = append(gt.Reward, id)
return items, nil
}

38
src/server/game/mod/handbook/Handbook.go
View File

@ -33,62 +33,62 @@ func (h *Handbook) InitData() {
}
// 解锁图鉴
func (h *Handbook) SetHandbook(Id int) bool {
if Id <= 0 {
func (h *Handbook) SetHandbook(id int) bool {
if id <= 0 {
return false
}
_, ok := h.BookList[Id]
_, ok := h.BookList[id]
if ok {
return false
}
h.BookList[Id] = STATUS_IDLE
h.BookList[id] = STATUS_IDLE
return true
}
// 领取图鉴奖励
func (h *Handbook) GetHandbookReward(Id int) error {
status, ok := h.BookList[Id]
func (h *Handbook) GetHandbookReward(id int) error {
status, ok := h.BookList[id]
if !ok {
return errors.New("图鉴未解锁")
}
if status == STATUS_REWARD {
return errors.New("图鉴奖励已领取")
}
h.BookList[Id] = STATUS_REWARD
h.BookList[id] = STATUS_REWARD
return nil
}
func (h *Handbook) CollectItem(Id string, AllChess []int) ([]*item.Item, error) {
func (h *Handbook) CollectItem(id string, AllChess []int) ([]*item.Item, error) {
for _, v := range AllChess {
if _, ok := h.BookList[v]; !ok {
return nil, fmt.Errorf("图鉴未解锁")
}
}
if _, ok := h.Collect[Id]; ok {
if _, ok := h.Collect[id]; ok {
return nil, fmt.Errorf("已经领取过该奖励")
}
Reward := handbookCfg.GetHandbookReward(Id)
if Reward == nil {
reward := handbookCfg.GetHandbookReward(id)
if reward == nil {
return nil, fmt.Errorf("奖励不存在")
}
h.Collect[Id] = struct{}{}
return Reward, nil
h.Collect[id] = struct{}{}
return reward, nil
}
func (h *Handbook) BackData() *msg.Handbook {
BookList := make([]*msg.HandbookInfo, 0, len(h.BookList))
bookList := make([]*msg.HandbookInfo, 0, len(h.BookList))
for k, v := range h.BookList {
BookList = append(BookList, &msg.HandbookInfo{
bookList = append(bookList, &msg.HandbookInfo{
ChessId: int32(k),
Status: int32(v),
})
}
Collect := make([]string, 0, len(h.Collect))
collect := make([]string, 0, len(h.Collect))
for k := range h.Collect {
Collect = append(Collect, k)
collect = append(collect, k)
}
return &msg.Handbook{
Handbooks: BookList,
Collect: Collect,
Handbooks: bookList,
Collect: collect,
}
}

18
src/server/game/mod/invite/invite.go
View File

@ -27,25 +27,25 @@ func (i *InviteMod) AddInvite(id int) error {
return nil
}
func (i *InviteMod) GetReward(Index int) ([]*item.Item, error) {
if Index <= i.GetIndex {
func (i *InviteMod) GetReward(index int) ([]*item.Item, error) {
if index <= i.GetIndex {
return nil, fmt.Errorf("index error")
}
var Items []*item.Item
var items []*item.Item
cur := i.GetIndex
for cur < Index {
for cur < index {
cur++
Need, Reward := inviteCfg.GetInviteReward(cur)
if Need == 0 {
need, reward := inviteCfg.GetInviteReward(cur)
if need == 0 {
return nil, fmt.Errorf("invite reward not found")
}
if len(i.InviteList) < Need {
if len(i.InviteList) < need {
return nil, fmt.Errorf("invite not enough")
}
Items = item.Merge(Items, Reward)
items = item.Merge(items, reward)
}
i.GetIndex = cur
return Items, nil
return items, nil
}
func (i *InviteMod) BackData() *msg.ResInviteFriendData {

30
src/server/game/mod/item/Item.go
View File

@ -184,18 +184,18 @@ func ItemListToMsg(items []*Item) *msg.ItemList {
}
// 道具叠加
func Merge(Item1, Item2 []*Item) []*Item {
if Item1 == nil {
return Item2
func Merge(item1, item2 []*Item) []*Item {
if item1 == nil {
return item2
}
if Item2 == nil {
return Item1
if item2 == nil {
return item1
}
l := make(map[int]int)
for _, v := range Item1 {
for _, v := range item1 {
l[v.Id] += v.Num
}
for _, v := range Item2 {
for _, v := range item2 {
l[v.Id] += v.Num
}
res := make([]*Item, 0, len(l))
@ -207,12 +207,12 @@ func Merge(Item1, Item2 []*Item) []*Item {
}
return res
}
func MutilItem(i []*Item, num int) []*Item {
if i == nil {
func MutilItem(item1 []*Item, num int) []*Item {
if item1 == nil {
return nil
}
res := make([]*Item, 0, len(i))
for _, v := range i {
res := make([]*Item, 0, len(item1))
for _, v := range item1 {
res = append(res, &Item{
Id: v.Id,
Num: v.Num * num,
@ -221,12 +221,12 @@ func MutilItem(i []*Item, num int) []*Item {
return res
}
func MutilItemFloat(i []*Item, num float64) []*Item {
if i == nil {
func MutilItemFloat(item1 []*Item, num float64) []*Item {
if item1 == nil {
return nil
}
res := make([]*Item, 0, len(i))
for _, v := range i {
res := make([]*Item, 0, len(item1))
for _, v := range item1 {
res = append(res, &Item{
Id: v.Id,
Num: int(math.Round(float64(v.Num) * num)),

389
src/server/game/mod/limited_time_event/limited_time_event.go
View File

@ -6,7 +6,6 @@ import (
limitedTimeEventCfg "server/conf/limited_time_event"
mergeDataCfg "server/conf/merge_data"
"server/game/mod/item"
"server/game/mod/order"
GoUtil "server/game_util"
"server/msg"
)
@ -85,7 +84,7 @@ type PaybackDay struct {
Count int
}
func (l *LimitedTimeEventMod) InitData(Lv int) {
func (l *LimitedTimeEventMod) InitData(lv int) {
if l.EventList == nil {
l.EventList = make(map[int]*LTEInfo)
}
@ -98,8 +97,8 @@ func (l *LimitedTimeEventMod) InitData(Lv int) {
}
if l.ProgressMax == 0 {
l.Lv = Lv
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(Lv, l.BonusNum)
l.Lv = lv
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(lv, l.BonusNum)
}
if !l.First {
l.First = true
@ -115,25 +114,25 @@ func (l *LimitedTimeEventMod) InitData(Lv int) {
}
if len(l.ProgressReward) == 0 {
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
l.fillProgressReward(RandMap, SelectNum)
}
}
func (l *LimitedTimeEventMod) ZeroUpdate(Lv int) {
func (l *LimitedTimeEventMod) ZeroUpdate(lv int) {
if !l.FirstReward {
return
}
l.Lv = Lv
l.Lv = lv
l.BonusNum = 0
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(Lv, l.BonusNum)
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(lv, l.BonusNum)
}
// 判断限时事件是否存在
func (l *LimitedTimeEventMod) CheckExist(EventId int) bool {
info, ok := l.EventList[EventId]
func (l *LimitedTimeEventMod) CheckExist(eventId int) bool {
info, ok := l.EventList[eventId]
if !ok {
return false
}
@ -142,16 +141,15 @@ func (l *LimitedTimeEventMod) CheckExist(EventId int) bool {
}
// 触发限时事件
func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) {
if Lv < 4 {
func (l *LimitedTimeEventMod) Trigger(lv int) (int, []int, []int) {
if lv < 4 {
return 0, nil, nil
}
TriggerEvent := limitedTimeEventCfg.GetLimitedTimeEventCfg()
TimeoutEvent := make([]int, 0)
AddEvent := make([]int, 0)
Now := GoUtil.Now()
for _, v := range TriggerEvent {
triggerEvent := limitedTimeEventCfg.GetLimitedTimeEventCfg()
timeoutEvent := make([]int, 0)
addEvent := make([]int, 0)
now := GoUtil.Now()
for _, v := range triggerEvent {
if _, ok := l.Triggered[v.Id]; ok { //不重复触发
continue
}
@ -159,57 +157,54 @@ func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) {
info.Remian += int64(v.Duration)
} else {
LTEInfo := &LTEInfo{
StartT: Now,
StartT: now,
Remian: int64(v.Duration),
}
initEventInfo(LTEInfo, v.EventId)
l.EventList[v.EventId] = LTEInfo
AddEvent = append(AddEvent, v.EventId)
addEvent = append(addEvent, v.EventId)
}
l.Triggered[v.Id] = struct{}{}
}
Remain := 0
remain := 0
//删除过期事件
for k, v := range l.EventList {
EndTime := v.StartT + v.Remian
if k == EVENT_TYPE_CAT_TRICK {
EndTime += 5 * 60 // 猫咪戏法事件显示时间为5分钟
}
if EndTime <= Now {
endTime := v.StartT + v.Remian
if endTime <= now {
delete(l.EventList, k)
TimeoutEvent = append(TimeoutEvent, k)
timeoutEvent = append(timeoutEvent, k)
continue
}
NowRemain := (v.StartT + v.Remian) - Now
if Remain > 0 {
Remain = min(Remain, int(NowRemain))
nowRemain := (v.StartT + v.Remian) - now
if remain > 0 {
remain = min(remain, int(nowRemain))
} else {
Remain = int(NowRemain)
remain = int(nowRemain)
}
}
return Remain, TimeoutEvent, AddEvent
return remain, timeoutEvent, addEvent
}
// 增加限时事件
func (l *LimitedTimeEventMod) AddEvent(EventId, Duration int) int64 {
v, ok := l.EventList[EventId]
if EventId == EVENT_TYPE_CAT_DAY_SALE {
func (l *LimitedTimeEventMod) AddEvent(eventId, duration int) int64 {
v, ok := l.EventList[eventId]
if eventId == EVENT_TYPE_CAT_DAY_SALE {
l.LastCatDaySale = GoUtil.Now()
}
if ok && v.StartT+v.Remian > GoUtil.Now() {
// 事件未过期
v.Remian += int64(Duration)
addEventInfo(v, EventId, Duration)
v.Remian += int64(duration)
addEventInfo(v, eventId, duration)
} else {
Event := &LTEInfo{
Remian: int64(Duration),
Remian: int64(duration),
StartT: GoUtil.Now(),
}
initEventInfo(Event, EventId)
l.EventList[EventId] = Event
initEventInfo(Event, eventId)
l.EventList[eventId] = Event
}
return l.EventList[EventId].Remian + l.EventList[EventId].StartT
return l.EventList[eventId].Remian + l.EventList[eventId].StartT
}
// 每周刷新
@ -217,34 +212,35 @@ func (l *LimitedTimeEventMod) WeekUpdate() {
l.Triggered = make(map[int]struct{})
}
func (l *LimitedTimeEventMod) GetMoneyCatReward(ChessList []int) []*item.Item {
L := l.EventList[EVENT_TYPE_MONEY_CAT]
if L == nil {
func (l *LimitedTimeEventMod) GetMoneyCatReward(chessList []int) []*item.Item {
eventInfo := l.EventList[EVENT_TYPE_MONEY_CAT]
if eventInfo == nil {
return nil
}
star := mergeDataCfg.GetMergeStar(chessList)
d, ok := eventInfo.D.(*MoneyCat)
if !ok {
return nil
}
Star := mergeDataCfg.GetMergeStar(ChessList)
d := L.D.(*MoneyCat)
mul := d.Mul
MaxId := limitedTimeEventCfg.GetMoneyCatMax()
NextId := min(d.Id+1, MaxId)
NextMul, Cd := limitedTimeEventCfg.GetMoneyCat(NextId)
d.Id = NextId
d.Mul = NextMul
maxId := limitedTimeEventCfg.GetMoneyCatMax()
nextId := min(d.Id+1, maxId)
nextMul, Cd := limitedTimeEventCfg.GetMoneyCat(nextId)
d.Id = nextId
d.Mul = nextMul
d.EndTime = GoUtil.Now() + int64(Cd)
Star = int(math.Ceil(float64(Star) * (mul - 1)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: Star}}
star = int(math.Ceil(float64(star) * (mul - 1)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: star}}
}
func (l *LimitedTimeEventMod) BackData() *msg.ResLimitEvent {
Res := &msg.ResLimitEvent{}
EventList := make(map[int32]*msg.LimitEvent)
res := &msg.ResLimitEvent{}
eventList := make(map[int32]*msg.LimitEvent)
for k, v := range l.EventList {
EventList[int32(k)] = getLimitEventMsg(k, v)
eventList[int32(k)] = getLimitEventMsg(k, v)
}
Res.LimitEventList = EventList
return Res
res.LimitEventList = eventList
return res
}
func (l *LimitedTimeEventMod) ProgressBackData() *msg.ResLimitEventProgress {
@ -260,16 +256,14 @@ func (l *LimitedTimeEventMod) ProgressBackData() *msg.ResLimitEventProgress {
}
// 获取流星雨奖励
func (l *LimitedTimeEventMod) GetMeteorReward(MergeList, EmitList []int) []*item.Item {
energy := order.GetVirtualEnergy(MergeList, EmitList)
NewStar := int(max(math.Ceil(float64(energy)/0.36*0.1), 1))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: NewStar}}
func (l *LimitedTimeEventMod) GetMeteorReward(virtualEnergy int) []*item.Item {
newStar := int(max(math.Ceil(float64(virtualEnergy)/0.36*0.1), 1))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: newStar}}
}
// 获取宝箱雨奖励
func (l *LimitedTimeEventMod) GetChestReward(MergeList, EmitList []int) []*item.Item {
energy := order.GetVirtualEnergy(MergeList, EmitList)
star := math.Ceil(float64(energy) / 10 / 2.5)
func (l *LimitedTimeEventMod) GetChestReward(virtualEnergy int) []*item.Item {
star := math.Ceil(float64(virtualEnergy) / 10 / 2.5)
return []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, int(star))}
}
@ -287,116 +281,116 @@ func (l *LimitedTimeEventMod) GetSceneDashReward() (int, []*item.Item, error) {
return 0, nil, fmt.Errorf("no dash times")
}
limitInfo.Info["Times"] = times - 1
ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
Id := GoUtil.RandMap(ProbList)
Items := limitedTimeEventCfg.GetSenceJackpotReward(Id)
if len(Items) > 1 {
probList := limitedTimeEventCfg.GetSenceJackpotProb()
id := GoUtil.RandMap(probList)
items := limitedTimeEventCfg.GetSenceJackpotReward(id)
if len(items) > 1 {
// 多个奖励时，随机选择一个
Items = []*item.Item{GoUtil.RandItem(Items)}
items = []*item.Item{GoUtil.RandItem(items)}
}
return Id, Items, nil
return id, items, nil
}
// 获取连击快手奖励
func (l *LimitedTimeEventMod) GetFastProduceReward(Energy int) ([]*item.Item, error) {
Event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
if !ok {
return nil, fmt.Errorf("FastProduce event not exist")
}
Now := GoUtil.Now()
if Now < GoUtil.Int64(Event.Info["NextPlay"]) {
now := GoUtil.Now()
if now < GoUtil.Int64(event.Info["NextPlay"]) {
return nil, fmt.Errorf("FastProduce CD")
}
return limitedTimeEventCfg.GetFastProduceReward(Energy), nil
}
func (l *LimitedTimeEventMod) ResetFastProduceCD() {
Event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
if !ok {
return
}
Event.Info["NextPlay"] = 0
event.Info["NextPlay"] = 0
}
func (l *LimitedTimeEventMod) GetFastProduceInfo() (int64, int) {
Event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
if !ok {
return 0, 0
}
return GoUtil.Int64(Event.Info["NextPlay"]), GoUtil.Int(Event.Info["Times"])
return GoUtil.Int64(event.Info["NextPlay"]), GoUtil.Int(event.Info["Times"])
}
// 增加进度
func (l *LimitedTimeEventMod) AddProgress(Lv int) {
UnlockLv := limitedTimeEventCfg.GetUnlockLv()
if Lv < UnlockLv {
func (l *LimitedTimeEventMod) AddProgress(lv int) {
unlockLv := limitedTimeEventCfg.GetUnlockLv()
if lv < unlockLv {
return
}
l.Progress++
}
// 选择进度奖励
func (l *LimitedTimeEventMod) SelectProgressReward(Id, Lv, Energy int) ([]*item.Item, int, int, map[int]int, error) {
RewardId, ok := l.ProgressReward[Id]
RewardList := l.ProgressReward
func (l *LimitedTimeEventMod) SelectProgressReward(id, lv, energy int) ([]*item.Item, int, int, map[int]int, error) {
rewardId, ok := l.ProgressReward[id]
rewardList := l.ProgressReward
if !ok {
return nil, 0, 0, nil, fmt.Errorf("RewardId not exist")
}
Item := limitedTimeEventCfg.GetProgressReward(RewardId)
OrderNum := l.ProgressMax
l.LastSelect = RewardId
items := limitedTimeEventCfg.GetProgressReward(rewardId)
orderNum := l.ProgressMax
l.LastSelect = rewardId
l.ProgressReward = make(map[int]int)
l.Progress = 0
l.BonusNum++
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(l.Lv, l.BonusNum)
// 重新生成进度奖励
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
selectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
bonusLv := limitedTimeEventCfg.GetBonusLv(lv)
randMap := limitedTimeEventCfg.GetProgressRewardRand(bonusLv)
// 体力小于200 high roller事件不进池子
if Energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
if energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
}
if GoUtil.Now()-l.LastCatDaySale < limitedTimeEventCfg.GetCatSaleCD() {
// 参与猫咪大甩卖活动时，猫咪大甩卖事件不进池子
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_CAT_DAY_SALE))
delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_CAT_DAY_SALE))
}
l.fillProgressReward(RandMap, SelectNum)
l.fillProgressReward(randMap, selectNum)
l.FirstReward = true
return Item, limitedTimeEventCfg.GetProgressRewardType(RewardId), OrderNum, RewardList, nil
return items, limitedTimeEventCfg.GetProgressRewardType(rewardId), orderNum, rewardList, nil
}
func (l *LimitedTimeEventMod) DebugProgressRewardList(Lv, Energy int) map[int]int {
func (l *LimitedTimeEventMod) DebugProgressRewardList(lv, energy int) map[int]int {
// 重新生成进度奖励
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
selectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
bonusLv := limitedTimeEventCfg.GetBonusLv(lv)
randMap := limitedTimeEventCfg.GetProgressRewardRand(bonusLv)
// 体力小于200 high roller事件不进池子
if Energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
if energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
}
if GoUtil.Now()-l.LastCatDaySale < limitedTimeEventCfg.GetCatSaleCD() {
// 参与猫咪大甩卖活动时，猫咪大甩卖事件不进池子
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_CAT_DAY_SALE))
delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_CAT_DAY_SALE))
}
l.fillProgressReward(RandMap, SelectNum)
l.fillProgressReward(randMap, selectNum)
return l.ProgressReward
}
// fillProgressReward 随机填充进度奖励（最多尝试10次避免与上次相同）
func (l *LimitedTimeEventMod) fillProgressReward(RandMap map[int]int, SelectNum int) {
LastOption := l.LastOption
func (l *LimitedTimeEventMod) fillProgressReward(randMap map[int]int, selectNum int) {
lastOption := l.LastOption
var r []int
for n := 0; n < 10; n++ {
r = GoUtil.RandMapNum(RandMap, SelectNum)
r = GoUtil.RandMapNum(randMap, selectNum)
Id := 1
for _, v := range r {
l.ProgressReward[Id] = v
Id++
}
if !GoUtil.SliceEqual(LastOption, r) {
if !GoUtil.SliceEqual(lastOption, r) {
break
}
}
@ -411,33 +405,39 @@ func (l *LimitedTimeEventMod) RemoveSuperOrder() bool {
return false
}
func (l *LimitedTimeEventMod) LuckyCat(ChessId int) error {
func (l *LimitedTimeEventMod) LuckyCat(chessId int) error {
L := l.EventList[EVENT_TYPE_LUCKY_CAT]
if L == nil {
return fmt.Errorf("LuckyCat event not exist")
}
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(L.Remian))
d := L.D.(*LuckyCat)
Lv := mergeDataCfg.GetLvById(ChessId)
Earn := math.Pow(2, float64(Lv-1))
d.Earnings += int(Earn)
if d.Earnings >= MaxEarning {
maxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(L.Remian))
d, ok := L.D.(*LuckyCat)
if !ok {
return fmt.Errorf("LuckyCat event data error")
}
lv := mergeDataCfg.GetLvById(chessId)
earn := math.Pow(2, float64(lv-1))
d.Earnings += int(earn)
if d.Earnings >= maxEarning {
delete(l.EventList, EVENT_TYPE_LUCKY_CAT)
}
return nil
}
func (l *LimitedTimeEventMod) AddCatTrickEnergy(Energy int) {
Event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
func (l *LimitedTimeEventMod) AddCatTrickEnergy(energy int) {
event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
if !ok {
return
}
if Event.Remian+Event.StartT <= GoUtil.Now() {
if event.Remian+event.StartT <= GoUtil.Now() {
return
}
// 事件未过期
d := Event.D.(*CatTrick)
d.Energy += Energy
d, ok := event.D.(*CatTrick)
if !ok {
return
}
d.Energy += energy
}
func (l *LimitedTimeEventMod) SubPaybackDay() error {
@ -445,120 +445,123 @@ func (l *LimitedTimeEventMod) SubPaybackDay() error {
}
func (l *LimitedTimeEventMod) GetCatTrickReward() ([]*item.Item, error) {
Event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
if !ok {
return nil, fmt.Errorf("CatTrick event not exist")
}
d := Event.D.(*CatTrick)
if d.Energy < 100 {
d, ok := event.D.(*CatTrick)
if !ok {
return nil, fmt.Errorf("CatTrick event data error")
}
energy := limitedTimeEventCfg.GetCatTrickEnergy()
diamond := limitedTimeEventCfg.GetCatTrickDiamond()
if d.Energy < energy {
return nil, fmt.Errorf("CatTrick energy not enough")
}
d.Energy -= 100
count := d.Energy / energy
d.Energy = d.Energy % energy
// TODO 放到配置中
return []*item.Item{
{Id: item.ITEM_DIAMOND_ID, Num: 5},
{Id: item.ITEM_DIAMOND_ID, Num: diamond * count},
}, nil
}
// #region 事件信息初始化
func initEventInfo(E *LTEInfo, EventType int) {
switch EventType {
func initEventInfo(event *LTEInfo, eventType int) {
switch eventType {
case EVENT_TYPE_SENCE_DASH:
E.Info = map[string]interface{}{
event.Info = map[string]interface{}{
"Times": 0,
}
case EVENT_TYPE_FAST_PRODUCE:
E.Info = map[string]interface{}{
event.Info = map[string]interface{}{
"Times": 0,
"NextPlay": 0,
}
case EVENT_TYPE_MONEY_CAT:
E.D = &MoneyCat{
event.D = &MoneyCat{
Id: 1,
Mul: 1.1,
}
case EVENT_TYPE_LUCKY_CAT:
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(E.Remian))
E.D = &LuckyCat{
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(event.Remian))
event.D = &LuckyCat{
MaxEarings: MaxEarning,
}
case EVENT_TYPE_PAYBACK_DAY:
E.D = &PaybackDay{
event.D = &PaybackDay{
Count: limitedTimeEventCfg.GetPaybackDay(),
}
case EVENT_TYPE_CAT_TRICK:
Type := limitedTimeEventCfg.GetCatTrickType(int(E.Remian))
E.D = &CatTrick{
List: []CatTrickInfo{
{
Id: 1,
Type: Type,
},
},
}
event.D = &CatTrick{}
}
}
func addEventInfo(E *LTEInfo, EventType, Duration int) {
switch EventType {
case EVENT_TYPE_CAT_TRICK:
d := E.D.(*CatTrick)
d.List = append(d.List, CatTrickInfo{
Id: len(d.List) + 1,
Type: limitedTimeEventCfg.GetCatTrickType(Duration),
})
func addEventInfo(event *LTEInfo, eventType, duration int) {
switch eventType {
case EVENT_TYPE_LUCKY_CAT:
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(Duration)
d := E.D.(*LuckyCat)
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(duration)
d, ok := event.D.(*LuckyCat)
if !ok {
return
}
d.MaxEarings += MaxEarning
case EVENT_TYPE_PAYBACK_DAY:
d := E.D.(*PaybackDay)
d, ok := event.D.(*PaybackDay)
if !ok {
return
}
d.Count += limitedTimeEventCfg.GetPaybackDay()
}
}
func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent {
Cd := 0
Mul := 0.0
Param := make(map[string]int32)
ShowTime := int32(e.StartT + e.Remian)
EndTime := int32(e.StartT + e.Remian)
switch t {
func getLimitEventMsg(eType int, event *LTEInfo) *msg.LimitEvent {
cd := 0
mul := 0.0
param := make(map[string]int32)
showTime := int32(event.StartT + event.Remian)
endTime := int32(event.StartT + event.Remian)
switch eType {
case EVENT_TYPE_FAST_PRODUCE:
NextPlay := GoUtil.Int64(e.Info["NextPlay"])
Cd = int(max(NextPlay-GoUtil.Now(), 0))
nextPlay := GoUtil.Int64(event.Info["NextPlay"])
cd = int(max(nextPlay-GoUtil.Now(), 0))
case EVENT_TYPE_MONEY_CAT:
d := e.D.(*MoneyCat)
Cd = int(d.EndTime)
Mul = d.Mul
case EVENT_TYPE_LUCKY_CAT:
d := e.D.(*LuckyCat)
Param[msg.LimitEventParam_LUCKY_CAT_EARNINGS.String()] = int32(d.MaxEarings)
case EVENT_TYPE_CAT_TRICK:
d := e.D.(*CatTrick)
Energy := d.Energy
Param[msg.LimitEventParam_CAT_TRICK_ENERGY.String()] = int32(Energy)
info := d.List[0]
Param[msg.LimitEventParam_CAT_TRICK_TYPE.String()] = int32(info.Type)
Diamon1, Energy1 := limitedTimeEventCfg.GetCatTrickDiamond(info.Type)
if d.Energy >= Diamon1*Energy1 {
// 进度条已满
EndTime += 5 * 60 // 5分钟
d, ok := event.D.(*MoneyCat)
if !ok {
return nil
}
cd = int(d.EndTime)
mul = d.Mul
case EVENT_TYPE_LUCKY_CAT:
d, ok := event.D.(*LuckyCat)
if !ok {
return nil
}
param[msg.LimitEventParam_LUCKY_CAT_EARNINGS.String()] = int32(d.MaxEarings)
case EVENT_TYPE_CAT_TRICK:
d, ok := event.D.(*CatTrick)
if !ok {
return nil
}
energy := d.Energy
param[msg.LimitEventParam_CAT_TRICK_ENERGY.String()] = int32(energy)
case EVENT_TYPE_PAYBACK_DAY:
d := e.D.(*PaybackDay)
Param[msg.LimitEventParam_PAYBACK_DAY_COUNT.String()] = int32(d.Count)
d, ok := event.D.(*PaybackDay)
if !ok {
return nil
}
param[msg.LimitEventParam_PAYBACK_DAY_COUNT.String()] = int32(d.Count)
case EVENT_TYPE_SENCE_DASH:
Times := GoUtil.Int(e.Info["Times"])
Param[msg.LimitEventParam_SENCE_DASH_TIMES.String()] = int32(Times)
times := GoUtil.Int(event.Info["Times"])
param[msg.LimitEventParam_SENCE_DASH_TIMES.String()] = int32(times)
}
return &msg.LimitEvent{
EndTime: EndTime,
ShowTime: ShowTime,
Cd: int32(Cd),
Mul: float32(Mul),
StartTime: int32(e.StartT),
Param: Param,
EndTime: endTime,
ShowTime: showTime,
Cd: int32(cd),
Mul: float32(mul),
StartTime: int32(event.StartT),
Param: param,
}
}
@ -575,13 +578,13 @@ func (l *LimitedTimeEventMod) GetCatDaySaleEndTime() int64 {
}
func (l *LimitedTimeEventMod) AddSenceDashTimes() bool {
SenceInfo, ok := l.EventList[EVENT_TYPE_SENCE_DASH]
senceInfo, ok := l.EventList[EVENT_TYPE_SENCE_DASH]
if !ok {
return false
}
if SenceInfo.Info == nil {
if senceInfo.Info == nil {
return false
}
SenceInfo.Info["Times"] = GoUtil.Int(SenceInfo.Info["Times"]) + 1
senceInfo.Info["Times"] = GoUtil.Int(senceInfo.Info["Times"]) + 1
return true
}

42
src/server/game/mod/mining/mining.go
View File

@ -21,22 +21,22 @@ func (m *MiningMod) InitData() {
}
}
func (m *MiningMod) Login(Id int) int {
OldId := m.Id
if Id == 0 {
func (m *MiningMod) Login(id int) int {
oldId := m.Id
if id == 0 {
m.Id = 0
return OldId
return oldId
}
if m.Id == Id {
if m.Id == id {
return 0
}
m.Id = Id
m.Id = id
m.Map = make(map[int32]string)
m.Gem = nil
m.Pass = 1
m.Mining = 0
m.InitItem = false
return OldId
return oldId
}
func (m *MiningMod) GetInitItem() []*item.Item {
@ -55,8 +55,8 @@ func (m *MiningMod) GetInitItem() []*item.Item {
return nil
}
func (m *MiningMod) ZeroUpdate(Id int) {
m.Login(Id)
func (m *MiningMod) ZeroUpdate(id int) {
m.Login(id)
}
func (m *MiningMod) GetMap() map[int32]string {
@ -75,7 +75,7 @@ func (m *MiningMod) GetMining() int {
return m.Mining
}
func (m *MiningMod) Take(Map map[int32]string, Gem int) ([]*item.Item, error) {
func (m *MiningMod) Take(miningMap map[int32]string, gem int) ([]*item.Item, error) {
AreaNum := miningCfg.GetPassArea(m.Pass)
if AreaNum == 0 {
return nil, fmt.Errorf("pass is not exist")
@ -83,32 +83,32 @@ func (m *MiningMod) Take(Map map[int32]string, Gem int) ([]*item.Item, error) {
if m.Mining+1 > AreaNum {
return nil, fmt.Errorf("mining is full")
}
if Gem > 0 {
if gem > 0 {
GemList := miningCfg.GetPassGem(m.Pass)
if len(m.Gem)+1 > len(GemList) {
return nil, fmt.Errorf("gem is full")
}
m.Map = Map
m.Map = miningMap
m.Mining++
m.Gem = append(m.Gem, Gem)
m.Gem = append(m.Gem, gem)
return nil, nil
}
m.Map = Map
m.Map = miningMap
m.Mining++
Items := miningCfg.GetRandItem()
return Items, nil
items := miningCfg.GetRandItem()
return items, nil
}
func (m *MiningMod) GetReward(orderFactor int) ([]*item.Item, int, error) {
GemList := miningCfg.GetPassGem(m.Pass)
if len(m.Gem) < len(GemList) {
gemList := miningCfg.GetPassGem(m.Pass)
if len(m.Gem) < len(gemList) {
return nil, 0, fmt.Errorf("gem is not full")
}
Items := miningCfg.GetPassItem(m.Pass, orderFactor)
items := miningCfg.GetPassItem(m.Pass, orderFactor)
m.Pass++
Ming := m.Mining
mining := m.Mining
m.Mining = 0
m.Map = nil
m.Gem = nil
return Items, Ming, nil
return items, mining, nil
}

4
src/server/game/mod/msg/Msg.go
View File

@ -158,6 +158,8 @@ const (
HANDLE_TYPE_LOGIN // 玩家登录处理
SERVER_PLAYER_SYNC_LOGOUT_MSG // 玩家处理完离线消息
HANDLE_TYPE_ACTIVITY_RELOAD // 活动重新加载
)
const (
@ -396,6 +398,8 @@ func formatType(t int) string {
return "player_login"
case SERVER_PLAYER_SYNC_LOGOUT_MSG:
return "player_sync_logout"
case HANDLE_TYPE_ACTIVITY_RELOAD:
return "activity_reload"
default:
return fmt.Sprintf("Unknown(%d)", t)
}

432
src/server/game/mod/order/Order.go
View File

@ -108,16 +108,16 @@ func (o *OrderMod) GetOrderList() map[int]Order {
// 领取奖励
func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
ItemList := make([]*item.Item, 0)
MergeList := make([]int, 0)
items := make([]*item.Item, 0)
mergeList := make([]int, 0)
if v, ok := o.OrderList[id]; ok {
o.LastOrder = v
delete(o.OrderList, id)
Star := 0
star := 0
for _, v := range v.MergeId {
Star += mergeDataCfg.GetStarById(v)
star += mergeDataCfg.GetStarById(v)
}
ItemList = v.Items
items = v.Items
if v.Type == Guide_type {
return nil, v.MergeId, v.Type, 0, nil
}
@ -130,9 +130,9 @@ func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
if GoUtil.InArray(79, o.FinishOrder) {
o.AutoEmit, _ = GoUtil.PopStringElemSlice(o.AutoEmit, "I")
}
return ItemList, v.MergeId, v.Type, Star, nil
return items, v.MergeId, v.Type, star, nil
}
return ItemList, MergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
return items, mergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
}
func (o *OrderMod) CreateOrderSeed(Order *Order) error {
for k, v := range o.OrderPool {
@ -145,41 +145,41 @@ func (o *OrderMod) CreateOrderSeed(Order *Order) error {
return nil
}
func (o *OrderMod) CreatOrderPool(lv int, Emit []int, EnergyMul int) error {
func (o *OrderMod) CreatOrderPool(lv int, emit []int, energyMul int) error {
o.OrderPool = make(map[int]*Order)
index := 1
for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_LOW)
if len(ChessList) == 0 {
chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_LOW)
if len(chessList) == 0 {
continue
}
o.OrderPool[index] = &Order{
MergeId: ChessList,
MergeId: chessList,
Diff: DIFF_LOW,
Timestamp: int64(index),
}
index++
}
for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_MID)
if len(ChessList) == 0 {
chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_MID)
if len(chessList) == 0 {
continue
}
o.OrderPool[index] = &Order{
MergeId: ChessList,
Diff: DIFF_LOW,
MergeId: chessList,
Diff: DIFF_MID,
Timestamp: int64(index),
}
index++
}
for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_HIGH)
if len(ChessList) == 0 {
chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_HIGH)
if len(chessList) == 0 {
continue
}
o.OrderPool[index] = &Order{
MergeId: ChessList,
Diff: DIFF_LOW,
MergeId: chessList,
Diff: DIFF_HIGH,
Timestamp: int64(index),
}
index++
@ -188,45 +188,45 @@ func (o *OrderMod) CreatOrderPool(lv int, Emit []int, EnergyMul int) error {
}
// 触发生成新的固定订单
func (o *OrderMod) TriggerOrder(lv int, Type string, Emit []int, EnergyMul int) error {
TriggerOrderList := orderCfg.GetStartOrderList()
FixedOrder := 0
func (o *OrderMod) TriggerOrder(lv int, oType string, emit []int, energyMul int) error {
triggerOrderList := orderCfg.GetStartOrderList()
fixedOrder := 0
for _, v := range o.OrderList {
if v.Type == Fixed_type {
FixedOrder++
fixedOrder++
}
}
OrderList := make(map[int]Order, len(o.OrderList))
orderList := make(map[int]Order, len(o.OrderList))
for k, v := range o.OrderList {
OrderList[k] = v
orderList[k] = v
}
// 触发生成新的固定订单
for _, v := range TriggerOrderList {
for _, v := range triggerOrderList {
if GoUtil.InArray(v.Id, o.FinishOrder) {
continue
}
orderInfo, exists := OrderList[v.Id]
orderInfo, exists := orderList[v.Id]
if exists && v.Preview == "" {
continue
}
// 预览条件不为空且未存在且未完成
if v.Preview != "" && !exists && !GoUtil.InArray(v.Id, o.FinishOrder) {
if o.CheckCondition(lv, v.Preview, Type, Emit, FixedOrder, OrderList) {
if o.CheckCondition(lv, v.Preview, oType, emit, fixedOrder, orderList) {
o.addFixOrder(v.Id, v.MergeList, Preview_type, v.Items)
}
}
if v.Appear != "" {
if o.CheckCondition(lv, v.Appear, Type, Emit, FixedOrder, OrderList) {
Type := Fixed_type
OrderType := orderCfg.GetOrderType(v.Id)
if OrderType != 0 {
Type = OrderType
if o.CheckCondition(lv, v.Appear, oType, emit, fixedOrder, orderList) {
oType1 := Fixed_type
orderType := orderCfg.GetOrderType(v.Id)
if orderType != 0 {
oType1 = orderType
}
if exists {
orderInfo.Type = Fixed_type
o.OrderList[v.Id] = orderInfo
} else {
o.addFixOrder(v.Id, v.MergeList, Type, v.Items)
o.addFixOrder(v.Id, v.MergeList, oType1, v.Items)
if v.Id == 78 {
o.Retire("D")
o.AutoEmit = append(o.AutoEmit, "D")
@ -242,7 +242,7 @@ func (o *OrderMod) TriggerOrder(lv int, Type string, Emit []int, EnergyMul int)
return nil
}
func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, FixedOrder int, OrderList map[int]Order) bool {
func (o *OrderMod) CheckCondition(lv int, condition, cType string, emit []int, fixedOrder int, orderList map[int]Order) bool {
r1 := strings.Split(condition, "|")
for _, v := range r1 {
r2 := strings.Split(v, "=")
@ -252,7 +252,7 @@ func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, Fi
if !GoUtil.InArray(id, o.FinishOrder) && id != 0 {
return false
}
if id == 0 && Type != TRIGGER_TYPE_ORDER {
if id == 0 && cType != TRIGGER_TYPE_ORDER {
return false
}
case "Lv":
@ -262,34 +262,34 @@ func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, Fi
}
case "OrderNum":
id := GoUtil.Int(r2[1])
if FixedOrder != id {
if fixedOrder != id {
return false
}
case "Order":
id := GoUtil.Int(r2[1])
_, ok := OrderList[id]
_, ok := orderList[id]
if !GoUtil.InArray(id, o.FinishOrder) && !ok {
return false
}
case "Emit":
Class := []string{}
for _, v := range Emit {
Class = append(Class, mergeDataCfg.GetEmitId(v))
class := []string{}
for _, v := range emit {
class = append(class, mergeDataCfg.GetEmitId(v))
}
if !GoUtil.InStringArray(r2[1], Class) {
if !GoUtil.InStringArray(r2[1], class) {
return false
}
case "EmitMax":
Class := []string{}
for _, v := range Emit {
EmitLv := mergeDataCfg.GetLvById(v)
MaxLv := mergeDataCfg.GetMaxLvById(v)
if EmitLv < MaxLv {
class := []string{}
for _, v := range emit {
emitLv := mergeDataCfg.GetLvById(v)
maxLv := mergeDataCfg.GetMaxLvById(v)
if emitLv < maxLv {
continue
}
Class = append(Class, mergeDataCfg.GetEmitId(v))
class = append(class, mergeDataCfg.GetEmitId(v))
}
if !GoUtil.InStringArray(r2[1], Class) {
if !GoUtil.InStringArray(r2[1], class) {
return false
}
}
@ -298,65 +298,65 @@ func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, Fi
}
// 生成新订单
func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul, OrderType int) error {
if len(Emit) == 0 {
func (o *OrderMod) CreateOrder(lv int, emit []int, energyMul, orderType int) error {
if len(emit) == 0 {
return nil
}
/// 生成优先订单
if o.CreatePriorityOrder(lv, Emit) {
// 生成优先订单
if o.CreatePriorityOrder(lv, emit) {
return nil
}
err := o.CreateNormalOrder(lv, Emit, EnergyMul, OrderType)
err := o.CreateNormalOrder(lv, emit, energyMul, orderType)
return err
}
func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
if len(Emit) == 0 {
func (o *OrderMod) CreatePriorityOrder(lv int, emit []int) bool {
if len(emit) == 0 {
return false
}
ChessList := make(map[string]int)
chessList := make(map[string]int)
for _, v := range o.OrderList {
for _, vv := range v.MergeId {
Color := mergeDataCfg.GetColorById(vv)
if vvv, ok := ChessList[Color]; ok {
OldLv := mergeDataCfg.GetLvById(vvv)
NewLv := mergeDataCfg.GetLvById(vv)
if NewLv > OldLv {
ChessList[Color] = vv
color := mergeDataCfg.GetColorById(vv)
if vvv, ok := chessList[color]; ok {
oldLv := mergeDataCfg.GetLvById(vvv)
newLv := mergeDataCfg.GetLvById(vv)
if newLv > oldLv {
chessList[color] = vv
}
} else {
ChessList[Color] = vv
chessList[color] = vv
}
}
}
for v := range Emit {
Produce := mergeDataCfg.GetEmitProduceChessType(v)
if len(Produce) < 2 {
for v := range emit {
produce := mergeDataCfg.GetEmitProduceChessType(v)
if len(produce) < 2 {
continue
}
for k, v := range ChessList {
if k == Produce[0] {
MaxLv := mergeDataCfg.GetMaxLvById(v)
DurLv := int((MaxLv - 3) * 1 / 3)
ChessLv := mergeDataCfg.GetLvById(v)
if ChessLv > (3 + DurLv*2) {
for k, v := range chessList {
if k == produce[0] {
maxLv := mergeDataCfg.GetMaxLvById(v)
durLv := int((maxLv - 3) * 1 / 3)
chessLv := mergeDataCfg.GetLvById(v)
if chessLv > (3 + durLv*2) {
B := GoUtil.RandMap(map[int]int{0: 80, 1: 20})
if B == 1 {
NewColor := GoUtil.RandStringSlice(Produce[1:])
DiffLv := GoUtil.RandMap(map[int]int{DIFF_LOW: 70, DIFF_MID: 30})
NewChessId := 0
switch DiffLv {
newColor := GoUtil.RandStringSlice(produce[1:])
diffLv := GoUtil.RandMap(map[int]int{DIFF_LOW: 70, DIFF_MID: 30})
newChessId := 0
switch diffLv {
case DIFF_LOW:
NewLv := GoUtil.RandNum(4, 3+DurLv)
NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor)
newLv := GoUtil.RandNum(4, 3+durLv)
newChessId = mergeDataCfg.GetChessIdByLvAndColor(newLv, newColor)
case DIFF_MID:
NewLv := GoUtil.RandNum(4+DurLv, 3+DurLv*2)
NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor)
newLv := GoUtil.RandNum(4+durLv, 3+durLv*2)
newChessId = mergeDataCfg.GetChessIdByLvAndColor(newLv, newColor)
}
if NewChessId == 0 {
if newChessId == 0 {
continue
}
o.addOrder([]int{NewChessId}, DiffLv, Common_type)
o.addOrder([]int{newChessId}, diffLv, Common_type)
return true
}
}
@ -367,8 +367,8 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
}
// 生成新订单
func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff int) []int {
if len(Emit) == 0 {
func (o *OrderMod) CreateNormalOrderSeed(lv int, emit []int, energyMul int, diff int) []int {
if len(emit) == 0 {
return nil
}
randNum := 0
@ -379,7 +379,7 @@ func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff
break
}
randNum++
mergeList, _, err = randOrderChessSeed(o, Emit, EnergyMul, Diff)
mergeList, _, err = randOrderChessSeed(o, emit, energyMul, diff)
if err != nil {
continue
}
@ -400,8 +400,8 @@ func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff
}
// 生成新订单
func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType int) error {
if len(Emit) == 0 {
func (o *OrderMod) CreateNormalOrder(lv int, emit []int, energyMul, orderType int) error {
if len(emit) == 0 {
return nil
}
randNum := 0
@ -413,7 +413,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType in
break
}
randNum++
mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul, OrderType)
mergeList, OrderDiff, err = randOrderChess(o, lv, emit, energyMul, orderType)
if err != nil {
continue
}
@ -435,7 +435,54 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType in
return nil
}
}
o.addOrder(mergeList, OrderDiff, OrderType)
o.addOrder(mergeList, OrderDiff, orderType)
return nil
}
// 直接生成生成宠物订单 宠物币订单价值大于75
func (o *OrderMod) CreatePetOrder(lv int, emit []int, energyMul, orderType int) error {
if len(emit) == 0 {
return nil
}
randNum := 0
mergeList := make([]int, 0)
OrderDiff := DIFF_LOW
var err error
for {
if randNum > 50 {
break
}
randNum++
mergeList, OrderDiff, err = randOrderChess(o, lv, emit, energyMul, orderType)
if err != nil {
continue
}
lastMergelist := o.LastNormalOrder.MergeId
conbine := false
star := 0
for _, v := range mergeList {
star += mergeDataCfg.GetStarById(v)
}
if star < 75 {
continue
}
for _, v := range mergeList {
if GoUtil.InArray(v, lastMergelist) {
conbine = true
break
}
}
if conbine {
continue
}
break
}
for _, v := range mergeList {
if v == 0 {
return nil
}
}
o.addOrder(mergeList, OrderDiff, orderType)
return nil
}
@ -444,16 +491,16 @@ func (o *OrderMod) DeleteOrder(OrderId int) {
}
// 生成超级订单
func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
if len(Emit) == 0 {
func (o *OrderMod) CreateSuperOrder(lv int, emit []int, energyMul int) error {
if len(emit) == 0 {
return nil
}
randNum := 0
mergeList := make([]int, 0)
// 忽视上一个订单的难度，生成此订单时，难度默认为50%概率的中难度、50%概率的高难度
OrderDiff := DIFF_MID
orderDiff := DIFF_MID
if GoUtil.RandNum(1, 100) <= 50 {
OrderDiff = DIFF_HIGH
orderDiff = DIFF_HIGH
}
var err error
for {
@ -461,7 +508,7 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
break
}
randNum++
mergeList, OrderDiff, err = randSuperOrderChess(o, lv, Emit, EnergyMul, OrderDiff)
mergeList, orderDiff, err = randSuperOrderChess(o, lv, emit, energyMul, orderDiff)
if err != nil {
continue
}
@ -478,92 +525,92 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
}
break
}
o.addOrder(mergeList, OrderDiff, Super_type)
o.addOrder(mergeList, orderDiff, Super_type)
return nil
}
func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) int {
func (o *OrderMod) addOrder(chessList []int, diff int, oType int) int {
o.Auto_id++
Order := Order{
MergeId: ChessList,
Diff: Diff,
Type: Type,
MergeId: chessList,
Diff: diff,
Type: oType,
Timestamp: time.Now().Unix(),
Items: nil,
}
o.OrderList[o.Auto_id] = Order
if Type == Common_type {
if oType == Common_type {
o.LastNormalOrder = Order
}
o.LastDiff = Diff
o.LastDiff = diff
return o.Auto_id
}
func (o *OrderMod) AddExtraOrder(ChessList []int) {
o.addOrder(ChessList, DIFF_LOW, Extra_type)
func (o *OrderMod) AddExtraOrder(chessList []int) {
o.addOrder(chessList, DIFF_LOW, Extra_type)
}
func (o *OrderMod) AddFixOrder(Id int, ChessList []int, Type int, Items []*item.Item) {
o.addFixOrder(Id, ChessList, Type, Items)
func (o *OrderMod) AddFixOrder(Id int, chessList []int, oType int, items []*item.Item) {
o.addFixOrder(Id, chessList, oType, items)
}
func (o *OrderMod) addFixOrder(Id int, ChessList []int, Type int, Items []*item.Item) {
func (o *OrderMod) addFixOrder(Id int, chessList []int, oType int, items []*item.Item) {
Order := Order{
MergeId: ChessList,
Type: Type,
MergeId: chessList,
Type: oType,
Timestamp: time.Now().Unix(),
Items: Items,
Items: items,
}
o.OrderList[Id] = Order
}
func (o *OrderMod) AddPreheatOrder(ChessList []int, Diff int, Type int, Items []*item.Item) int {
return o.addPreheatOrder(ChessList, Diff, Type, Items)
func (o *OrderMod) AddPreheatOrder(chessList []int, diff int, oType int, items []*item.Item) int {
return o.addPreheatOrder(chessList, diff, oType, items)
}
func (o *OrderMod) addPreheatOrder(ChessList []int, Diff int, Type int, Items []*item.Item) int {
func (o *OrderMod) addPreheatOrder(chessList []int, diff int, oType int, items []*item.Item) int {
o.Auto_id++
Order := Order{
MergeId: ChessList,
Diff: Diff,
Type: Type,
MergeId: chessList,
Diff: diff,
Type: oType,
Timestamp: time.Now().Unix(),
Items: Items,
Items: items,
}
o.OrderList[o.Auto_id] = Order
return o.Auto_id
}
func (o *OrderMod) CreateCleanOrder(ChessList []int) bool {
o.addOrder(ChessList, DIFF_LOW, Clean_type)
func (o *OrderMod) CreateCleanOrder(chessList []int) bool {
o.addOrder(chessList, DIFF_LOW, Clean_type)
return true
}
func (o *OrderMod) CreateCleanOrder2(ChessList []int) bool {
o.addOrder(ChessList, DIFF_LOW, Clean_Order_type)
func (o *OrderMod) CreateCleanOrder2(chessList []int) bool {
o.addOrder(chessList, DIFF_LOW, Clean_Order_type)
return true
}
func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, EnergyMul, Level int) bool {
BeginExtraEmitId := orderCfg.GetEmitExtraOrder() // 从发射器F系列开始
func (o *OrderMod) CreateExtraOrder(addChess, addNewEmit, chessList []int, energyMul, level int) bool {
beginExtraEmitId := orderCfg.GetEmitExtraOrder() // 从发射器F系列开始
b1 := false
OrderEmit := 0
MaxLvChess := make(map[int]int)
for _, v := range AddNewEmit {
Emit_Id := mergeDataCfg.GetEmitId(v)
ok := Emit_Id >= BeginExtraEmitId
_, ok1 := o.EimtOrder[Emit_Id]
orderEmit := 0
maxLvChess := make(map[int]int)
for _, v := range addNewEmit {
emit_Id := mergeDataCfg.GetEmitId(v)
ok := emit_Id >= beginExtraEmitId
_, ok1 := o.EimtOrder[emit_Id]
ChessColor := mergeDataCfg.GetEmitProduceChessType(v)
if ok && !ok1 && len(ChessColor) > 0 {
b1 = true
OrderEmit = v
o.EimtOrder[Emit_Id] = struct{}{}
orderEmit = v
o.EimtOrder[emit_Id] = struct{}{}
break
}
}
for _, ChessId := range AddChess {
Lv := mergeDataCfg.GetLvById(ChessId)
Type := mergeDataCfg.GetTypeById(ChessId)
if Type != "Product" {
for _, ChessId := range addChess {
lv := mergeDataCfg.GetLvById(ChessId)
cType := mergeDataCfg.GetTypeById(ChessId)
if cType != "Product" {
continue
}
MaxLv := mergeDataCfg.GetMaxLvById(ChessId)
if Lv == MaxLv {
MaxLvChess[ChessId]++
maxLv := mergeDataCfg.GetMaxLvById(ChessId)
if lv == maxLv {
maxLvChess[ChessId]++
}
}
b3 := false
@ -586,15 +633,15 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
// }
//额外订单补充1；CDEG发射器首次合成时，生成其对应2及棋子订单，完成后生成3及，再完成生成4及的；
if b1 {
ChessColor := mergeDataCfg.GetEmitProduceChessType(OrderEmit)
if len(ChessColor) == 0 {
chessColor := mergeDataCfg.GetEmitProduceChessType(orderEmit)
if len(chessColor) == 0 {
return b1
}
ChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+1, ChessColor[0])
if ChessId != 0 {
o.PreheatStep[ChessColor[0]] = 1
chessId := mergeDataCfg.GetChessIdByLvAndColor(energyMul+1, chessColor[0])
if chessId != 0 {
o.PreheatStep[chessColor[0]] = 1
Items := PreheatItems[1]
o.addPreheatOrder([]int{ChessId}, DIFF_LOW, Preheat_type, Items)
o.addPreheatOrder([]int{chessId}, DIFF_LOW, Preheat_type, Items)
}
}
return b1 || b3
@ -602,19 +649,19 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
// 返回订单列表
func (o *OrderMod) BackData() *msg.ResOrderList {
OrderList := make([]*msg.Order, 0)
orderList := make([]*msg.Order, 0)
for k, v := range o.OrderList {
mergeList := GoUtil.IntToInt32(v.MergeId)
Order := &msg.Order{
order := &msg.Order{
Id: int32(k),
ChessId: mergeList,
Type: int32(v.Type),
Items: item.ItemToMsg(v.Items),
}
OrderList = append(OrderList, Order)
orderList = append(orderList, order)
}
return &msg.ResOrderList{
OrderList: OrderList,
OrderList: orderList,
}
}
@ -638,41 +685,41 @@ func (o *OrderMod) CheckSuperOrder() bool {
/*
* 根据能量倍数 调整订单
*/
func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList []int) {
func (o *OrderMod) ChangeEnergyMul(lv int, emit []int, energyMul int, chessList []int) {
for k, v := range o.OrderList {
if v.Type == Preheat_type { // 预热订单 修改倍数时修改棋子等级
ChessId := v.MergeId[0]
ChessColor := mergeDataCfg.GetColorById(ChessId)
PreheatStep := o.PreheatStep[ChessColor]
NewChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+PreheatStep, ChessColor)
if NewChessId == 0 {
chessId := v.MergeId[0]
chessColor := mergeDataCfg.GetColorById(chessId)
preheatStep := o.PreheatStep[chessColor]
newChessId := mergeDataCfg.GetChessIdByLvAndColor(energyMul+preheatStep, chessColor)
if newChessId == 0 {
continue
}
delete(o.OrderList, k)
Items, ok := PreheatItems[PreheatStep]
items, ok := PreheatItems[preheatStep]
if !ok {
Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, GetOrderStar([]int{NewChessId}, Emit))}
items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, GetOrderStar([]int{newChessId}, emit))}
}
o.addPreheatOrder([]int{NewChessId}, DIFF_LOW, Preheat_type, Items)
o.addPreheatOrder([]int{newChessId}, DIFF_LOW, Preheat_type, items)
}
}
MaxStep := orderCfg.GetMaxStep()
if o.Step < MaxStep { // 还在新手引导阶段
maxStep := orderCfg.GetMaxStep()
if o.Step < maxStep { // 还在新手引导阶段
return
}
for k, v := range o.OrderList {
NeedTrigger := false
needTrigger := false
for _, vv := range v.MergeId {
Lv := mergeDataCfg.GetLvById(vv)
Color := mergeDataCfg.GetColorById(vv)
EmitId := GetEmitByColor(Emit, Color)
_, Max := getChesslvRange(EmitId, EnergyMul, o.IsCharge)
Adjust := mergeDataCfg.GetAdjust(EmitId, Color, EnergyMul)
if Lv >= EnergyMul+1 && Lv <= Max-Adjust {
lv := mergeDataCfg.GetLvById(vv)
color := mergeDataCfg.GetColorById(vv)
emitId := GetEmitByColor(emit, color)
_, max := getChesslvRange(emitId, energyMul, o.IsCharge)
adjust := mergeDataCfg.GetAdjust(emitId, color, energyMul)
if lv >= energyMul+1 && lv <= max-adjust {
continue
}
NeedTrigger = true
needTrigger = true
}
if v.Type != Common_type && v.Type != Pet_type {
@ -684,60 +731,37 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
订单棋子等级>n+11 且该棋子在棋盘上没有
则删除该订单，重新生成一个普通订单
*/
if NeedTrigger {
if needTrigger {
delete(o.OrderList, k)
o.CreateNormalOrder(lv, Emit, EnergyMul, v.Type)
o.CreateNormalOrder(lv, emit, energyMul, v.Type)
}
}
}
func (o *OrderMod) Retire(EmitId string) {
ChessPool := make([]int, 0)
Product := mergeDataCfg.GetEmitOrderProduce(EmitId)
func (o *OrderMod) Retire(emitId string) {
chessPool := make([]int, 0)
product := mergeDataCfg.GetEmitOrderProduce(emitId)
for _, v := range o.ChessPool {
Color := mergeDataCfg.GetColorById(v)
if GoUtil.InStringArray(Color, Product) {
color := mergeDataCfg.GetColorById(v)
if GoUtil.InStringArray(color, product) {
continue
}
ChessPool = append(ChessPool, v)
chessPool = append(chessPool, v)
}
o.ChessPool = ChessPool
o.ChessPool = chessPool
o.ColorShuffle = nil
}
func (o *OrderMod) DelOrder(OrderId int) (*Order, error) {
Order, ok := o.OrderList[OrderId]
func (o *OrderMod) DelOrder(orderId int) (*Order, error) {
order, ok := o.OrderList[orderId]
if !ok {
return nil, fmt.Errorf("order not exist")
}
if Order.Type != Clean_Order_type {
if order.Type != Clean_Order_type {
return nil, fmt.Errorf("order type wrong")
}
delete(o.OrderList, OrderId)
return &Order, nil
}
func (o *OrderMod) CreateComfortOrder(lv int, Emit []int, EnergyMul, Diff, ChessNum int) error {
if len(Emit) == 0 {
return nil
}
randNum := 0
mergeList := make([]int, 0)
var err error
for {
if randNum > 50 {
break
}
randNum++
mergeList, _, err = randOrderChessWithDiff(o, Emit, EnergyMul, Diff, ChessNum)
if err != nil {
continue
}
break
}
o.addOrder(mergeList, Diff, COMFORT_TYPE)
return nil
delete(o.OrderList, orderId)
return &order, nil
}
func (o *OrderMod) ResetChessPool() {

736
src/server/game/mod/order/order_func.go
View File

File diff suppressed because it is too large Load Diff

54
src/server/game/mod/pass/Pass.go
View File

@ -17,71 +17,71 @@ type PassMod struct {
func (p *PassMod) InitData() {
}
func (p *PassMod) ZeroUpdate(Id int) {
p.Login(Id)
func (p *PassMod) ZeroUpdate(id int) {
p.Login(id)
}
func (p *PassMod) GetRewardItems() ([]*item.Item, []int) {
template := passCfg.GetTemplate(p.Id)
NewLevel := passCfg.GetNewLevel(template, p.Num, p.Reward)
if len(NewLevel) == 0 {
newLevel := passCfg.GetNewLevel(template, p.Num, p.Reward)
if len(newLevel) == 0 {
return nil, nil
}
var Items []*item.Item
Items = append(Items, passCfg.GetFreeChargeItems(template, p.Reward)...)
var items []*item.Item
items = append(items, passCfg.GetFreeChargeItems(template, p.Reward)...)
if p.LowPass != 0 {
Items = append(Items, passCfg.GetLowChargeItems(template, p.Reward)...)
items = append(items, passCfg.GetLowChargeItems(template, p.Reward)...)
}
if p.HighPass != 0 {
Items = append(Items, passCfg.GetHighChargeItems(template, p.Reward)...)
items = append(items, passCfg.GetHighChargeItems(template, p.Reward)...)
}
p.Reward = append(p.Reward, NewLevel...)
return Items, NewLevel
p.Reward = append(p.Reward, newLevel...)
return items, newLevel
}
func (p *PassMod) Login(Id int) int {
OldId := p.Id
if Id == 0 {
func (p *PassMod) Login(id int) int {
oldId := p.Id
if id == 0 {
p.Id = 0
return OldId
return oldId
}
if p.Id == Id {
if p.Id == id {
return 0
}
p.Id = Id
p.Id = id
p.LowPass = 0
p.HighPass = 0
p.Num = 0
p.Reward = nil
return OldId
return oldId
}
func (p *PassMod) GetLowChargeItems() []*item.Item {
if p.LowPass != 0 {
return nil
}
Template := passCfg.GetTemplate(p.Id)
if Template == 0 {
template := passCfg.GetTemplate(p.Id)
if template == 0 {
return nil
}
Items := passCfg.GetLowChargeItems(Template, p.Reward)
items := passCfg.GetLowChargeItems(template, p.Reward)
p.LowPass = GoUtil.Now()
return Items
return items
}
func (p *PassMod) GetHighChargeItems() []*item.Item {
if p.HighPass != 0 {
return nil
}
Template := passCfg.GetTemplate(p.Id)
if Template == 0 {
template := passCfg.GetTemplate(p.Id)
if template == 0 {
return nil
}
Items := passCfg.GetHighChargeItems(Template, p.Reward)
items := passCfg.GetHighChargeItems(template, p.Reward)
p.HighPass = GoUtil.Now()
return Items
return items
}
func (p *PassMod) AddExp(Score int) {
p.Num += Score
func (p *PassMod) AddExp(score int) {
p.Num += score
}

34
src/server/game/mod/piggy_bank/piggy_bank.go
View File

@ -22,13 +22,13 @@ const (
func (p *PiggyBankMod) InitData() {
}
func (p *PiggyBankMod) AddPiggyBank(Type int) {
p.List = append(p.List, Type)
func (p *PiggyBankMod) AddPiggyBank(pType int) {
p.List = append(p.List, pType)
}
func (p *PiggyBankMod) Fire(ChargeId int) []*item.Item {
PiggyBankChargeId := chargeCfg.GetPiggyBankChargeId()
if ChargeId != PiggyBankChargeId && ChargeId != 0 {
func (p *PiggyBankMod) Fire(chargeId int) []*item.Item {
piggyBankChargeId := chargeCfg.GetPiggyBankChargeId()
if chargeId != piggyBankChargeId && chargeId != 0 {
return nil
}
reward := []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, p.Diamond)}
@ -39,25 +39,25 @@ func (p *PiggyBankMod) Fire(ChargeId int) []*item.Item {
}
func (p *PiggyBankMod) TimeOut() int64 {
Now := GoUtil.Now()
Remain := p.EndTime - Now
if Remain > 0 {
return Remain
now := GoUtil.Now()
remain := p.EndTime - now
if remain > 0 {
return remain
}
if len(p.List) == 0 {
return 0
}
var Type int
Type, p.List = GoUtil.PopSlice(p.List)
p.Type = Type
Duration := int64(chargeCfg.GetPiggyDuration())
p.EndTime = Now + Duration
return Duration
var pType int
pType, p.List = GoUtil.PopSlice(p.List)
p.Type = pType
duration := int64(chargeCfg.GetPiggyDuration())
p.EndTime = now + duration
return duration
}
func (p *PiggyBankMod) Trigger() {
Now := GoUtil.Now()
if p.EndTime < Now {
now := GoUtil.Now()
if p.EndTime < now {
return
}
minDia, maxDia := chargeCfg.GetPiggyRandDia()

535
src/server/game/mod/playroom/playroom.go
View File

@ -176,9 +176,9 @@ func (p *PlayroomMod) InitData() {
if p.NewCollect == nil {
p.NewCollect = make(map[int]*CollectInfo)
}
InitCollect := playroomCfg.GetInitDecorate()
initCollect := playroomCfg.GetInitDecorate()
if len(p.NewCollect) == 0 {
for _, v := range InitCollect {
for _, v := range initCollect {
p.NewCollect[v] = &CollectInfo{
Id: v,
AddTime: GoUtil.Now(),
@ -196,7 +196,7 @@ func (p *PlayroomMod) InitData() {
}
p.Collect = make(map[int]int)
}
for _, v := range InitCollect {
for _, v := range initCollect {
p.Collect[v] = 1
}
if p.Room == nil {
@ -229,8 +229,8 @@ func (p *PlayroomMod) InitData() {
}
if len(p.NewPetAir) == 0 {
p.NewPetAir = make(map[int]*PetAirInfo)
InitPetAir := playroomCfg.GetInitAirList()
for _, v := range InitPetAir {
initPetAir := playroomCfg.GetInitAirList()
for _, v := range initPetAir {
p.NewPetAir[v] = &PetAirInfo{
Id: v,
AddTime: GoUtil.Now(),
@ -253,12 +253,12 @@ func (p *PlayroomMod) InitData() {
p.NewDress = make(map[int]*DressInfo)
}
if len(p.NewDress) == 0 {
InitDressList := playroomCfg.GetInitDressList()
for _, v := range InitDressList {
Part := playroomCfg.GetDressPart(v)
initDressList := playroomCfg.GetInitDressList()
for _, v := range initDressList {
part := playroomCfg.GetDressPart(v)
p.NewDress[v] = &DressInfo{
Id: v,
Part: Part,
Part: part,
AddTime: GoUtil.Now(),
Num: 1,
}
@ -268,10 +268,10 @@ func (p *PlayroomMod) InitData() {
if len(p.Dress) != 0 {
for _, v := range p.Dress {
for _, id := range v {
Part := playroomCfg.GetDressPart(id)
part := playroomCfg.GetDressPart(id)
p.NewDress[id] = &DressInfo{
Id: id,
Part: Part,
Part: part,
AddTime: GoUtil.Now(),
Num: 1,
}
@ -300,34 +300,34 @@ func (p *PlayroomMod) ZeroUpdate() {
func (p *PlayroomMod) InitDailyTask() {
p.DailyTask = make(map[int]*DailyTask)
Index := 1
TaskList1 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_ONE)
for k, v := range TaskList1 {
Items := playroomCfg.GetDailyTaskReward(Index)
Quest, _ := quest.ParseQuest(v)
index := 1
taskList1 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_ONE)
for k, v := range taskList1 {
items := playroomCfg.GetDailyTaskReward(index)
quest, _ := quest.ParseQuest(v)
p.DailyTask[k] = &DailyTask{
Items: Items,
Quest: Quest,
Items: items,
Quest: quest,
UnLock: true,
Index: Index,
Index: index,
}
Index++
index++
}
TaskList2 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_TWO)
for k, v := range TaskList2 {
Items := playroomCfg.GetDailyTaskReward(Index)
Quest, _ := quest.ParseQuest(v)
taskList2 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_TWO)
for k, v := range taskList2 {
items := playroomCfg.GetDailyTaskReward(index)
quest, _ := quest.ParseQuest(v)
p.DailyTask[k] = &DailyTask{
Items: Items,
Quest: Quest,
Items: items,
Quest: quest,
UnLock: false,
Index: Index,
Index: index,
}
Index++
index++
}
}
func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
func (p *PlayroomMod) QuestTrigger(tr *quest.Trigger) bool {
update := false
unlock := true
for k, v := range p.DailyTask {
@ -337,14 +337,14 @@ func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
if v.Status != quest.QUEST_STATUS_UNFINISH {
continue
}
update = quest.TriggerQuestProgress(&v.Quest, Tr) || update
update = quest.TriggerQuestProgress(&v.Quest, tr) || update
if v.Quest.Status {
v.Status = quest.QUEST_STATUS_FINISH
}
Type := playroomCfg.GetDailyTaskType(k)
if Type == DAILY_TASK_TYPE_ONE && v.Status == quest.QUEST_STATUS_UNFINISH {
qType := playroomCfg.GetDailyTaskType(k)
if qType == DAILY_TASK_TYPE_ONE && v.Status == quest.QUEST_STATUS_UNFINISH {
unlock = false
}
}
@ -356,9 +356,9 @@ func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
return update
}
func (p *PlayroomMod) DailyTaskCanReward(Id int) bool {
IdList := playroomCfg.GetDailyTaskListById(Id)
for _, v := range IdList {
func (p *PlayroomMod) DailyTaskCanReward(id int) bool {
idList := playroomCfg.GetDailyTaskListById(id)
for _, v := range idList {
v, ok := p.DailyTask[v]
if !ok {
return false
@ -370,8 +370,8 @@ func (p *PlayroomMod) DailyTaskCanReward(Id int) bool {
return true
}
func (p *PlayroomMod) GetDailyTaskReward(Id int) ([]*item.Item, error) {
v, ok := p.DailyTask[Id]
func (p *PlayroomMod) GetDailyTaskReward(id int) ([]*item.Item, error) {
v, ok := p.DailyTask[id]
if !ok {
return nil, fmt.Errorf("GetDailyTaskReward Id is not ok")
}
@ -414,12 +414,12 @@ func (p *PlayroomMod) GetPhysiologyList() map[int]int {
return Physiology
}
func (p *PlayroomMod) GetMoodInfo(Id int) *Mood {
return p.MoodInfo[Id]
func (p *PlayroomMod) GetMoodInfo(id int) *Mood {
return p.MoodInfo[id]
}
func (p *PlayroomMod) GetPhysiology(Id int) *Physiology {
return p.Physiology[Id]
func (p *PlayroomMod) GetPhysiology(id int) *Physiology {
return p.Physiology[id]
}
func (p *PlayroomMod) GetCollect() map[int]*CollectInfo {
@ -438,154 +438,154 @@ func (p *PlayroomMod) GetChip() int {
return len(p.ChipList)
}
func (p *PlayroomMod) AddChip(Uid int, Time int64, Emoji int) {
func (p *PlayroomMod) AddChip(uid int, time int64, emoji int) {
if len(p.ChipList) >= playroomCfg.GetChipNum() {
return
}
p.ChipList = append(p.ChipList, &ChipInfo{Uid: Uid, Time: Time, Emoji: Emoji})
p.RevengeUid = int64(Uid)
p.ChipList = append(p.ChipList, &ChipInfo{Uid: uid, Time: time, Emoji: emoji})
p.RevengeUid = int64(uid)
}
func (p *PlayroomMod) SetTarget(Target int) {
p.Target = Target
func (p *PlayroomMod) SetTarget(target int) {
p.Target = target
p.Status = 1
p.HasVisit[Target] = GoUtil.Now()
p.HasVisit[target] = GoUtil.Now()
}
func (p *PlayroomMod) SetGameId(GameId int) {
p.GameId = GameId
func (p *PlayroomMod) SetGameId(gameId int) {
p.GameId = gameId
}
func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) {
if Star == 0 {
func (p *PlayroomMod) CreateOrderReward(star int, itemMod *item.ItemMod) {
if star == 0 {
return
}
FoodItem := playroomCfg.GetFoodItem()
CleanItem := playroomCfg.GetCleanItem()
ToyItem := playroomCfg.GetToyItem()
DailyItem := playroomCfg.GetDailyItem()
foodItem := playroomCfg.GetFoodItem()
cleanItem := playroomCfg.GetCleanItem()
toyItem := playroomCfg.GetToyItem()
dailyItem := playroomCfg.GetDailyItem()
FoodItemNum := itemMod.GetItemNumByList(FoodItem)
CleanItemNum := itemMod.GetItemNumByList(CleanItem)
ToyItemNum := itemMod.GetItemNumByList(ToyItem)
DailyItemNum := itemMod.GetItemNumByList(DailyItem)
foodItemNum := itemMod.GetItemNumByList(foodItem)
cleanItemNum := itemMod.GetItemNumByList(cleanItem)
toyItemNum := itemMod.GetItemNumByList(toyItem)
dailyItemNum := itemMod.GetItemNumByList(dailyItem)
type d struct {
Id []int
Num int
}
sortList := []d{
{Id: FoodItem, Num: FoodItemNum},
{Id: CleanItem, Num: CleanItemNum},
{Id: ToyItem, Num: ToyItemNum},
{Id: DailyItem, Num: DailyItemNum},
{Id: foodItem, Num: foodItemNum},
{Id: cleanItem, Num: cleanItemNum},
{Id: toyItem, Num: toyItemNum},
{Id: dailyItem, Num: dailyItemNum},
}
sort.Slice(sortList, func(i, j int) bool {
return sortList[i].Num < sortList[j].Num
})
Prob := GoUtil.RandSlice(sortList[0].Id)
p.Reward = []*item.Item{{Id: Prob, Num: 1}}
prob := GoUtil.RandSlice(sortList[0].Id)
p.Reward = []*item.Item{{Id: prob, Num: 1}}
}
func (p *PlayroomMod) GetReward() []*item.Item {
return p.Reward
}
func (p *PlayroomMod) Interact(Id, Type int) ([]*item.Item, int, error) {
MoodType, ItemList, Effect := playroomCfg.GetInteract(Id, Type)
if MoodType == 0 {
func (p *PlayroomMod) Interact(id, iType int) ([]*item.Item, int, error) {
moodType, items, effect := playroomCfg.GetInteract(id, iType)
if moodType == 0 {
return nil, 0, fmt.Errorf("Interact MoodType is 0")
}
if Effect > 0 {
if effect > 0 {
p.AllMood = min(100, p.AllMood+10)
}
PType, PEffect := playroomCfg.GetInteractPhysiology(Id)
p.AddPhysiology(PType, PEffect)
p.AddMood(MoodType, Effect)
return ItemList, PType, nil
pType, pEffect := playroomCfg.GetInteractPhysiology(id)
p.AddPhysiology(pType, pEffect)
p.AddMood(moodType, effect)
return items, pType, nil
}
func (p *PlayroomMod) AddInteractNum(Lv int) {
Unlock := playroomCfg.GetInteractUnlock()
if Lv < Unlock {
func (p *PlayroomMod) AddInteractNum(lv int) {
unlock := playroomCfg.GetInteractUnlock()
if lv < unlock {
return
}
p.InteractNum++
p.InteractNum = min(p.InteractNum, playroomCfg.GetInteractNum())
}
func (p *PlayroomMod) AddMood(Id, Num int) {
_, ok := p.MoodInfo[Id]
func (p *PlayroomMod) AddMood(id, num int) {
_, ok := p.MoodInfo[id]
if !ok {
p.MoodInfo[Id] = &Mood{Id: Id}
p.MoodInfo[id] = &Mood{Id: id}
}
p.MoodInfo[Id].Num = max(0, min(p.MoodInfo[Id].Num+Num, 100))
if p.MoodInfo[Id].Num != 0 && p.MoodInfo[Id].Time == 0 {
p.MoodInfo[Id].Time = GoUtil.Now()
p.MoodInfo[id].Num = max(0, min(p.MoodInfo[id].Num+num, 100))
if p.MoodInfo[id].Num != 0 && p.MoodInfo[id].Time == 0 {
p.MoodInfo[id].Time = GoUtil.Now()
}
if p.MoodInfo[Id].Num == 0 {
p.MoodInfo[Id].Time = 0
if p.MoodInfo[id].Num == 0 {
p.MoodInfo[id].Time = 0
}
}
func (p *PlayroomMod) GetMoodNum(MoodType int) int {
Mood, ok := p.MoodInfo[MoodType]
func (p *PlayroomMod) GetMoodNum(moodType int) int {
mood, ok := p.MoodInfo[moodType]
if !ok {
return 0
}
return Mood.Num
return mood.Num
}
func (p *PlayroomMod) AddPhysiology(Id, Num int) {
Phy := p.GetPhysiology(Id)
if Phy == nil {
Phy = &Physiology{Id: Id}
p.Physiology[Id] = Phy
func (p *PlayroomMod) AddPhysiology(id, num int) {
phy := p.GetPhysiology(id)
if phy == nil {
phy = &Physiology{Id: id}
p.Physiology[id] = phy
}
Max := playroomCfg.GetPhysiologyMax(Id)
Phy.Num = max(0, min(Phy.Num+Num, Max))
Phy.Time = GoUtil.Now()
if Phy.Num == 0 {
Phy.Time = 0
maxNum := playroomCfg.GetPhysiologyMax(id)
phy.Num = max(0, min(phy.Num+num, maxNum))
phy.Time = GoUtil.Now()
if phy.Num == 0 {
phy.Time = 0
}
}
func (p *PlayroomMod) AddVisitor(Id int, Time int64) {
v, ok := p.Visitor[Id]
func (p *PlayroomMod) AddVisitor(id int, time int64) {
v, ok := p.Visitor[id]
if !ok {
p.Visitor[Id] = &Info{Time: Time, Times: 1}
p.Visitor[id] = &Info{Time: time, Times: 1}
return
}
v.Times++
v.Time = Time
v.Time = time
}
func (p *PlayroomMod) SetRoom(Room map[int]int) (map[int]int, error) {
diff := GoUtil.DiffMap(p.Room, Room)
p.Room = Room
func (p *PlayroomMod) SetRoom(room map[int]int) (map[int]int, error) {
diff := GoUtil.DiffMap(p.Room, room)
p.Room = room
return diff, nil
}
func (p *PlayroomMod) AddCollect(Id int, Label string) {
p.NewCollect[Id] = &CollectInfo{
Id: Id,
func (p *PlayroomMod) AddCollect(id int, label string) {
p.NewCollect[id] = &CollectInfo{
Id: id,
AddTime: GoUtil.Now(),
Label: Label,
Label: label,
}
}
func (p *PlayroomMod) AddDress(Id int, Label string) {
Part := playroomCfg.GetDressPart(Id)
if _, ok := p.NewDress[Id]; !ok {
p.NewDress[Id] = &DressInfo{
Id: Id,
Part: Part,
func (p *PlayroomMod) AddDress(id int, label string) {
part := playroomCfg.GetDressPart(id)
if _, ok := p.NewDress[id]; !ok {
p.NewDress[id] = &DressInfo{
Id: id,
Part: part,
AddTime: GoUtil.Now(),
Label: Label,
Label: label,
Num: 1,
}
} else {
p.NewDress[Id].Num++
p.NewDress[id].Num++
}
}
@ -606,43 +606,44 @@ func (p *PlayroomMod) ResetLose() {
p.LoseItem = nil
}
func (p *PlayroomMod) SetGameReward(Chess1, Chess2, Star int) {
p.GameReward[1] = &item.Item{Id: Chess1, Num: 1}
p.GameReward[2] = &item.Item{Id: Chess2, Num: 1}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
func (p *PlayroomMod) SetGameReward(chess1, chess2, star int) {
p.GameReward[1] = &item.Item{Id: chess1, Num: 1}
p.GameReward[2] = &item.Item{Id: chess2, Num: 1}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
}
func (p *PlayroomMod) SetGameReward2(Chess1, Star int) {
p.GameReward[1] = &item.Item{Id: Chess1, Num: 1}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
func (p *PlayroomMod) SetGameReward2(chess1, star int) {
p.GameReward[1] = &item.Item{Id: chess1, Num: 1}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
}
func (p *PlayroomMod) SetGameReward3(Star int) {
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
func (p *PlayroomMod) SetGameReward3(star int) {
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
}
func (p *PlayroomMod) SetGameRewardFlip(N1, N2, N3 int) {
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: N1}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: N2}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: N3}
// N1, N2, N3分别是铜、银、金翻牌的奖励数量，经过玩家的加成后再设置到GameReward中
func (p *PlayroomMod) SetGameRewardFlip(n1, n2, n3 int) {
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: n1}
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: n2}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: n3}
}
func (p *PlayroomMod) SelectReward(Id int) []*item.Item {
v, ok := p.GameReward[Id]
func (p *PlayroomMod) SelectReward(id int) []*item.Item {
v, ok := p.GameReward[id]
if !ok {
return nil
}
var Items []*item.Item
Items = append(Items, v)
if Id < 3 {
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 5))
var items []*item.Item
items = append(items, v)
if id < 3 {
items = append(items, item.NewItem(item.ITEM_STAR_ID, 5))
}
return Items
return items
}
func (p *PlayroomMod) Lose(Item []*item.Item) {
p.LoseItem = append(p.LoseItem, Item...)
func (p *PlayroomMod) Lose(items []*item.Item) {
p.LoseItem = append(p.LoseItem, items...)
}
func (p *PlayroomMod) Work() ([]*item.Item, error) {
@ -653,16 +654,19 @@ func (p *PlayroomMod) Work() ([]*item.Item, error) {
p.Starttime = GoUtil.Now()
p.Endtime = GoUtil.Now() + 86400
p.WorkStatus = 1
ItemId := playroomCfg.GetWorkItem()
return []*item.Item{item.NewItem(ItemId, 1)}, nil
itemId := playroomCfg.GetWorkItem()
if itemId == 0 {
return nil, fmt.Errorf("Work ItemId is 0")
}
return []*item.Item{item.NewItem(itemId, 1)}, nil
}
func (p *PlayroomMod) Rest() {
p.WorkStatus = 2
}
func (p *PlayroomMod) SetWorkOutline(Status int) {
p.WorkOutline = Status
func (p *PlayroomMod) SetWorkOutline(status int) {
p.WorkOutline = status
}
func (p *PlayroomMod) ResetWork() {
@ -674,16 +678,16 @@ func (p *PlayroomMod) Outline() {
p.WorkOutline = 1
}
func (p *PlayroomMod) GetVisitorInfo(Id int) (int, int64) {
v, ok := p.Visitor[Id]
func (p *PlayroomMod) GetVisitorInfo(id int) (int, int64) {
v, ok := p.Visitor[id]
if !ok {
return 0, 0
}
return v.Times, v.Time
}
func (p *PlayroomMod) GetTaskReward(Type int) (int, []*item.Item, error) {
if GoUtil.InArray(Type, p.DailyTaskReward) {
func (p *PlayroomMod) GetTaskReward(taskType int) (int, []*item.Item, error) {
if GoUtil.InArray(taskType, p.DailyTaskReward) {
return 0, nil, fmt.Errorf("GetTaskReward Type is already in DailyTaskReward")
}
finish := 0
@ -692,42 +696,39 @@ func (p *PlayroomMod) GetTaskReward(Type int) (int, []*item.Item, error) {
finish++
}
}
if Type == DAILY_TASK_TYPE_ONE && finish < playroomCfg.GetPlayroomTaskDailyNum1() {
if taskType == DAILY_TASK_TYPE_ONE && finish < playroomCfg.GetPlayroomTaskDailyNum1() {
return 0, nil, fmt.Errorf("GetTaskReward Type is DAILY_TASK_TYPE_ONE but finish is %d", finish)
}
if Type == DAILY_TASK_TYPE_TWO && finish < playroomCfg.GetPlayroomTaskDailyNum1()+playroomCfg.GetPlayroomTaskDailyNum2() {
if taskType == DAILY_TASK_TYPE_TWO && finish < playroomCfg.GetPlayroomTaskDailyNum1()+playroomCfg.GetPlayroomTaskDailyNum2() {
return 0, nil, fmt.Errorf("GetTaskReward Type is DAILY_TASK_TYPE_TWO but finish is %d", finish)
}
p.DailyTaskReward = append(p.DailyTaskReward, Type)
Id := 0
var Items []*item.Item
ProbList := playroomCfg.GetTaskJackpotProb()
Id = GoUtil.RandMap(ProbList)
Items = playroomCfg.GetTaskJackpotReward(Id)
if len(Items) > 1 {
p.DailyTaskReward = append(p.DailyTaskReward, taskType)
id := 0
var items []*item.Item
probList := playroomCfg.GetTaskJackpotProb()
id = GoUtil.RandMap(probList)
items = playroomCfg.GetTaskJackpotReward(id)
if len(items) > 1 {
// 多个奖励时，随机选择一个
Items = []*item.Item{GoUtil.RandItem(Items)}
items = []*item.Item{GoUtil.RandItem(items)}
}
return Id, Items, nil
return id, items, nil
}
func (p *PlayroomMod) Draw() (int, []*item.Item, error) {
// if p.AllMood < 100 {
// return 0, nil, fmt.Errorf("Draw AllMood < 100")
// }
if p.JackpotNum == 0 {
return 0, nil, fmt.Errorf("Draw JackpotNum is 0")
}
p.JackpotNum--
p.AllMood = 0
ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
Id := GoUtil.RandMap(ProbList)
Items := limitedTimeEventCfg.GetSenceJackpotReward(Id)
if len(Items) > 1 {
probList := limitedTimeEventCfg.GetSenceJackpotProb()
id := GoUtil.RandMap(probList)
items := limitedTimeEventCfg.GetSenceJackpotReward(id)
if len(items) > 1 {
// 多个奖励时，随机选择一个
Items = []*item.Item{GoUtil.RandItem(Items)}
items = []*item.Item{GoUtil.RandItem(items)}
}
return Id, Items, nil
return id, items, nil
}
func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
@ -738,25 +739,25 @@ func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
}
func (p *PlayroomMod) NotifyLose() *msg.NotifyPlayroomLose {
ChipMessage := make([]*msg.ChipInfo, 0, len(p.ChipList))
chipMessage := make([]*msg.ChipInfo, 0, len(p.ChipList))
for _, v := range p.ChipList {
ChipMessage = append(ChipMessage, &msg.ChipInfo{
chipMessage = append(chipMessage, &msg.ChipInfo{
Uid: int64(v.Uid),
})
}
return &msg.NotifyPlayroomLose{
LoseItem: item.ItemToMsg(p.LoseItem),
Chip: ChipMessage,
Chip: chipMessage,
Revenge: p.RevengeUid,
}
}
func (p *PlayroomMod) ResetPhysiology(MoodType int) {
PhysiologyList := playroomCfg.GetPhysiologyList(MoodType)
for _, v := range PhysiologyList {
Phy := p.GetPhysiology(v)
if Phy != nil {
Phy.Num = 0
Phy.Time = 0
physiologyList := playroomCfg.GetPhysiologyList(MoodType)
for _, v := range physiologyList {
phy := p.GetPhysiology(v)
if phy != nil {
phy.Num = 0
phy.Time = 0
}
}
}
@ -767,9 +768,9 @@ func (p *PlayroomMod) NotifyStatus() *msg.NofiPlayroomStatus {
}
func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
Mood := make(map[int32]int32)
mood := make(map[int32]int32)
for k, v := range p.MoodInfo {
Mood[int32(k)] = int32(v.Num)
mood[int32(k)] = int32(v.Num)
}
var resAdItems []*msg.AdItem
for k, v := range p.ADItem {
@ -781,24 +782,24 @@ func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
}
return &msg.NotifyPlayroomMood{
AllMood: int32(p.AllMood),
Mood: Mood,
Mood: mood,
Physiology: GoUtil.MapIntToInt32(p.GetPhysiologyList()),
AdItem: resAdItems,
}
}
func (p *PlayroomMod) Fire(ChargeId int) []*item.Item {
WorkChargeId := playroomCfg.GetWorkChargeId()
if ChargeId == WorkChargeId {
ItemId := playroomCfg.GetWorkItem()
return []*item.Item{item.NewItem(ItemId, 1)}
func (p *PlayroomMod) Fire(chargeId int) []*item.Item {
workChargeId := playroomCfg.GetWorkChargeId()
if chargeId == workChargeId {
itemId := playroomCfg.GetWorkItem()
return []*item.Item{item.NewItem(itemId, 1)}
}
return nil
}
func (p *PlayroomMod) RemoveChip(Uids []int64) ([]*item.Item, int, error) {
func (p *PlayroomMod) RemoveChip(uids []int64) ([]*item.Item, int, error) {
len1 := len(p.ChipList)
len2 := len(Uids)
len2 := len(uids)
if len1 == 0 {
return nil, 0, fmt.Errorf("RemoveChip Uids is 0")
}
@ -806,7 +807,7 @@ func (p *PlayroomMod) RemoveChip(Uids []int64) ([]*item.Item, int, error) {
p.ChipList = nil
} else {
uidCount := make(map[int64]int)
for _, uid := range Uids {
for _, uid := range uids {
uidCount[uid]++
}
@ -823,16 +824,16 @@ func (p *PlayroomMod) RemoveChip(Uids []int64) ([]*item.Item, int, error) {
return []*item.Item{item.NewItem(item.ITEM_STAR_ID, len2*25)}, len2, nil
}
func (p *PlayroomMod) FlipCard(Pos int) (int, error) {
func (p *PlayroomMod) FlipCard(pos int) (int, error) {
if p.Status != STATUS_VISIT {
return 0, fmt.Errorf("FlipCard Status is not STATUS_VISIT")
}
RandMap := map[int]int{
randMap := map[int]int{
FLIP_TYPE_COPPER: 35,
FLIP_TYPE_SILVER: 45,
FLIP_TYPE_GOLD: 20,
}
Prob := GoUtil.RandMap(RandMap)
Prob := GoUtil.RandMap(randMap)
/**
若玩家同一天内上一次游玩猫猫小金库未能获得金币档位奖励，且当天还未获得过金币档位奖励
@ -851,58 +852,57 @@ func (p *PlayroomMod) FlipCard(Pos int) (int, error) {
Prob = FLIP_TYPE_GOLD
}
}
p.Flip[Pos] = Prob
p.Flip[pos] = Prob
return Prob, nil
}
func (p *PlayroomMod) GetFlipReward() ([]*item.Item, int, int, error) {
check := make(map[int]int)
var Items []*item.Item
T := p.Target
Result := FLIP_TYPE_COPPER
var items []*item.Item
result := FLIP_TYPE_COPPER
for _, v := range p.Flip {
check[v]++
if check[v] == 3 {
switch v {
case FLIP_TYPE_COPPER:
p.NoFlip++
Items = append(Items, p.GameReward[FLIP_TYPE_COPPER])
items = append(items, p.GameReward[FLIP_TYPE_COPPER])
case FLIP_TYPE_SILVER:
p.NoFlip++
Result = FLIP_TYPE_SILVER
Items = append(Items, p.GameReward[FLIP_TYPE_SILVER])
result = FLIP_TYPE_SILVER
items = append(items, p.GameReward[FLIP_TYPE_SILVER])
case FLIP_TYPE_GOLD:
p.NoFlip = 0
p.TodayFlip = true
Result = FLIP_TYPE_GOLD
Items = append(Items, p.GameReward[FLIP_TYPE_GOLD])
result = FLIP_TYPE_GOLD
items = append(items, p.GameReward[FLIP_TYPE_GOLD])
}
p.LastFlip = v
p.Flip = make(map[int]int)
p.ResetGame()
return Items, T, Result, nil
return items, 0, result, nil
}
}
return Items, T, Result, fmt.Errorf("GetFlipReward check is not 3")
return items, p.Target, result, fmt.Errorf("GetFlipReward check is not 3")
}
func (p *PlayroomMod) BuyItem(Id int) ([]*item.Item, []*item.Item) {
return playroomCfg.GetBuyItem(Id)
func (p *PlayroomMod) BuyItem(id int) ([]*item.Item, []*item.Item) {
return playroomCfg.GetBuyItem(id)
}
func (p *PlayroomMod) UnLock(Lv int) bool {
func (p *PlayroomMod) UnLock(lv int) bool {
UnlockLv := playroomCfg.GetUnLockLv()
if Lv < UnlockLv || len(p.Physiology) != 0 {
if lv < UnlockLv || len(p.Physiology) != 0 {
return false
}
Now := GoUtil.Now()
now := GoUtil.Now()
p.Physiology = make(map[int]*Physiology)
TypeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range TypeList {
Max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now}
typeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range typeList {
max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: max, Time: now}
}
if len(p.MoodInfo) == 0 {
p.MoodInfo = make(map[int]*Mood)
@ -913,17 +913,17 @@ func (p *PlayroomMod) UnLock(Lv int) bool {
return true
}
func (p *PlayroomMod) FixUnLock(Lv int) bool {
UnlockLv := playroomCfg.GetUnLockLv()
if Lv < UnlockLv || len(p.Physiology) != 0 {
func (p *PlayroomMod) FixUnLock(lv int) bool {
unlockLv := playroomCfg.GetUnLockLv()
if lv < unlockLv || len(p.Physiology) != 0 {
return false
}
Now := GoUtil.Now()
now := GoUtil.Now()
p.Physiology = make(map[int]*Physiology)
TypeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range TypeList {
Max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now}
typeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range typeList {
max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: max, Time: now}
}
if len(p.MoodInfo) == 0 {
p.MoodInfo = make(map[int]*Mood)
@ -935,27 +935,30 @@ func (p *PlayroomMod) FixUnLock(Lv int) bool {
}
// shop
func (p *PlayroomMod) ShopBuy(Id, Num int, WeeklyDiscount bool) ([]*item.Item, []*item.Item, error) {
AddItemId, CostItem, Discount, Limit := playroomCfg.GetShopItem(Id)
if AddItemId == 0 {
func (p *PlayroomMod) ShopBuy(id, num int, weeklyDiscount bool) ([]*item.Item, []*item.Item, error) {
addItemId, costItem, discount, limit := playroomCfg.GetShopItem(id)
if addItemId == 0 {
return nil, nil, fmt.Errorf("ShopBuy AddItemId is 0")
}
NewCostItem := CostItem[0].Num * Num
if WeeklyDiscount {
LimitNum := p.WeeklyDiscount[Id]
if LimitNum < Limit {
NewCostItem = int(math.Ceil(float64(NewCostItem) * float64(Discount) / 100))
}
p.WeeklyDiscount[Id] = LimitNum + Num
if costItem == nil || len(costItem) == 0 {
return nil, nil, fmt.Errorf("ShopBuy CostItem is nil or length is 0")
}
CostItem[0].Num = NewCostItem
return []*item.Item{item.NewItem(AddItemId, Num)}, CostItem, nil
newCostItem := costItem[0].Num * num
if weeklyDiscount {
limitNum := p.WeeklyDiscount[id]
if limitNum < limit {
newCostItem = int(math.Ceil(float64(newCostItem) * float64(discount) / 100))
}
p.WeeklyDiscount[id] = limitNum + num
}
costItem[0].Num = newCostItem
return []*item.Item{item.NewItem(addItemId, num)}, costItem, nil
}
func (p *PlayroomMod) UnlockDress(Type, Id int) error {
p.NewDress[Id] = &DressInfo{
Id: Id,
Part: Type,
func (p *PlayroomMod) UnlockDress(dType, id int) error {
p.NewDress[id] = &DressInfo{
Id: id,
Part: dType,
AddTime: GoUtil.Now(),
Num: 1,
}
@ -966,42 +969,42 @@ func (p *PlayroomMod) RandGameType() int {
return GoUtil.RandMap(map[int]int{1: 50, 3: 50})
}
func (p *PlayroomMod) UnlockPetAir(Id int) {
p.NewPetAir[Id] = &PetAirInfo{
Id: Id,
func (p *PlayroomMod) UnlockPetAir(id int) {
p.NewPetAir[id] = &PetAirInfo{
Id: id,
AddTime: GoUtil.Now(),
Num: 1,
}
}
func (p *PlayroomMod) PlayroomDressSet(DressSet map[int]int) ([]int, map[int]int, error) {
func (p *PlayroomMod) PlayroomDressSet(dressSet map[int]int) ([]int, map[int]int, error) {
// 判断服装是否存在
var Part []int
Diff := GoUtil.DiffMap(DressSet, p.DressSet)
for Type, Id := range DressSet {
if Id == 0 {
diff := GoUtil.DiffMap(dressSet, p.DressSet)
for dType, id := range dressSet {
if id == 0 {
continue
}
dressInfo, ok := p.NewDress[Id]
dressInfo, ok := p.NewDress[id]
if !ok {
return nil, nil, fmt.Errorf("dress Id not found")
}
if dressInfo.EndTime < GoUtil.Now() && dressInfo.EndTime != 0 {
return nil, nil, fmt.Errorf("dress timeout")
}
if p.DressSet[Type] != Id && Id != 0 {
Part = append(Part, Type)
if p.DressSet[dType] != id && id != 0 {
Part = append(Part, dType)
}
}
p.DressSet = DressSet
return Part, Diff, nil
p.DressSet = dressSet
return Part, diff, nil
}
func (p *PlayroomMod) GiveUpvote(Uid int) ([]*item.Item, error) {
if GoUtil.InArray(Uid, p.UpvoteList) {
func (p *PlayroomMod) GiveUpvote(uid int) ([]*item.Item, error) {
if GoUtil.InArray(uid, p.UpvoteList) {
return nil, fmt.Errorf("upvote already")
}
p.UpvoteList = append(p.UpvoteList, Uid)
p.UpvoteList = append(p.UpvoteList, uid)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, 5)}, nil
}
@ -1009,29 +1012,29 @@ func (p *PlayroomMod) AddUpvote() {
p.Upvote++
}
func (p *PlayroomMod) PlayroomPetAirSet(Id int) error {
if _, ok := p.NewPetAir[Id]; !ok {
func (p *PlayroomMod) PlayroomPetAirSet(id int) error {
if _, ok := p.NewPetAir[id]; !ok {
return fmt.Errorf("PlayroomPetAirSet Id is not ok")
}
p.PetAirSet = Id
p.PetAirSet = id
return nil
}
func (p *PlayroomMod) Unlock(Id int) error {
Need := playroomCfg.GetUnlockNeed(Id)
if Need == 0 || Need > p.RoomPoint {
func (p *PlayroomMod) Unlock(id int) error {
need := playroomCfg.GetUnlockNeed(id)
if need == 0 || need > p.RoomPoint {
return fmt.Errorf("unlock need is 0 or need > RoomPoint")
}
p.UnlockList[Id] = GoUtil.Now()
p.UnlockList[id] = GoUtil.Now()
return nil
}
func (p *PlayroomMod) GetUnlockIds() []int32 {
UnlockIds := make([]int32, 0, len(p.UnlockList))
unlockIds := make([]int32, 0, len(p.UnlockList))
for k := range p.UnlockList {
UnlockIds = append(UnlockIds, int32(k))
unlockIds = append(unlockIds, int32(k))
}
return UnlockIds
return unlockIds
}
func (p *PlayroomMod) GetDressSet() map[int]int {
@ -1051,9 +1054,9 @@ func (p *PlayroomMod) GetPetAir() map[int]*PetAirInfo {
}
func (p *PlayroomMod) BackDataTask() []*msg.DailyTask {
DailyTask := make([]*msg.DailyTask, 0, len(p.DailyTask))
dailyTask := make([]*msg.DailyTask, 0, len(p.DailyTask))
for k, v := range p.DailyTask {
DailyTask = append(DailyTask, &msg.DailyTask{
dailyTask = append(dailyTask, &msg.DailyTask{
Status: int32(v.Status),
UnLock: v.UnLock,
Progress: quest.QuestProgressToMsg(&v.Quest),
@ -1062,10 +1065,10 @@ func (p *PlayroomMod) BackDataTask() []*msg.DailyTask {
Id: int32(k),
})
}
sort.Slice(DailyTask, func(i, j int) bool {
return DailyTask[i].Index < DailyTask[j].Index
sort.Slice(dailyTask, func(i, j int) bool {
return dailyTask[i].Index < dailyTask[j].Index
})
return DailyTask
return dailyTask
}
func (p *PlayroomMod) Guide(Type int) error {

22
src/server/game/mod/quest/Quest.go
View File

@ -68,8 +68,8 @@ func ParseQuest(s string) (QuestProgress, error) {
}, nil
}
func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
if q.Label != Tr.Label {
func TriggerQuestProgress(q *QuestProgress, tr *Trigger) bool {
if q.Label != tr.Label {
return false
}
if q.Status {
@ -81,23 +81,23 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
TRIGGER_LABEL_STAR,
TRIGGER_LABEL_DIAMOND,
TRIGGER_LABEL_DECORATE: // 消耗x能量
AddNum := GoUtil.Int(Tr.A[0])
AddNum := GoUtil.Int(tr.A[0])
q.Num += AddNum
case TRIGGER_LABEL_MERGELVTIME: // 合成x级棋子y次
Lv := GoUtil.Int(Tr.A[0])
Lv := GoUtil.Int(tr.A[0])
TargetLv, _ := strconv.Atoi(q.A[0].(string))
if TargetLv == Lv {
q.Num++
}
case TRIGGER_LABEL_GUIDE_LOGIN: // 引导任务登录
LoginDay := GoUtil.Int(Tr.A[0])
LoginDay := GoUtil.Int(tr.A[0])
q.Num = LoginDay
case TRIGGER_LABEL_MERGETIME, // 合成x次
TRIGGER_LABEL_FINISHORDER,
TRIGGER_LABEL_BUBBLE: // 完成x次订单
q.Num++
case TRIGGER_LABEL_INTERACT: // 互动x类型y次
InteractId := GoUtil.Int(Tr.A[0])
InteractId := GoUtil.Int(tr.A[0])
Ids := GoUtil.IntSliceInterface(q.A)
if GoUtil.InArray(InteractId, Ids) {
q.Num++
@ -106,11 +106,11 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
if len(q.A) == 0 {
return false
}
if len(Tr.A) == 0 {
if len(tr.A) == 0 {
return false
}
Ids := GoUtil.IntSliceInterface(q.A)
arg := GoUtil.IntSlice(Tr.A[0])
arg := GoUtil.IntSlice(tr.A[0])
for _, t := range arg {
if GoUtil.InArray(t, Ids) {
q.Num++
@ -127,15 +127,15 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
}
func QuestProgressToMsg(quest *QuestProgress) *msg.QuestProgress {
Param := 0
param := 0
if len(quest.A) > 0 {
Param = GoUtil.Int(quest.A[0])
param = GoUtil.Int(quest.A[0])
}
return &msg.QuestProgress{
Label: quest.Label,
Num: int32(quest.Num),
Target: int32(quest.Target),
Status: quest.Status,
Param: int32(Param),
Param: int32(param),
}
}

64
src/server/game/mod/race/race.go
View File

@ -27,28 +27,28 @@ type Opponent struct {
Progress int
}
func (r *RaceMod) Login(Id int) int {
OldId := r.Id
if Id == 0 {
func (r *RaceMod) Login(id int) int {
oldId := r.Id
if id == 0 {
r.Id = 0
return OldId
return oldId
}
if r.Id == Id {
if r.Id == id {
return 0
}
r.Id = Id
r.Id = id
r.Pass = 1
r.StartTime = 0
r.EndTime = 0
r.Progress = 0
r.Rank = 0
r.Opponent = nil
return OldId
return oldId
}
// TODO 剩余AI逻辑未开发
func (r *RaceMod) ZeroUpdate(Id int) {
r.Login(Id)
func (r *RaceMod) ZeroUpdate(id int) {
r.Login(id)
}
func (r *RaceMod) StartGame() error {
@ -56,66 +56,66 @@ func (r *RaceMod) StartGame() error {
return fmt.Errorf("the game has started")
}
r.StartTime = GoUtil.Now()
OpponentNum := raceCfg.GetRaceNum(r.Pass)
opponentNum := raceCfg.GetRaceNum(r.Pass)
r.EndTime = r.StartTime + int64(raceCfg.GetCD(r.Id))
r.Opponent = randOpponents(OpponentNum)
r.Opponent = randOpponents(opponentNum)
r.Rank = 1
return nil
}
func (r *RaceMod) AddCoin(Num int) {
func (r *RaceMod) AddCoin(num int) {
if r.StartTime == 0 {
return
}
r.Progress += Num
r.Progress += num
}
func (r *RaceMod) GetReward() ([]*item.Item, error) {
if r.EndTime == 0 {
return nil, fmt.Errorf("the game is not over")
}
Need := raceCfg.GetRaceNeed(r.Pass)
if r.Progress < Need {
need := raceCfg.GetRaceNeed(r.Pass)
if r.Progress < need {
return nil, fmt.Errorf("not enough progress")
}
if r.Rank != 1 {
return nil, fmt.Errorf("you are not the first")
}
var Items []*item.Item
Items = append(Items, raceCfg.GetReward(r.Pass)...)
Now := GoUtil.Now()
if Now <= r.EndTime {
Items = append(Items, raceCfg.GetExtraReward(r.Pass)...)
var items []*item.Item
items = append(items, raceCfg.GetReward(r.Pass)...)
now := GoUtil.Now()
if now <= r.EndTime {
items = append(items, raceCfg.GetExtraReward(r.Pass)...)
}
r.Pass++
r.Progress -= Need
MaxPass := raceCfg.GetMaxPass(r.Id)
if r.Pass > MaxPass {
r.Progress -= need
maxPass := raceCfg.GetMaxPass(r.Id)
if r.Pass > maxPass {
r.Pass = 1
r.StartTime = 0
r.EndTime = 0
r.Opponent = nil
r.Progress = 0
} else {
r.StartTime = Now
r.EndTime = Now + int64(raceCfg.GetCD(r.Id))
r.StartTime = now
r.EndTime = now + int64(raceCfg.GetCD(r.Id))
r.Opponent = randOpponents(raceCfg.GetRaceNum(r.Pass))
}
return Items, nil
return items, nil
}
func randOpponents(OpponentNum int) []*Opponent {
opponents := make([]*Opponent, 0, OpponentNum-1)
names := randnameCfg.GetRandNames(OpponentNum)
for i := 1; i < OpponentNum; i++ {
func randOpponents(opponentNum int) []*Opponent {
opponents := make([]*Opponent, 0, opponentNum-1)
names := randnameCfg.GetRandNames(opponentNum)
for i := 1; i < opponentNum; i++ {
opponents = append(opponents, randOpponent(i, names[i]))
}
return opponents
}
func randOpponent(Id int, name string) *Opponent {
func randOpponent(id int, name string) *Opponent {
return &Opponent{
Id: Id,
Id: id,
Name: name,
Face: rand.Intn(10),
Avatar: rand.Intn(10),

82
src/server/game/mod/seven_login/seven_login.go
View File

@ -30,15 +30,15 @@ func (s *SevenLoginMod) InitData() {
}
func (s *SevenLoginMod) ZeroUpdate(Add, LastLoginTime, factor, level int) {
WeekZeroTimestamp := GoUtil.WeekZeroTimestamp()
Now := GoUtil.Now()
if WeekZeroTimestamp > s.WeekResetTime {
RewardType := GoUtil.IfTrue(Now-int64(LastLoginTime) > GoUtil.SEVENDAYS && LastLoginTime > 0, BACK_REWARD, DEFAULT_REWARD).(int)
s.IsBack = RewardType == BACK_REWARD
s.LoginReward = randWeekReward(Add, RewardType, level)
func (s *SevenLoginMod) ZeroUpdate(add, lastLoginTime, factor, level int) {
weekZeroTimestamp := GoUtil.WeekZeroTimestamp()
now := GoUtil.Now()
if weekZeroTimestamp > s.WeekResetTime {
rewardType := GoUtil.IfTrue(now-int64(lastLoginTime) > GoUtil.SEVENDAYS && lastLoginTime > 0, BACK_REWARD, DEFAULT_REWARD).(int)
s.IsBack = rewardType == BACK_REWARD
s.LoginReward = randWeekReward(add, rewardType, level)
s.LoginReward = formatSevenReward(s.LoginReward, factor)
s.WeekResetTime = WeekZeroTimestamp
s.WeekResetTime = weekZeroTimestamp
s.DayR = 0
}
monthZeroTimestamp := GoUtil.MonthZeroTimestamp()
@ -51,53 +51,53 @@ func (s *SevenLoginMod) ZeroUpdate(Add, LastLoginTime, factor, level int) {
s.DayR++
}
func (s *SevenLoginMod) GetReward(Id int) ([]*item.Item, error) {
if Id > s.DayR {
func (s *SevenLoginMod) GetReward(id int) ([]*item.Item, error) {
if id > s.DayR {
return nil, fmt.Errorf("id greater than login days")
}
Reward := s.LoginReward[Id]
if Reward.Status {
reward := s.LoginReward[id]
if reward.Status {
return nil, fmt.Errorf("reward already received")
}
Reward.Status = true
s.LoginReward[Id] = Reward
reward.Status = true
s.LoginReward[id] = reward
s.Active++
item := make([]*item.Item, 0)
item = append(item, Reward.Item1...)
item = append(item, Reward.Item2...)
item = append(item, Reward.Item3...)
item = append(item, reward.Item1...)
item = append(item, reward.Item2...)
item = append(item, reward.Item3...)
return item, nil
}
func (s *SevenLoginMod) GetMonthReward(Id int) ([]*item.Item, error) {
NeedActive := sevenLoginCfg.GetMonthActive(Id)
if NeedActive > s.Active {
func (s *SevenLoginMod) GetMonthReward(id int) ([]*item.Item, error) {
needActive := sevenLoginCfg.GetMonthActive(id)
if needActive > s.Active {
return nil, fmt.Errorf("id greater than active")
}
Reward := s.MonthReward[Id]
if Reward.Status {
reward := s.MonthReward[id]
if reward.Status {
return nil, fmt.Errorf("reward already received")
}
Reward.Status = true
s.MonthReward[Id] = Reward
reward.Status = true
s.MonthReward[id] = reward
item := make([]*item.Item, 0)
item = append(item, Reward.Item1...)
item = append(item, Reward.Item2...)
item = append(item, Reward.Item3...)
item = append(item, reward.Item1...)
item = append(item, reward.Item2...)
item = append(item, reward.Item3...)
return item, nil
}
func (s *SevenLoginMod) BackData() *msg.ResSevenLogin {
WeekReward := make([]*msg.SevenLoginReward, 0)
MonthReward := make([]*msg.SevenLoginReward, 0)
weekReward := make([]*msg.SevenLoginReward, 0)
monthReward := make([]*msg.SevenLoginReward, 0)
for k, v := range s.LoginReward {
Status := GoUtil.IfTrue(!v.Status && s.DayR >= k, 1, 0).(int)
Status = GoUtil.IfTrue(v.Status, 2, Status).(int)
WeekReward = append(WeekReward, &msg.SevenLoginReward{
status := GoUtil.IfTrue(!v.Status && s.DayR >= k, 1, 0).(int)
status = GoUtil.IfTrue(v.Status, 2, status).(int)
weekReward = append(weekReward, &msg.SevenLoginReward{
Item1: item.ItemToMsg(v.Item1),
Item2: item.ItemToMsg(v.Item2),
Item3: item.ItemToMsg(v.Item3),
Status: int32(Status),
Status: int32(status),
Id: int32(k),
})
}
@ -106,22 +106,22 @@ func (s *SevenLoginMod) BackData() *msg.ResSevenLogin {
if k < 0 {
continue
}
Active := sevenLoginCfg.GetMonthActive(k)
Status := GoUtil.IfTrue(!v.Status && s.Active >= Active, 1, 0).(int)
Status = GoUtil.IfTrue(v.Status, 2, Status).(int)
MonthReward = append(MonthReward, &msg.SevenLoginReward{
active := sevenLoginCfg.GetMonthActive(k)
status := GoUtil.IfTrue(!v.Status && s.Active >= active, 1, 0).(int)
status = GoUtil.IfTrue(v.Status, 2, status).(int)
monthReward = append(monthReward, &msg.SevenLoginReward{
Item1: item.ItemToMsg(v.Item1),
Item2: item.ItemToMsg(v.Item2),
Item3: item.ItemToMsg(v.Item3),
Status: int32(Status),
Status: int32(status),
Id: int32(k),
NeedActive: int32(Active),
NeedActive: int32(active),
})
}
return &msg.ResSevenLogin{
WeekReward: WeekReward,
MonthReward: MonthReward,
WeekReward: weekReward,
MonthReward: monthReward,
Active: int32(s.Active),
IsBack: s.IsBack,
}

110
src/server/game/player_back.go
View File

@ -25,19 +25,19 @@ func (p *Player) PlayroomBackData() {
r.Status = int32(PlayroomMod.Status)
r.Items = item.ItemToMsg(PlayroomMod.Reward)
Opponent := make([]*proto.RoomOpponent, 0, len(PlayroomMod.Visitor))
opponent := make([]*proto.RoomOpponent, 0, len(PlayroomMod.Visitor))
FriendList := make([]*proto.FriendRoom, 0, len(FriendMod.GetFriendList()))
if PlayroomMod.Target == 0 {
PlayroomMod.SetTarget(p.GetVisitorPlayer())
}
TargerRoom := &proto.FriendRoom{}
targetRoom := &proto.FriendRoom{}
if PlayroomMod.Target != 0 {
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(PlayroomMod.Target)
if PlayerData != nil {
TargerRoom.Uid = int64(PlayerData.Uid)
TargerRoom.Name = PlayerData.Name
TargerRoom.Face = int32(PlayerData.Face)
TargerRoom.Avatar = int32(PlayerData.Avatar)
playerData := G_GameLogicPtr.GetSimplePlayerByUid(PlayroomMod.Target)
if playerData != nil {
targetRoom.Uid = int64(playerData.Uid)
targetRoom.Name = playerData.Name
targetRoom.Face = int32(playerData.Face)
targetRoom.Avatar = int32(playerData.Avatar)
} else {
PlayroomMod.Target = 0
}
@ -48,7 +48,7 @@ func (p *Player) PlayroomBackData() {
continue
}
if !FriendMod.CheckFriend(k) {
Opponent = append(Opponent, &proto.RoomOpponent{
opponent = append(opponent, &proto.RoomOpponent{
Uid: int64(k),
Name: ps.Name,
Face: int32(ps.Face),
@ -57,8 +57,8 @@ func (p *Player) PlayroomBackData() {
})
}
}
Friend := FriendMod.GetFriendList()
for k := range Friend {
friend := FriendMod.GetFriendList()
for k := range friend {
ps := G_GameLogicPtr.GetSimplePlayerByUid(k)
if ps == nil {
continue
@ -72,24 +72,24 @@ func (p *Player) PlayroomBackData() {
Times: int32(Times),
})
}
r.Opponent = Opponent
r.Opponent = opponent
r.Friend = FriendList
r.Target = TargerRoom
r.Target = targetRoom
collectList := PlayroomMod.GetCollect()
Collect := make([]*proto.PlayroomCollectInfo, 0, len(collectList))
collect := make([]*proto.PlayroomCollectInfo, 0, len(collectList))
for _, v := range collectList {
Collect = append(Collect, &proto.PlayroomCollectInfo{
collect = append(collect, &proto.PlayroomCollectInfo{
Id: int32(v.Id),
AddTime: v.AddTime,
EndTime: v.EndTime,
Label: v.Label,
})
}
r.Collect = Collect
Dress := make(map[int32]*proto.PlayroomDress)
r.Collect = collect
dress := make(map[int32]*proto.PlayroomDress)
for _, v := range PlayroomMod.GetDress() {
PlayroomDress, ok := Dress[int32(v.Part)]
PlayroomDress, ok := dress[int32(v.Part)]
if !ok {
PlayroomDress = &proto.PlayroomDress{}
}
@ -99,25 +99,25 @@ func (p *Player) PlayroomBackData() {
EndTime: int64(v.EndTime),
Label: v.Label,
})
Dress[int32(v.Part)] = PlayroomDress
dress[int32(v.Part)] = PlayroomDress
}
ChipMessage := make([]*proto.ChipInfo, 0, len(PlayroomMod.ChipList))
chipMessage := make([]*proto.ChipInfo, 0, len(PlayroomMod.ChipList))
for _, v := range PlayroomMod.ChipList {
ChipMessage = append(ChipMessage, &proto.ChipInfo{
chipMessage = append(chipMessage, &proto.ChipInfo{
Uid: int64(v.Uid),
EmojiId: int32(v.Emoji),
})
}
AdWatch := make([]*proto.AdItem, 0, len(PlayroomMod.ADItem))
adWatch := make([]*proto.AdItem, 0, len(PlayroomMod.ADItem))
for k, v := range PlayroomMod.ADItem {
AdWatch = append(AdWatch, &proto.AdItem{
adWatch = append(adWatch, &proto.AdItem{
Watch: int32(v.Watch),
LastWatch: int32(v.LastTime),
ItemId: int32(k),
})
}
r.Dress = Dress
r.Dress = dress
r.DressSet = GoUtil.MapIntToInt32(PlayroomMod.GetDressSet())
petAirList := PlayroomMod.GetPetAir()
PetAir := make([]*proto.PlayroomAirInfo, 0, len(petAirList))
@ -146,7 +146,7 @@ func (p *Player) PlayroomBackData() {
r.WeeklyDiscount = weeklyDiscount
r.PetAir = PetAir
r.PetAirSet = int32(PlayroomMod.GetPetAirSet())
r.Chip = ChipMessage
r.Chip = chipMessage
r.StartTime = int32(PlayroomMod.Starttime)
r.WorkStatus = int32(PlayroomMod.WorkStatus)
r.Playroom = GoUtil.MapIntToInt32(PlayroomMod.GetRoom())
@ -162,34 +162,34 @@ func (p *Player) PlayroomBackData() {
r.Kiss = int32(p.GetPlayroomKiss(int(p.M_DwUin)))
r.Revenge = PlayroomMod.RevengeUid
r.InteractNum = int32(PlayroomMod.InteractNum)
r.AdItem = AdWatch
r.AdItem = adWatch
p.PushClientRes(r)
}
func (p *Player) PlayroomVisit(Uid int) {
if Uid == 0 {
func (p *Player) PlayroomVisit(uid int) {
if uid == 0 {
p.PushClientRes(&proto.ResPlayroomInfo{})
return
}
PlayroomMod := p.PlayMod.getPlayroomMod()
r := &proto.ResPlayroomInfo{}
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(uid)
if PlayerData == nil {
p.PushClientRes(&proto.ResPlayroomInfo{})
return
}
Now := GoUtil.Now()
Work := false
if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > Now {
Work = true
now := GoUtil.Now()
work := false
if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > now {
work = true
}
r.Uid = int64(Uid)
r.Uid = int64(uid)
r.Name = PlayerData.Name
r.Face = int32(PlayerData.Face)
r.Avatar = int32(PlayerData.Avatar)
r.Playroom = GoUtil.MapIntToInt32(PlayerData.Playroom)
r.GameId = int32(PlayroomMod.GameId)
r.Defense = Work
r.Defense = work
r.Emoji = GoUtil.MapIntToInt32(PlayerData.Emoji)
r.PetName = PlayerData.PetName
Items := make(map[int32]*proto.ItemInfo)
@ -199,12 +199,12 @@ func (p *Player) PlayroomVisit(Uid int) {
Num: int32(v.Num),
}
}
r.Upvote = GoUtil.InArray(Uid, PlayroomMod.UpvoteList)
r.Upvote = GoUtil.InArray(uid, PlayroomMod.UpvoteList)
r.Items = Items
r.Status = int32(PlayroomMod.GameStatus)
r.UpvoteCount = int32(p.GetPlayroomUpvote(Uid))
r.Chip = int32(p.GetPlayroomChip(Uid))
r.Kiss = int32(p.GetPlayroomKiss(Uid))
r.UpvoteCount = int32(p.GetPlayroomUpvote(uid))
r.Chip = int32(p.GetPlayroomChip(uid))
r.Kiss = int32(p.GetPlayroomKiss(uid))
r.DressSet = GoUtil.MapIntToInt32(PlayerData.DressSet)
r.Fur = int32(PlayerData.PetFur)
p.PushClientRes(r)
@ -242,17 +242,17 @@ func (p *Player) BackUserInfo() {
func (p *Player) ChargeBackData() {
c := p.PlayMod.getChargeMod()
LimitedEventMod := p.PlayMod.getLimitedTimeEventMod()
SpecialShop := make(map[int32]*proto.ResSpecialShop)
ChessShop := make(map[int32]*proto.ResChessShop)
specialShop := make(map[int32]*proto.ResSpecialShop)
chessShop := make(map[int32]*proto.ResChessShop)
for k, v := range c.SpecialShop {
SpecialShop[int32(k)] = &proto.ResSpecialShop{
specialShop[int32(k)] = &proto.ResSpecialShop{
Grade: int32(v.Grade),
Count: int32(v.Count),
}
}
for k, v := range c.ChessShop {
ChessShop[int32(k)] = &proto.ResChessShop{
chessShop[int32(k)] = &proto.ResChessShop{
Diamond: int32(v.Diamond),
Count: int32(v.Count),
ChessId: int32(v.Id),
@ -266,20 +266,20 @@ func (p *Player) ChargeBackData() {
Uid: c.WishList.SendList,
}
}
WeeklyDiscount := make(map[int32]*proto.WeeklyDiscountInfo)
WeeklyDiscountInfo := chargeCfg.GetWeeklyInfoAll()
weeklyDiscount := make(map[int32]*proto.WeeklyDiscountInfo)
weeklyDiscountInfo := chargeCfg.GetWeeklyInfoAll()
// 优惠日开启或者猫咪闪促开启
if c.IsWeeklyDiscountDay() || LimitedEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_DAY_SALE) {
for k, v := range WeeklyDiscountInfo {
for k, v := range weeklyDiscountInfo {
LimitNum := c.WeeklyDiscount[k]
WeeklyDiscount[int32(k)] = &proto.WeeklyDiscountInfo{
weeklyDiscount[int32(k)] = &proto.WeeklyDiscountInfo{
Discount: int32(v.Discount),
Count: int32(v.WeeklyLimit - LimitNum),
Id: int32(k),
}
}
}
CatDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime()
catDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime()
var specialChargeWeek int32
if c.LastSpecialCharge != 0 {
specialChargeWeek = int32(GoUtil.FullWeeksSince(c.LastSpecialCharge))
@ -288,9 +288,9 @@ func (p *Player) ChargeBackData() {
Charge: float32(c.Charge),
Total: int32(c.Total),
First: GoUtil.MapIntToSlice(c.EnergyShop),
SpecialShop: SpecialShop,
SpecialShop: specialShop,
FreeShop: int32(c.FreeShop),
ChessShop: ChessShop,
ChessShop: chessShop,
Gift: GoUtil.MapIntToInt32(c.Gift),
Ad: c.Ad,
SpecialCharge: float32(c.SpecialCharge),
@ -299,9 +299,9 @@ func (p *Player) ChargeBackData() {
MonthCharge: float32(c.MonthCharge),
Wish: resWish,
AdEndTime: c.AdEndTime,
WeeklyDiscount: WeeklyDiscount,
WeeklyDiscount: weeklyDiscount,
PetWorkRemainTime: c.PetWorkTime,
WeeklyEndTime: max(c.WeeklyEndTime, CatDaySaleEndTime),
WeeklyEndTime: max(c.WeeklyEndTime, catDaySaleEndTime),
})
}
@ -335,16 +335,16 @@ func (p *Player) FriendListBackData() {
}
}
now := GoUtil.Now()
ReqFriendList := make([]int64, 0, len(FriendMod.SendApply))
reqFriendList := make([]int64, 0, len(FriendMod.SendApply))
for k, v := range FriendMod.SendApply {
if now-v > oneday {
continue
}
ReqFriendList = append(ReqFriendList, int64(k))
reqFriendList = append(reqFriendList, int64(k))
}
p.PushClientRes(&proto.ResFriendList{
FriendList: fl,
ReqApplyList: ReqFriendList,
ReqApplyList: reqFriendList,
Npc: GoUtil.IntToInt32(FriendMod.GetNpc()),
Sponsor: int32(FriendMod.GetSponsor()),
})

86
src/server/game/player_base_mod.go
View File

@ -85,10 +85,10 @@ func (p *PlayerBaseData) Recover(old *PlayerBaseData) *PlayerBaseData {
return old
}
func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
func (p *PlayerBaseData) LoadDataFromDB(userName interface{}) bool {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE user_name = ?"
sqlStruck := db.ResPlayerBaseInfo{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, UserName); err != nil {
if err := db.SqlDb.Get(&sqlStruck, sqlStr, userName); err != nil {
log.Debug("PlayerBaseData get data failed, err:%v\n", err)
return false
}
@ -118,10 +118,10 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
return true
}
func (p *PlayerBaseData) LoadDataFromDBByUid(Uid int) bool {
func (p *PlayerBaseData) LoadDataFromDBByUid(uid int) bool {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE DwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, Uid); err != nil {
if err := db.SqlDb.Get(&sqlStruck, sqlStr, uid); err != nil {
log.Debug("PlayerBaseData get data failed, err:%v\n", err)
return false
}
@ -151,7 +151,7 @@ func (p *PlayerBaseData) LoadDataFromDBByUid(Uid int) bool {
return true
}
func (p *PlayerBaseData) SaveDataFromDB(Key interface{}) bool {
func (p *PlayerBaseData) SaveDataFromDB(key interface{}) bool {
BaseMod := p.p.PlayMod.getBaseMod()
sqlStruck := db.ResPlayerBaseInfo{}
sqlStruck.Diamond = int32(BaseMod.Diamond)
@ -178,17 +178,16 @@ func (p *PlayerBaseData) SaveDataFromDB(Key interface{}) bool {
sqlStruck.FaceBookId = p.Data.FaceBookId
sqlStruck.NickName = BaseMod.NickName
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin")
return true
}
func (p *PlayerBaseData) GetMaxEnergyMul(player *Player) int {
BaseMod := player.PlayMod.getBaseMod()
MaxEnergyMul := baseCfg.GetMaxEnergyMul(BaseMod.GetLevel(), BaseMod.GetEnergy())
maxEnergyMul := baseCfg.GetMaxEnergyMul(BaseMod.GetLevel(), BaseMod.GetEnergy())
if player.PlayMod.getLimitedTimeEventMod().CheckExist(limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER) {
MaxEnergyMul = 11
maxEnergyMul = 11
}
return MaxEnergyMul
return maxEnergyMul
}
func (p *PlayerBaseData) GetMaxEnergy() int {
@ -276,7 +275,6 @@ func (p *PlayerBaseData) ReqUnBindFacebook(player *Player, buf []byte) {
if err != nil {
return
}
res.ResultCode = 0
res.BindAccountId = req.BindAccountId
p.Data.FaceBookId = ""
@ -298,7 +296,6 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(player *Player, buf []byte) {
if err != nil {
return
}
sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?"
sqlStruck := db.ResPlayerBaseInfo{}
isHaveOther := false
@ -313,7 +310,6 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(player *Player, buf []byte) {
res.ResultCode = MergeConst.Protocol_FaceBook_Binded
} else {
sqlStruck.FaceBookId = ""
// 修改双方的faceBookId
ctx := context.Background()
txOptions := &sql.TxOptions{}
@ -365,11 +361,9 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
if err != nil {
return
}
sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?"
sqlStruck := db.ResPlayerBaseInfo{}
isHaveOther := false
if err := db.SqlDb.Get(&sqlStruck, sqlStr, req.NewFBId); err != nil {
isHaveOther = false
} else {
@ -378,16 +372,16 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
if sqlStruck.DwUin == player.M_DwUin {
return
}
OldPlayer := G_GameLogicPtr.GetPlayer(sqlStruck.DwUin)
if OldPlayer != nil {
agent := OldPlayer.GetAgentByPlayer()
oldPlayer := G_GameLogicPtr.GetPlayer(sqlStruck.DwUin)
if oldPlayer != nil {
agent := oldPlayer.GetAgentByPlayer()
// notify := &msg.ForceKickOut{}
notify := &msg.ResSynGameData{}
data, _ := proto.Marshal(notify)
if agent != nil {
G_getGameLogic().PackResInfo(agent, "ResSynGameData", data)
}
OldPlayer.ClearData()
oldPlayer.ClearData()
G_GameLogicPtr.M_Players.Delete(sqlStruck.DwUin)
}
@ -395,8 +389,8 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
if sqlStruck.DwUin == p.Data.DwUin {
res.ResultCode = MergeConst.Protocol_FaceBook_Binded
} else {
ReplaceName := sqlStruck.UserName
UserName := p.Data.UserName
replaceName := sqlStruck.UserName
userName := p.Data.UserName
res.ResultCode = 0
// 修改双方的账号
ctx := context.Background()
@ -404,7 +398,7 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
tx, _ := db.SqlDb.BeginTx(ctx, txOptions)
sqlStr1 := "SELECT * FROM t_account WHERE user_name = ?"
sqlAccStruck1 := db.Db_Account{}
err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, UserName)
err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, userName)
if err2 == nil {
sqlAccStruck1.UserName = ""
_, err := db.SqlDb.Exec("update t_account set user_name = ? where auto_id = ?", sqlAccStruck1.UserName, sqlAccStruck1.AutoId)
@ -421,8 +415,8 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
}
sqlStruck.FaceBookId = req.NewFBId
sqlStruck.UserName = UserName
_, err = db.SqlDb.Exec("update t_player_baseinfo set user_name = ?, FaceBookId = ? where dwUin = ?", UserName, req.NewFBId, sqlStruck.DwUin)
sqlStruck.UserName = userName
_, err = db.SqlDb.Exec("update t_player_baseinfo set user_name = ?, FaceBookId = ? where dwUin = ?", userName, req.NewFBId, sqlStruck.DwUin)
if err != nil {
tx.Rollback()
return
@ -430,9 +424,9 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
sqlAccStruck := db.Db_Account{}
err2 = db.SqlDb.Get(&sqlAccStruck, sqlStr, ReplaceName)
err2 = db.SqlDb.Get(&sqlAccStruck, sqlStr, replaceName)
if err2 == nil {
sqlAccStruck.UserName = UserName
sqlAccStruck.UserName = userName
_, err := db.SqlDb.Exec("update t_account set user_name = ? where auto_id = ?", sqlAccStruck.UserName, sqlAccStruck.AutoId)
if err != nil {
tx.Rollback()
@ -468,16 +462,16 @@ func (p *PlayerBaseData) GetRegisterTime() int64 {
// 增加减少体力
func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod()
NewEnergy := BaseMod.Energy + cnt
if NewEnergy < 0 {
newEnergy := BaseMod.Energy + cnt
if newEnergy < 0 {
return errors.New("能量不足")
}
if cnt < 0 {
player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_ENERGY, A: []interface{}{-cnt}})
// BaseMod.FormatEnergyMul(NewEnergy)
// BaseMod.FormatEnergyMul(newEnergy)
p.p.PushClientRes(BaseMod.BackData())
}
if BaseMod.Energy >= p.GetMaxEnergy() && NewEnergy < p.GetMaxEnergy() {
if BaseMod.Energy >= p.GetMaxEnergy() && newEnergy < p.GetMaxEnergy() {
Recover := userCfg.GetRecover(int(BaseMod.Level))
player.CallEvent(time.Duration(Recover)*time.Second, func() {
player.lock.Lock()
@ -486,21 +480,21 @@ func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error {
}, "AddEnergy")
BaseMod.RecoverTime = time.Now().Unix()
}
BaseMod.Energy = NewEnergy
BaseMod.Energy = newEnergy
return nil
}
// 增加减少星星
func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod()
NewStar := BaseMod.Star + cnt
if NewStar < 0 {
newStar := BaseMod.Star + cnt
if newStar < 0 {
return errors.New("星星不足")
}
if cnt > 0 {
player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STAR, A: []interface{}{cnt}})
}
BaseMod.Star = NewStar
BaseMod.Star = newStar
player.UpdateUserInfo()
return nil
}
@ -508,11 +502,11 @@ func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
// 增加减少钻石
func (p *PlayerBaseData) AddDiamond(cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod()
NewDiamond := BaseMod.Diamond + cnt
if NewDiamond < 0 {
newDiamond := BaseMod.Diamond + cnt
if newDiamond < 0 {
return errors.New("钻石不足")
}
BaseMod.Diamond = NewDiamond
BaseMod.Diamond = newDiamond
return nil
}
@ -523,13 +517,13 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
BaseMod.PExp += pexp
upLv := 0
upExp, upPExp := userCfg.GetLevUpExp(BaseMod.Level)
Num := 0
UpLevelItem := make([]*item.Item, 0)
num := 0
upLevelItem := make([]*item.Item, 0)
for BaseMod.Exp >= upExp && BaseMod.PExp >= upPExp {
if Num > 100 {
if num > 100 {
break
}
Num++
num++
BaseMod.Level++
BaseMod.Exp -= upExp
BaseMod.PExp -= upPExp
@ -541,8 +535,8 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
player.PushClientRes(DailyTaskMod.BackData())
}
upLv = BaseMod.Level
Items := userCfg.GetLevUpReward(upLv)
UpLevelItem = item.Merge(UpLevelItem, Items)
items := userCfg.GetLevUpReward(upLv)
upLevelItem = item.Merge(upLevelItem, items)
// 棋盘背包解锁
player.PushClientRes(p.BackAsset())
ChessMod := player.PlayMod.getChessMod()
@ -577,8 +571,8 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
})
player.HandleInUserRank()
}
if len(UpLevelItem) > 0 {
err := player.HandleItem(UpLevelItem, msg.ITEM_POP_LABEL_LevUpReward.String())
if len(upLevelItem) > 0 {
err := player.HandleItem(upLevelItem, msg.ITEM_POP_LABEL_LevUpReward.String())
if err != nil {
return 0, err
}
@ -658,10 +652,10 @@ func (p *PlayerBaseData) GetLoginTime() int64 {
return int64(BaseMod.LoginTime)
}
func (p *PlayerBaseData) GetDataByUid(Uid interface{}) bool {
func (p *PlayerBaseData) GetDataByUid(uid interface{}) bool {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, Uid); err != nil {
if err := db.SqlDb.Get(&sqlStruck, sqlStr, uid); err != nil {
// log.Debug("get data failed, err:%v\n", err)
return false
}

219
src/server/game/player_chess_mod.go
View File

@ -24,26 +24,22 @@ type PlayerChessData struct {
}
func (p *PlayerChessData) LoadDataFromDB(dwUin interface{}) bool {
return true
}
func (p *PlayerChessData) Reconnect(b bool) {
}
func (p *PlayerChessData) SaveDataFromDB(Key interface{}) bool {
func (p *PlayerChessData) Reconnect(b bool) {}
func (p *PlayerChessData) SaveDataFromDB(key interface{}) bool {
return true
}
func (p *PlayerChessData) ResPlayerChessData(player *Player) {
agent := player.GetAgentByPlayer()
Msg := &p.Data
res := &p.Data
ChessMod := player.PlayMod.getChessMod()
Msg.ChessList = ChessMod.BackData().ChessList
Msg.MChessData = ChessMod.ChessMap
data, _ := proto.Marshal(Msg)
res.ChessList = ChessMod.BackData().ChessList
res.MChessData = ChessMod.ChessMap
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResPlayerChessData", data)
}
@ -57,22 +53,21 @@ func (p *PlayerChessData) ResChessColorData(player *Player) {
func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) error {
update := &msg.UpdatePlayerChessData{}
proto.Unmarshal(buf, update)
LastMap := player.PlayMod.getChessMod().ChessMap
AddChessList, AddNewEmit, err := p.HandleChess(player, update.MChessHandle)
lastMap := player.PlayMod.getChessMod().ChessMap
addChessList, addNewEmit, err := p.HandleChess(player, update.MChessHandle)
if err != nil {
res := &msg.ResUpdatePlayerChessData{
Code: msg.RES_CODE_FAIL,
Msg: err.Error(),
}
HandleStr := ""
handleStr := ""
sort.Slice(update.MChessHandle, func(i, j int) bool {
return update.MChessHandle[i].Id < update.MChessHandle[j].Id
})
for _, v := range update.MChessHandle {
HandleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
handleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
}
log.Debug("棋子操作队列错误, %v===%v===%v===%v", HandleStr, LastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
log.Debug("棋子操作队列错误, %v===%v===%v===%v", handleStr, lastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
player.SendErrClienRes(res)
return err
}
@ -85,14 +80,14 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
Code: msg.RES_CODE_FAIL,
Msg: "棋子数据不一致",
}
HandleStr := ""
handleStr := ""
sort.Slice(update.MChessHandle, func(i, j int) bool {
return update.MChessHandle[i].Id < update.MChessHandle[j].Id
})
for _, v := range update.MChessHandle {
HandleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
handleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
}
log.Debug("棋子数据不一致地图, %v===%v===%v===%v", HandleStr, LastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
log.Debug("棋子数据不一致地图, %v===%v===%v===%v", handleStr, lastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
player.SendErrClienRes(res)
player.TeLog("outsync_event", map[string]interface{}{
"outsync_event": "UpdatePlayerChessDataFunc",
@ -103,7 +98,7 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
BaseMod := player.PlayMod.getBaseMod()
OrderMod := player.PlayMod.getOrderMod()
ChessMod.ChessMap = update.MChessData
Update := OrderMod.CreateExtraOrder(AddChessList, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
Update := OrderMod.CreateExtraOrder(addChessList, addNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
if Update {
player.InitOrderItem()
player.PushClientRes(OrderMod.BackData())
@ -111,8 +106,8 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
return nil
}
func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]int32) error {
p.Data.MChessData = MChessData
func (p *PlayerChessData) UpdateChessData(player *Player, mChessData map[string]int32) error {
p.Data.MChessData = mChessData
if !p.checkChessEqual(player) {
res := &msg.ResUpdatePlayerChessData{
Code: msg.RES_CODE_FAIL,
@ -125,7 +120,7 @@ func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]
})
return fmt.Errorf("棋子数据不一致")
}
player.PlayMod.getChessMod().ChessMap = MChessData
player.PlayMod.getChessMod().ChessMap = mChessData
return nil
}
@ -134,21 +129,19 @@ func (p *PlayerChessData) checkChessEqual(player *Player) bool {
if len(p.Data.MChessData) == 0 && conf.Server.GameName == "Merge_Pet_Local" {
return true
}
ChessList := player.PlayMod.getChessMod().GetChessList()
if len(ChessList) != len(p.Data.MChessData) {
chessList := player.PlayMod.getChessMod().GetChessList()
if len(chessList) != len(p.Data.MChessData) {
return false
}
aCopy := make([]int, 0, len(ChessList))
aCopy := make([]int, 0, len(chessList))
bCopy := make([]int, 0, len(p.Data.MChessData))
for _, v := range ChessList {
for _, v := range chessList {
aCopy = append(aCopy, int(v))
}
for _, v := range p.Data.MChessData {
bCopy = append(bCopy, int(v))
}
isEqual := SlicesEqual(aCopy, bCopy)
if isEqual {
if SlicesEqual(aCopy, bCopy) {
return true
}
// 找出aCopy多的元素和少的元素
@ -199,75 +192,75 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
HandbookMod := player.PlayMod.getHandbookMod()
var addChessCostEnergy int
var buyChess int
LimitPush := false // 限时事件推送
limitPush := false // 限时事件推送
var TriggerList []*quest.Trigger
var itemList []*item.Item
var AddChessList []int
var AddNewEmit []int
EmitList := ChessMod.GetEmitList()
var addChessList []int
var addNewEmit []int
emitList := ChessMod.GetEmitList()
for _, v := range handle_list {
ChessId := int(v.ChessId)
EmitId := int(v.Emit)
chessId := int(v.ChessId)
emitId := int(v.Emit)
switch v.Type {
case msg.HANDLE_TYPE_ADD: //增加棋子
err := ChessMod.AddChess(ChessId)
err := ChessMod.AddChess(chessId)
if err != nil {
return nil, nil, err
}
Type := mergeDataCfg.GetTypeById(ChessId)
AddChessList = append(AddChessList, ChessId)
if !GoUtil.InArray(EmitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706, 0}) && Type != "Resource" { // 宝箱生成的棋子不扣体力
chessType := mergeDataCfg.GetTypeById(chessId)
addChessList = append(addChessList, chessId)
if !GoUtil.InArray(emitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706, 0}) && chessType != "Resource" { // 宝箱生成的棋子不扣体力
addChessCostEnergy++
}
b := HandbookMod.SetHandbook(ChessId) // 添加图鉴
b := HandbookMod.SetHandbook(chessId) // 添加图鉴
if b {
player.TeLog("collection_add", map[string]interface{}{
"item_id": ChessId,
"item_name": mergeDataCfg.GetNameById(ChessId),
"item_id": chessId,
"item_name": mergeDataCfg.GetNameById(chessId),
})
AddNewEmit = append(AddNewEmit, ChessId)
addNewEmit = append(addNewEmit, chessId)
}
player.PushClientRes(HandbookMod.BackData())
case msg.HANDLE_TYPE_COMPOSE: //合成棋子
NewChessId, err := ChessMod.ComposeChess(ChessId)
newChessId, err := ChessMod.ComposeChess(chessId)
if err != nil {
return nil, nil, err
}
b := HandbookMod.SetHandbook(NewChessId) // 添加图鉴
b := HandbookMod.SetHandbook(newChessId) // 添加图鉴
if b {
AddNewEmit = append(AddNewEmit, NewChessId)
addNewEmit = append(addNewEmit, newChessId)
}
AddChessList = append(AddChessList, NewChessId)
NewChessIdLv := mergeDataCfg.GetLvById(NewChessId)
TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGELVTIME, A: []interface{}{NewChessIdLv}})
addChessList = append(addChessList, newChessId)
newChessIdLv := mergeDataCfg.GetLvById(newChessId)
TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGELVTIME, A: []interface{}{newChessIdLv}})
TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGETIME})
player.PushClientRes(HandbookMod.BackData())
triggerComposeChess(player, NewChessId, player.PlayMod.getBaseMod().EnergyMul, player.PlayMod.getChessMod().GetEmitList())
triggerComposeChess(player, newChessId, player.PlayMod.getBaseMod().EnergyMul, player.PlayMod.getChessMod().GetEmitList())
// 获取活动道具
ActItem := player.GetActivityItem(GoUtil.Int32ToInt(v.ActType))
itemList = item.Merge(itemList, ActItem)
case msg.HANDLE_TYPE_BUY: //购买棋子
loseGold, err := ChessMod.BuyChess(ChessId)
loseGold, err := ChessMod.BuyChess(chessId)
if err != nil {
return nil, nil, err
}
AddChessList = append(AddChessList, ChessId)
addChessList = append(addChessList, chessId)
buyChess += loseGold
itemList = append(itemList, &item.Item{Id: item.ITEM_STAR_ID, Num: int(-loseGold)})
case msg.HANDLE_TYPE_SELL: //出售棋子
items, err := ChessMod.SellChess(ChessId)
if checkChess(ChessId, BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) { // 在订单中无法生成的棋子 出售获得原价宠物币
items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(ChessId)}}
items, err := ChessMod.SellChess(chessId)
if checkChess(chessId, BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) { // 在订单中无法生成的棋子 出售获得原价宠物币
items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(chessId)}}
}
LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
ChessType := mergeDataCfg.GetTypeById(ChessId)
if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) && ChessType == "Product" { // 限时活动 返利日
chessType := mergeDataCfg.GetTypeById(chessId)
if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) && chessType == "Product" { // 限时活动 返利日
err = LimitedTimeEventMod.SubPaybackDay()
if err == nil {
items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(ChessId)}}
items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(chessId)}}
}
LimitPush = true
limitPush = true
}
if err != nil {
return nil, nil, err
@ -277,8 +270,8 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
get_star_num = items[0].Num
}
player.TeLog("sell_item", map[string]interface{}{
"merge_item_id": ChessId,
"product_name": mergeDataCfg.GetNameById(ChessId),
"merge_item_id": chessId,
"product_name": mergeDataCfg.GetNameById(chessId),
"get_star_num": get_star_num,
})
itemList = item.Merge(itemList, items)
@ -286,34 +279,34 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
ActItem := player.GetActivityItem(GoUtil.Int32ToInt(v.ActType))
itemList = item.Merge(itemList, ActItem)
case msg.HANDLE_TYPE_REMOVE: //移除棋子
ChessMod.RemoveChess(ChessId)
ChessMod.RemoveChess(chessId)
}
}
//扣除体力
EnergyPow := BaseMod.GetEnergyMul()
ReduceEneny := 0
energyPow := BaseMod.GetEnergyMul()
reduceEneny := 0
if addChessCostEnergy > 0 {
ReduceEneny = int(math.Pow(2, float64(EnergyPow))) * addChessCostEnergy
itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: -ReduceEneny})
reduceEneny = int(math.Pow(2, float64(energyPow))) * addChessCostEnergy
itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: -reduceEneny})
}
err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandleChess.String())
if err != nil {
return nil, nil, err
}
NewEmitList := ChessMod.GetEmitList()
var EmitProductList []string
for _, v := range EmitList {
newEmitList := ChessMod.GetEmitList()
var emitProductList []string
for _, v := range emitList {
ColorList := mergeDataCfg.GetEmitProduceType(v)
EmitProductList = append(EmitProductList, ColorList...)
emitProductList = append(emitProductList, ColorList...)
}
var NewEmitProductList []string
for _, v := range NewEmitList {
var newEmitProductList []string
for _, v := range newEmitList {
ColorList := mergeDataCfg.GetEmitProduceType(v)
NewEmitProductList = append(NewEmitProductList, ColorList...)
newEmitProductList = append(newEmitProductList, ColorList...)
}
OrderMod := player.PlayMod.getOrderMod()
if !GoUtil.SlicesEqualString(EmitProductList, NewEmitProductList) {
if !GoUtil.SlicesEqualString(emitProductList, newEmitProductList) {
// 发射器系列变化，重新洗牌
OrderMod.ResetChessPool()
}
@ -321,10 +314,10 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
// 限时事件 小猫戏法
LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
LimitedTimeEventMod.AddCatTrickEnergy(ReduceEneny)
LimitPush = true
LimitedTimeEventMod.AddCatTrickEnergy(reduceEneny)
limitPush = true
}
if LimitPush {
if limitPush {
player.PushClientRes(LimitedTimeEventMod.BackData())
}
player.QuestTriggerList(TriggerList)
@ -332,80 +325,80 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
player.InitOrderItem()
player.PushClientRes(ChessMod.BackData())
player.PlayMod.save()
return AddChessList, AddNewEmit, nil
return addChessList, addNewEmit, nil
}
func (p *PlayerChessData) ClearData() bool {
return true
}
func checkChess(ChessId, EnergyMul int, Emit []int) bool {
if len(Emit) == 0 {
func checkChess(chessId, energyMul int, emit []int) bool {
if len(emit) == 0 {
return false
}
ChessIdLv := mergeDataCfg.GetLvById(ChessId)
ChessIdType := mergeDataCfg.GetTypeById(ChessId)
if ChessIdType != "Product" {
chessIdLv := mergeDataCfg.GetLvById(chessId)
chessIdType := mergeDataCfg.GetTypeById(chessId)
if chessIdType != "Product" {
return false
}
ChessIdColor := mergeDataCfg.GetColorById(ChessId)
if ChessIdColor == "Star" || ChessIdColor == "Energy" || ChessIdColor == "Diamond" {
chessIdColor := mergeDataCfg.GetColorById(chessId)
if chessIdColor == "Star" || chessIdColor == "Energy" || chessIdColor == "Diamond" {
return false
}
EmitId := 0
for _, v := range Emit {
emitId := 0
for _, v := range emit {
ProduceColor := mergeDataCfg.GetEmitProduceType(v)
if GoUtil.InStringArray(ChessIdColor, ProduceColor) {
EmitId = v
if GoUtil.InStringArray(chessIdColor, ProduceColor) {
emitId = v
break
}
}
_, Max := getChesslvRange(EmitId, EnergyMul, false)
Adjust := mergeDataCfg.GetAdjust(EmitId, ChessIdColor, EnergyMul)
return ChessIdLv > Max-Adjust
_, max := getChesslvRange(emitId, energyMul, false)
adjust := mergeDataCfg.GetAdjust(emitId, chessIdColor, energyMul)
return chessIdLv > max-adjust
}
func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) {
RandEmitLv := mergeDataCfg.GetLvById(Emit)
EmitId := mergeDataCfg.GetEmitId(Emit)
RandMaxLv := mergeDataCfg.GetMaxLvById(Emit)
RandEmitMinLv := mergeDataCfg.GetEmitMinLvById(EmitId)
Ratio := mergeDataCfg.GetEmitRatio(EmitId)
m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) / Ratio * 100)
if IsCharge {
func getChesslvRange(emit int, energyMul int, isCharge bool) (int, int) {
randEmitLv := mergeDataCfg.GetLvById(emit)
emitId := mergeDataCfg.GetEmitId(emit)
randMaxLv := mergeDataCfg.GetMaxLvById(emit)
randEmitMinLv := mergeDataCfg.GetEmitMinLvById(emitId)
ratio := mergeDataCfg.GetEmitRatio(emitId)
m := int(float64(1+randEmitLv-randEmitMinLv) / float64(1+randMaxLv-randEmitMinLv) / ratio * 100)
if isCharge {
m += 10
}
m = max(1, m)
m = min(100, m)
ChessMinLev := orderCfg.GetLvMin(EnergyMul)
ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
ChessMinLev := orderCfg.GetLvMin(energyMul)
ChessMaxLev := orderCfg.GetLvMax(energyMul, m)
return ChessMinLev, ChessMaxLev
}
func triggerComposeChess(player *Player, ChessId, EnergyMul int, Emit []int) {
func triggerComposeChess(player *Player, chessId, energyMul int, emit []int) {
OrderMod := player.PlayMod.getOrderMod()
if OrderMod.Step < 12 {
return
}
if !checkChess(ChessId, EnergyMul, Emit) {
if !checkChess(chessId, energyMul, emit) {
return
}
ChessMod := player.PlayMod.getChessMod()
ChessList := ChessMod.GetUnlockChessList()
ChessNum := 0
chessNum := 0
for _, v := range ChessList {
if v == ChessId {
ChessNum++
if v == chessId {
chessNum++
}
}
OrderNum := 0
orderNum := 0
for _, v := range OrderMod.GetOrderList() {
if v.Type == order.Clean_Order_type && v.MergeId[0] == ChessId {
OrderNum++
if v.Type == order.Clean_Order_type && v.MergeId[0] == chessId {
orderNum++
}
}
if OrderNum >= ChessNum {
if orderNum >= chessNum {
return
}
OrderMod.CreateCleanOrder2([]int{ChessId})
OrderMod.CreateCleanOrder2([]int{chessId})
player.PushClientRes(OrderMod.BackData())
}

44
src/server/game/player_data.go
View File

@ -7,7 +7,6 @@ import (
"errors"
"math"
"server/conf"
activityCfg "server/conf/activity"
cardCfg "server/conf/card"
chargeCfg "server/conf/charge"
fur_cfg "server/conf/fur"
@ -70,6 +69,7 @@ type Player struct {
stopOnce sync.Once
msgChanOnce sync.Once
func_time int
config_list map[string]interface{}
}
type PlayerBackUp struct {
@ -82,6 +82,22 @@ type PlayerMsg struct {
B []byte
}
var playerDataPool = sync.Pool{
New: func() interface{} {
return &PlayerBackUp{}
},
}
func (pd *PlayerBackUp) Reset() {
pd.Data = msg.ResPlayerBaseInfo{}
pd.PlayMod = nil
}
func (pd *PlayerBackUp) Reclaim() {
pd.Reset()
playerDataPool.Put(pd)
}
func (p *Player) Stop() {
p.wg.Wait()
p.signalDispatcherStop()
@ -201,10 +217,10 @@ func (p *Player) ProcessTrigger() {
// 接口请求之前备份数据
func (p *Player) BackUp() *PlayerBackUp {
BackUp := PlayerBackUp{}
p.PlayMod.BackUp(&BackUp)
BackUp := playerDataPool.Get().(*PlayerBackUp)
p.PlayMod.BackUp(BackUp)
BackUp.Data = p.GetPlayerBaseMod().BackUp()
return &BackUp
return BackUp
}
// 接口发生错误时 还原数据
@ -1209,9 +1225,8 @@ func (p *Player) TeLog(Type string, Param map[string]interface{}) {
// 初始化活动
func (p *Player) InitActivity() {
p.activity = make(map[int]*ActivityInfo)
ActivityList := activityCfg.GetActivityList()
ActivityList := G_GameLogicPtr.ActivityMgr.GetActivityList()
Level := p.GetPlayerBaseMod().GetLevel()
ActivityMod := p.PlayMod.getActivityMod()
now := GoUtil.Now()
var startduration int64
var minduration int64
@ -1220,24 +1235,21 @@ func (p *Player) InitActivity() {
if v.Level > Level {
continue
}
Status := ActivityMod.GetActivityStatus(v)
if Status == 0 {
continue
}
startduration = v.StartTime - now
endduration = v.EndTime - now + 1
Status := 1
startduration = v.Startime - now
endduration = v.Endtime - now + 1
if startduration > 0 && (minduration == 0 || minduration > startduration) {
minduration = startduration
}
if endduration > 0 && (minduration == 0 || minduration > endduration) {
minduration = endduration
}
if v.StartTime > now || v.EndTime < now {
if v.Startime > now || v.Endtime < now {
continue
}
p.activity[v.Id] = &ActivityInfo{
StartT: v.StartTime,
EndT: v.EndTime,
StartT: v.Startime,
EndT: v.Endtime,
Id: v.Id,
Type: v.Type,
Status: Status,
@ -1247,7 +1259,7 @@ func (p *Player) InitActivity() {
if minduration > 0 {
p.CallEvent(time.Duration(minduration)*time.Second, p.TickActivity, "init_activity")
}
ActivityMod = p.PlayMod.getActivityMod()
ActivityMod := p.PlayMod.getActivityMod()
if ActivityMod.AddEnd > now && !ActivityMod.AddReward {
p.CallEvent(time.Duration(ActivityMod.AddEnd-now)*time.Second, p.TickActivityAddGift, "init_activity_add_gift")
}

1176
src/server/game/register_network_func.go
View File

File diff suppressed because it is too large Load Diff

12
src/server/game/req_func_friend.go
View File

@ -452,9 +452,9 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
From: int(player.M_DwUin),
To: int(ReplyInfo.Uid),
Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
Extra: CatnipMsg{
ActivityId: ActivityId,
GameId: int(GameId),
Extra: map[string]interface{}{
"ActivityId": ActivityId,
"GameId": int(GameId),
},
SendT: now,
End: now + sevendays,
@ -465,9 +465,9 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
From: int(player.M_DwUin),
To: int(v),
Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
Extra: CatnipMsg{
ActivityId: ActivityId,
GameId: int(GameId),
Extra: map[string]interface{}{
"ActivityId": ActivityId,
"GameId": int(GameId),
},
SendT: now,
End: now + sevendays,

9
src/server/game/unit_test.go
View File

@ -183,15 +183,6 @@ func UnitLimitProgress(p *Player) error {
return nil
}
func UnitLimitedTimeEvent(p *Player) error {
LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
ChessMod := p.PlayMod.getChessMod()
mergeList := []int{246, 15}
AddItem := LimitedTimeEventMod.GetChestReward(mergeList, ChessMod.GetStarEmitList())
fmt.Print(AddItem)
return nil
}
func UnitCard(p *Player) error {
CardMod := p.PlayMod.getCardMod()
for i := 0; i < 10000; i++ {

5
src/server/main.go
View File

@ -6,6 +6,7 @@ import (
_ "net/http/pprof"
"runtime"
"runtime/debug"
"server/MergeConst"
"server/conf"
"server/game"
"server/gate"
@ -27,8 +28,8 @@ func main() {
lconf.CenterAddr = conf.Server.CenterAddr
lconf.PendingWriteNum = conf.PendingWriteNum
// 当内存>256M时开始GC
debug.SetGCPercent(200)
debug.SetMemoryLimit(1024 << 20)
debug.SetGCPercent(MergeConst.Go_gc_percent)
debug.SetMemoryLimit(MergeConst.Go_gc_memory_limit)
// 启动 pprof（仅绑定本地）
go func() {
// 如果需要绑定所有接口改为 ":6060"

6
src/server/pkg/github.com/name5566/leaf/leaf.go
View File

@ -3,6 +3,8 @@ package leaf
import (
"os"
"os/signal"
"server/MergeConst"
"server/backend"
mergeCluster "server/cluster"
sconf "server/conf"
"server/game"
@ -30,9 +32,9 @@ func Run(mods ...module.Module) {
panic(err)
}
}
log.Release("服务器版本: %s", "1.0.02")
log.Release("服务器版本: %s", MergeConst.Go_game_version)
log.Release("%s 启动, 节点类型: %s, 区服id: %d", sconf.Server.GameName, sconf.Server.ServerType, sconf.Server.ServerID)
go backend.Start()
// module
for i := 0; i < len(mods); i++ {
module.Register(mods[i])

22
src/server/sql/Merge_Pet.sql
View File

@ -141,11 +141,29 @@ CREATE TABLE IF NOT EXISTS `system_mail_info` (
) ENGINE = InnoDB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4 COMMENT = '系统邮件';
/*==============================================================*/
/* Table: t_player_data 系统模块表 */
/* Table: t_server_mod 系统模块表 */
/*==============================================================*/
CREATE TABLE IF NOT EXISTS t_server_mod (
`id` int NOT NULL AUTO_INCREMENT primary key,
`key` varchar(128) DEFAULT '' COMMENT '模块key',
`mData` mediumblob DEFAULT NULL COMMENT '数据',
`updateTime` int unsigned NOT NULL DEFAULT '0' COMMENT '更新时间'
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE utf8mb4_general_ci COMMENT = '系统模块表';
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE utf8mb4_general_ci COMMENT = '系统模块表';
/*==============================================================*/
/* Table: t_activity_mod 系统活动表 */
/*==============================================================*/
CREATE TABLE IF NOT EXISTS t_activity_mod (
`id` int NOT NULL AUTO_INCREMENT primary key,
`type` int DEFAULT 0 COMMENT '活动类型',
`title` varchar(128) DEFAULT '' COMMENT '活动标题',
`mail_title` varchar(128) DEFAULT '' COMMENT '活动邮件标题',
`mail_content` varchar(2048) DEFAULT '' COMMENT '活动邮件内容',
`start_time` int unsigned NOT NULL DEFAULT '0' COMMENT '活动开始时间',
`end_time` int unsigned NOT NULL DEFAULT '0' COMMENT '活动结束时间',
`level_limit` int unsigned NOT NULL DEFAULT '0' COMMENT '等级限制',
`cfg` TEXT COMMENT '活动配置',
`cfg_buf` BLOB COMMENT '活动配置buf',
`extra` TEXT COMMENT '活动额外数据',
`updateTime` int unsigned NOT NULL DEFAULT '0' COMMENT '更新时间'
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE utf8mb4_general_ci COMMENT = '系统活动表';

8
src/server/test/chess_test.go
View File

@ -21,3 +21,11 @@ func TestGetStarEmitList(t *testing.T) {
p1.InitOrderItem()
fmt.Printf("%v\n", EM)
}
func TestTakeChessOutBagToHonor(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
ChessMod := p1.GetChessMod()
ChessMod.TakeChessOutBagToHonor(3)
fmt.Printf("%v\n", ChessMod.Honor)
}

1
src/server/test/conf/server.json
View File

@ -3,6 +3,7 @@
"LogLevel": "debug",
"LogPath": "./log",
"TCPAddr": ":3601",
"RPCAddr": ":50051",
"WSAddr": ":3566",
"MySqlAddr": "127.0.0.1",
"MySqlPort": "3306",

9
src/server/test/friend_test.go
View File

@ -2,7 +2,9 @@ package test
import (
"fmt"
friendTreasureCfg "server/conf/friend_treasure"
"server/game"
GoUtil "server/game_util"
"server/msg"
"testing"
@ -54,3 +56,10 @@ func TestFriendBackData(t *testing.T) {
p1.FriendLogBackData()
p1.FriendCardBackData()
}
func TestFriendTreasureInit(t *testing.T) {
probMap := friendTreasureCfg.GetChestProb()
prob := GoUtil.RandMap(probMap)
items := friendTreasureCfg.GetChestItems(prob)
fmt.Printf("Prob: %v, Items: %v\n", prob, items)
}

27
src/server/test/limit_test.go
View File

@ -2,21 +2,13 @@ package test
import (
"fmt"
limitedTimeEventCfg "server/conf/limited_time_event"
"server/game"
"server/game/mod/item"
limitedTimeEvent "server/game/mod/limited_time_event"
"testing"
)
func TestMetroRain(t *testing.T) {
// 3625212
p := new(game.Player)
p.InitPlayer("3625212")
ChessMod := p.GetChessMod()
LimitEventMod := p.GetLimitEventMod()
rewards := LimitEventMod.GetMeteorReward([]int{1, 22, 3}, ChessMod.GetStarEmitList())
t.Logf("rewards: %v", rewards)
}
func TestFast(t *testing.T) {
p := new(game.Player)
p.InitPlayer("3625212")
@ -54,3 +46,18 @@ func TestProgressReward(t *testing.T) {
fmt.Printf("Current progress reward list: %v\n", res)
}
}
func TestCatTrick(t *testing.T) {
p := new(game.Player)
p.InitPlayer("3625212")
items := []*item.Item{
{Id: 101191, Num: 1},
}
err := p.HandleItem(items, "")
if err != nil {
t.Fatal(err)
}
energy := limitedTimeEventCfg.GetCatTrickEnergy()
diamond := limitedTimeEventCfg.GetCatTrickDiamond()
t.Log(energy, diamond)
}

56
src/server/test/order_test.go
View File

@ -32,15 +32,6 @@ func TestOrderFinish(t *testing.T) {
}
}
func TestChestRain(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
ChessMod := p1.GetChessMod()
LimitEventMod := p1.GetLimitEventMod()
f := LimitEventMod.GetMeteorReward([]int{226}, ChessMod.GetStarEmitList())
fmt.Printf("chest rain reward:%v", f)
}
func TestInitOrderItem(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
@ -66,3 +57,50 @@ func TestHighOrder(t *testing.T) {
p1.InitOrderItem()
fmt.Printf("order item:%v", OrderMod.OrderList[1].Items)
}
func TestAddPetOrder(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
ChessMod := p1.GetChessMod()
emitList := ChessMod.GetOrderPartEmit()
fmt.Printf("emit list:%v", emitList)
}
func TestAddNormalOrder(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
p1.CreateNormalOrder()
}
func TestAddPartOrder(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
OrderMod := p1.GetOrderMod()
BaseMod := p1.GetBaseMod()
ChessMod := p1.GetChessMod()
for i := 0; i < 10; i++ {
OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderPartEmit(), BaseMod.GetEnergyMul(), order.Part_type)
}
}
func TestCreatePetOrder(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
OrderMod := p1.GetOrderMod()
BaseMod := p1.GetBaseMod()
ChessMod := p1.GetChessMod()
for i := 0; i < 10; i++ {
OrderMod.CreatePetOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Pet_type)
}
}
func TestCreateSuperOrder(t *testing.T) {
p1 := new(game.Player)
p1.InitPlayer("3625212")
OrderMod := p1.GetOrderMod()
BaseMod := p1.GetBaseMod()
ChessMod := p1.GetChessMod()
for i := 0; i < 10; i++ {
OrderMod.CreateSuperOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul())
}
}