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 package backend
func Start() { import (
// addr := net.JoinHostPort("localhost", "9090") "context"
// handler := NewGameServiceHandler() "net"
"server/conf"
"server/game"
"server/msg"
"server/pkg/github.com/name5566/leaf/log"
// //创建处理器 "google.golang.org/grpc"
// processor := backend.NewGameAdminServiceProcessor(handler) )
// transportFactory := thrift.NewTBufferedTransportFactory(8192) type backendServer struct {
// protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{}) msg.UnimplementedBackendServer
}
// tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
// if err != nil { func (s *backendServer) ReloadActivity(ctx context.Context, req *msg.ReqActivityCfgReload) (*msg.ResActivityCfgReload, error) {
// fmt.Printf("Failed to resolve address %s: %v\n", addr, err) log.Debug("Received ReloadActivity request: %v", req)
// return game.AcitivityCfgReload()
// } return nil, nil
// serverTransport := thrift.NewTServerSocketFromAddrTimeout(tcpAddr, 0) }
// server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
// fmt.Printf("Starting the server on %s...\n", addr) func (s *backendServer) OrderShipping(ctx context.Context, req *msg.ReqOrderShipping) (*msg.ResOrderShipping, error) {
// if err := server.Serve(); err != nil { log.Debug("Received OrderShipping request: %v", req)
// fmt.Printf("Error starting the server: %v\n", err) 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 package activityCfg
import ( import (
languageCfg "server/conf/language"
"server/game/mod/item" "server/game/mod/item"
GoUtil "server/game_util" GoUtil "server/game_util"
"server/gamedata" "server/gamedata"
"server/msg"
"server/pkg/github.com/name5566/leaf/log" "server/pkg/github.com/name5566/leaf/log"
"strconv" "strconv"
) )
@ -136,16 +134,6 @@ func GetActivityRewardItems(ActId int) []*item.Item {
return nil 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) { func GetActivityRecycleMail(ActId int) (string, string, string) {
data, err := gamedata.GetDataByIntKey(CFG_ACTIVITY, ActId) data, err := gamedata.GetDataByIntKey(CFG_ACTIVITY, ActId)
if err != nil { if err != nil {

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

@ -14,6 +14,7 @@ var Server struct {
LogLevel string LogLevel string
LogPath string LogPath string
WSAddr string WSAddr string
RPCAddr string
CertFile string CertFile string
KeyFile string KeyFile string
TCPAddr 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_BONUS = "LimitedTimeEventBonus"
CFG_LIMITED_TIME_EVENT_MONEY = "LimitedTimeEventMoney" CFG_LIMITED_TIME_EVENT_MONEY = "LimitedTimeEventMoney"
CFG_LIMITED_TIME_EVENT_LUCKY = "LimitedTimeEventLucky" CFG_LIMITED_TIME_EVENT_LUCKY = "LimitedTimeEventLucky"
CFG_LIMITED_TIME_EVENT_CAT_TRICK = "LimitedTimeEventCatTrick"
CFG_LIMTTED_TIME_EVENT_DECORATE_OFF = "LimitedTimeEventDecorateOff" 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_CHEST_JACKPOT)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_MONEY) gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_MONEY)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_LUCKY) gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_LUCKY)
gamedata.InitCfg(CFG_LIMITED_TIME_EVENT_CAT_TRICK)
gamedata.InitCfg(CFG_LIMTTED_TIME_EVENT_DECORATE_OFF) gamedata.InitCfg(CFG_LIMTTED_TIME_EVENT_DECORATE_OFF)
} }
@ -421,28 +419,22 @@ func GetLuckyCatMaxEarning(Remain int) int {
return 0 return 0
} }
func GetCatTrickType(Duartion int) int { func GetCatTrickEnergy() int {
data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_CAT_TRICK) data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "CatTrick_ConsumeEnergy")
if err != nil { if err != nil {
log.Debug("GetCatTrickType err:%v, Duartion=%d", err, Duartion) log.Debug("GetCatTrickEnergy err:%v", err)
return 1 return 0
} }
for k, v := range data { return gamedata.GetIntValue(data, "Value")
D := gamedata.GetIntValue(v, "Duration")
if Duartion == D {
return GoUtil.Int(k)
}
}
return gamedata.GetIntValue(data, "Type")
} }
func GetCatTrickDiamond(Type int) (int, int) { func GetCatTrickDiamond() int {
data, err := gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_CAT_TRICK, Type) data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "CatTrick_RewardDiamond")
if err != nil { if err != nil {
log.Debug("GetCatTrickDiamond err:%v, Type=%d", err, Type) log.Debug("GetCatTrickDiamond err:%v", err)
return 0, 0 return 0
} }
return gamedata.GetIntValue(data, "Diamond"), gamedata.GetIntValue(data, "Energy") return gamedata.GetIntValue(data, "Value")
} }
func GetDecorateOffDiscount(AreaId, StepId int) int { func GetDecorateOffDiscount(AreaId, StepId int) int {

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

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

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

@ -413,6 +413,12 @@ func GetServerMailData(data *[]*SqlServerMailStruct) error {
return err 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 { 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 (?,?,?,?,?,?,?,?,?)" sql := "insert into t_player_charge (`Uid`,`OrderId`, `ProductId`, `Price`,`Currency`, `CreateTime`, `PayPlatform`, `PayChannel`, `PayChannelExtra`) Values (?,?,?,?,?,?,?,?,?)"
Now := GoUtil.Now() Now := GoUtil.Now()

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

@ -497,6 +497,19 @@ type SqlServerMailStruct struct {
CreateTime int64 `db:"create_time"` 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 { type SqlChargeOrderStruct struct {
Id int `db:"id"` Id int `db:"id"`
Uid int `db:"Uid"` Uid int `db:"Uid"`

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

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

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

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

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

@ -1,12 +1,19 @@
package game package game
import ( import (
"fmt"
"server/db"
"server/game/mod/msg" "server/game/mod/msg"
Msg "server/game/mod/msg"
protoMsg "server/msg"
"server/pkg/github.com/name5566/leaf/log"
"sync" "sync"
"google.golang.org/protobuf/proto"
) )
type ActivityMgr struct { type ActivityMgr struct {
*ServerMod data *ActivityData
} }
type ActivityData struct { type ActivityData struct {
@ -17,29 +24,32 @@ type ActivityData struct {
type ActivityCfg struct { type ActivityCfg struct {
Id int Id int
Type int Type int
Strartime int64 Startime int64
Endtime int64 Endtime int64
Level int Level int
Title string Title string
MailTitle string MailTitle string
MailContent string MailContent string
RewardItem map[string]interface{} cfg interface{}
Extra map[string]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 () const ()
func (r *ActivityMgr) Init() { func (r *ActivityMgr) Init() {
r.key = RANK_MGR_KEY
r.data = &ActivityData{ r.data = &ActivityData{
List: make(map[int]*ActivityCfg, 0), List: make(map[int]*ActivityCfg, 0),
} }
// 注册处理函数 r.Reload()
r.init()
} }
func (r *ActivityMgr) getData() *ActivityData { 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 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 := r.getData()
data.mu.Lock() data.mu.Lock()
@ -58,3 +80,57 @@ func (r ActivityMgr) GetActivityCfg(Id int) ActivityCfg {
} }
return *cfg 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, "ReqAdminShipping": ReqAdminShipping,
} }
func AdminProcess(Func string, args []interface{}) { func AdminProcess(funcName string, args []interface{}) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
log.Error("uid : %d, func : %s, fatal : %s", 0, Func, r) log.Error("uid : %d, func : %s, fatal : %s", 0, funcName, r)
//GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", 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) err := f(args)
if err != nil { if err != nil {
log.Debug("AdminProcess error: %v", err) log.Debug("AdminProcess error: %v", err)
@ -123,27 +123,27 @@ func ReqAdminShipping(args []interface{}) error {
proto.Unmarshal(buf, req) proto.Unmarshal(buf, req)
res := make(map[string]interface{}) res := make(map[string]interface{})
res["Code"] = 0 res["Code"] = 0
OrderInfo, err := db.GetPlayerChargeData(req.OrderSn) orderInfo, err := db.GetPlayerChargeData(req.OrderSn)
if err != nil { if err != nil {
res["Code"] = 1 res["Code"] = 1
res["Msg"] = "order not found" res["Msg"] = "order not found"
AdminPlayerBack(a, res) AdminPlayerBack(a, res)
} }
if OrderInfo.PayStatus == MergeConst.ORDER_STATUS_SHIP { if orderInfo.PayStatus == MergeConst.ORDER_STATUS_SHIP {
res["Msg"] = "order already shipped" res["Msg"] = "order already shipped"
AdminPlayerBack(a, res) AdminPlayerBack(a, res)
} }
Player := G_GameLogicPtr.GetPlayer(int64(OrderInfo.Uid)) player := G_GameLogicPtr.GetPlayer(int64(orderInfo.Uid))
if Player != nil { if player != nil {
go Player.TriggerShippingOrderOrigin(&msg.ReqShippingOrder{ go player.TriggerShippingOrderOrigin(&msg.ReqShippingOrder{
OrderSn: req.OrderSn, OrderSn: req.OrderSn,
}) })
res["Msg"] = "player online,triggered sync" res["Msg"] = "player online,triggered sync"
AdminPlayerBack(a, res) AdminPlayerBack(a, res)
} else { } else {
OrderInfo.PayStatus = MergeConst.ORDER_STATUS_PAY orderInfo.PayStatus = MergeConst.ORDER_STATUS_PAY
OrderInfo.PayChannelOrderId = req.ChannelOrderSn orderInfo.PayChannelOrderId = req.ChannelOrderSn
db.UpdatePlayerChargeData(OrderInfo) db.UpdatePlayerChargeData(orderInfo)
} }
return nil return nil
} }
@ -230,10 +230,10 @@ func AdminPlayerInfo(args []interface{}) error {
} }
func AdminPlayerBack(a gate.Agent, res map[string]interface{}) { func AdminPlayerBack(a gate.Agent, res map[string]interface{}) {
JsonBuff, _ := json.Marshal(res) jsonBuff, _ := json.Marshal(res)
response := &msg.AdminRes{} response := &msg.AdminRes{}
response.Func = "admin" response.Func = "admin"
response.Info = string(JsonBuff) response.Info = string(jsonBuff)
a.WriteMsg(response) a.WriteMsg(response)
} }
@ -322,3 +322,29 @@ func ReqAdminBan(args []interface{}) error {
AdminPlayerBack(a, res) AdminPlayerBack(a, res)
return nil 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() c.init()
Now := GoUtil.Now() now := GoUtil.Now()
ZeroTime := GoUtil.ZeroTimestamp() zeroTime := GoUtil.ZeroTimestamp()
if c.getData().ZeroTime != ZeroTime { if c.getData().ZeroTime != zeroTime {
c.ZeroUpdate() c.ZeroUpdate()
} }
Remain := Now - ZeroTime remain := now - zeroTime
Remain1 := 1800 - Remain%1800 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) c.group(false)
}) })
@ -205,10 +205,10 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.Lock() ChampshipData.mu.Lock()
defer ChampshipData.mu.Unlock() defer ChampshipData.mu.Unlock()
Now := GoUtil.Now() now := GoUtil.Now()
uids := make(map[int]struct{}) uids := make(map[int]struct{})
for k, v := range ChampshipData.Rank { for k, v := range ChampshipData.Rank {
Notify := make(map[int]int) notify := make(map[int]int)
for e, r := range v { for e, r := range v {
if r.Type == RANK_PLAYER_ROBOT { if r.Type == RANK_PLAYER_ROBOT {
AddScore := 0.0 AddScore := 0.0
@ -217,17 +217,17 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
continue continue
} }
if Robot.Type == 2 && Robot.Time+60 < Now { if Robot.Type == 2 && Robot.Time+60 < now {
AddScore = Robot.PerScore 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 AddScore = Robot.PerScore
Robot.Time = Now Robot.Time = now
} }
r.Score += AddScore r.Score += AddScore
} else { } else {
Notify[r.Uid] = e notify[r.Uid] = e
} }
} }
sort.Slice(v, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序 sort.Slice(v, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
@ -242,14 +242,13 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
if r.Type == RANK_PLAYER_ROBOT { if r.Type == RANK_PLAYER_ROBOT {
continue continue
} }
if Notify[r.Uid] != e { if notify[r.Uid] != e {
c.SetRankCache(r.Uid) c.SetRankCache(r.Uid)
uids[r.Uid] = struct{}{} uids[r.Uid] = struct{}{}
} }
} }
ChampshipData.Rank[k] = v ChampshipData.Rank[k] = v
} }
now := GoUtil.Now()
// 在锁外通知玩家，避免在持锁时启动 goroutine 访问可能被并发修改的数据 // 在锁外通知玩家，避免在持锁时启动 goroutine 访问可能被并发修改的数据
for uid := range uids { for uid := range uids {
go NotifyPlayer(uid, &msg.Msg{ go NotifyPlayer(uid, &msg.Msg{
@ -264,180 +263,180 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
return nil, nil return nil, nil
} }
func (c *ChampshipMgr) GetPreRankMsg(Uid int) *proto.ResChampshipPreRank { func (c *ChampshipMgr) GetPreRankMsg(uid int) *proto.ResChampshipPreRank {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.RLock() ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock() defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.PreGroupInfo[Uid] groupId := ChampshipData.PreGroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return &proto.ResChampshipPreRank{} return &proto.ResChampshipPreRank{}
} }
RankList, ok := ChampshipData.PreRank[GroupId] RankList, ok := ChampshipData.PreRank[groupId]
if !ok { if !ok {
return &proto.ResChampshipPreRank{} return &proto.ResChampshipPreRank{}
} }
MyRank := 0 myRank := 0
MyScore := 0.0 myScore := 0.0
RL := make(map[int32]*proto.ResPlayerRank, 0) RL := make(map[int32]*proto.ResPlayerRank, 0)
for k, v := range RankList { for k, v := range RankList {
if v.Uid == Uid { if v.Uid == uid {
MyRank = k + 1 myRank = k + 1
MyScore = v.Score myScore = v.Score
} }
if v.Type == RANK_PLAYER_ROBOT { if v.Type == RANK_PLAYER_ROBOT {
Robot := ChampshipData.PreRobot[v.Uid] robot := ChampshipData.PreRobot[v.Uid]
if Robot == nil { if robot == nil {
continue continue
} }
last := &proto.ActLog{} last := &proto.ActLog{}
if Robot.ActLog != nil { if robot.ActLog != nil {
last = &proto.ActLog{ last = &proto.ActLog{
Type: int32(Robot.ActLog.Type), Type: int32(robot.ActLog.Type),
Time: Robot.ActLog.Time, Time: robot.ActLog.Time,
Param: Robot.ActLog.Param, Param: robot.ActLog.Param,
} }
} }
RL[int32(k+1)] = &proto.ResPlayerRank{ RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid), Uid: int64(v.Uid),
Score: float32(v.Score), Score: float32(v.Score),
Name: Robot.Name, Name: robot.Name,
Avatar: int32(Robot.Avatar), Avatar: int32(robot.Avatar),
Face: int32(Robot.Face), Face: int32(robot.Face),
Level: int32(Robot.Level), Level: int32(robot.Level),
Type: int32(v.Type), Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(Robot.Playroom), PlayroomSet: GoUtil.MapIntToInt32(robot.Playroom),
DressSet: GoUtil.MapIntToInt32(Robot.DressSet), DressSet: GoUtil.MapIntToInt32(robot.DressSet),
FurSet: int32(Robot.FurSet), FurSet: int32(robot.FurSet),
PetName: Robot.PetName, PetName: robot.PetName,
Last: last, Last: last,
} }
} else { } else {
SimplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid) simplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if SimplePlayer == nil { if simplePlayer == nil {
continue continue
} }
last := &proto.ActLog{} last := &proto.ActLog{}
if SimplePlayer.ActLog != nil { if simplePlayer.ActLog != nil {
last = &proto.ActLog{ last = &proto.ActLog{
Type: int32(SimplePlayer.ActLog.Type), Type: int32(simplePlayer.ActLog.Type),
Time: SimplePlayer.ActLog.Time, Time: simplePlayer.ActLog.Time,
Param: SimplePlayer.ActLog.Param, Param: simplePlayer.ActLog.Param,
} }
} }
RL[int32(k+1)] = &proto.ResPlayerRank{ RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid), Uid: int64(v.Uid),
Score: float32(v.Score), Score: float32(v.Score),
Name: SimplePlayer.Name, Name: simplePlayer.Name,
Avatar: int32(SimplePlayer.Avatar), Avatar: int32(simplePlayer.Avatar),
Face: int32(SimplePlayer.Face), Face: int32(simplePlayer.Face),
Level: int32(SimplePlayer.Level), Level: int32(simplePlayer.Level),
Type: int32(v.Type), Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(SimplePlayer.Playroom), PlayroomSet: GoUtil.MapIntToInt32(simplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(SimplePlayer.DressSet), DressSet: GoUtil.MapIntToInt32(simplePlayer.DressSet),
FurSet: int32(SimplePlayer.PetFur), FurSet: int32(simplePlayer.PetFur),
PetName: SimplePlayer.PetName, PetName: simplePlayer.PetName,
Last: last, Last: last,
} }
} }
} }
return &proto.ResChampshipPreRank{ return &proto.ResChampshipPreRank{
MyRank: int32(MyRank), MyRank: int32(myRank),
MyScore: float32(MyScore), MyScore: float32(myScore),
RankList: RL, RankList: RL,
} }
} }
// TODO 待优化 // TODO 待优化
func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank { func (c *ChampshipMgr) GetRankMsg(uid int) *proto.ResChampshipRank {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.RLock() ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock() defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.GroupInfo[Uid] groupId := ChampshipData.GroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return &proto.ResChampshipRank{} return &proto.ResChampshipRank{}
} }
RankList, ok := ChampshipData.Rank[GroupId] rankList, ok := ChampshipData.Rank[groupId]
if !ok { if !ok {
return &proto.ResChampshipRank{} return &proto.ResChampshipRank{}
} }
MyRank := 0 myRank := 0
MyScore := 0.0 myScore := 0.0
RL := make(map[int32]*proto.ResPlayerRank, 0) RL := make(map[int32]*proto.ResPlayerRank, 0)
for k, v := range RankList { for k, v := range rankList {
if v.Uid == Uid { if v.Uid == uid {
MyRank = k + 1 myRank = k + 1
MyScore = v.Score myScore = v.Score
} }
if v.Type == RANK_PLAYER_ROBOT { if v.Type == RANK_PLAYER_ROBOT {
Robot := ChampshipData.Robot[v.Uid] robot := ChampshipData.Robot[v.Uid]
if Robot == nil { if robot == nil {
continue continue
} }
last := &proto.ActLog{} last := &proto.ActLog{}
if Robot.ActLog != nil { if robot.ActLog != nil {
last = &proto.ActLog{ last = &proto.ActLog{
Type: int32(Robot.ActLog.Type), Type: int32(robot.ActLog.Type),
Time: Robot.ActLog.Time, Time: robot.ActLog.Time,
Param: Robot.ActLog.Param, Param: robot.ActLog.Param,
} }
} }
RL[int32(k+1)] = &proto.ResPlayerRank{ RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid), Uid: int64(v.Uid),
Score: float32(v.Score), Score: float32(v.Score),
Name: Robot.Name, Name: robot.Name,
Avatar: int32(Robot.Avatar), Avatar: int32(robot.Avatar),
Face: int32(Robot.Face), Face: int32(robot.Face),
Level: int32(Robot.Level), Level: int32(robot.Level),
Type: int32(v.Type), Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(Robot.Playroom), PlayroomSet: GoUtil.MapIntToInt32(robot.Playroom),
DressSet: GoUtil.MapIntToInt32(Robot.DressSet), DressSet: GoUtil.MapIntToInt32(robot.DressSet),
FurSet: int32(Robot.FurSet), FurSet: int32(robot.FurSet),
PetName: Robot.PetName, PetName: robot.PetName,
Last: last, Last: last,
} }
} else { } else {
SimplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid) simplePlayer := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
if SimplePlayer == nil { if simplePlayer == nil {
continue continue
} }
last := &proto.ActLog{} last := &proto.ActLog{}
if SimplePlayer.ActLog != nil { if simplePlayer.ActLog != nil {
last = &proto.ActLog{ last = &proto.ActLog{
Type: int32(SimplePlayer.ActLog.Type), Type: int32(simplePlayer.ActLog.Type),
Time: SimplePlayer.ActLog.Time, Time: simplePlayer.ActLog.Time,
Param: SimplePlayer.ActLog.Param, Param: simplePlayer.ActLog.Param,
} }
} }
RL[int32(k+1)] = &proto.ResPlayerRank{ RL[int32(k+1)] = &proto.ResPlayerRank{
Uid: int64(v.Uid), Uid: int64(v.Uid),
Score: float32(v.Score), Score: float32(v.Score),
Name: SimplePlayer.Name, Name: simplePlayer.Name,
Avatar: int32(SimplePlayer.Avatar), Avatar: int32(simplePlayer.Avatar),
Face: int32(SimplePlayer.Face), Face: int32(simplePlayer.Face),
Level: int32(SimplePlayer.Level), Level: int32(simplePlayer.Level),
Type: int32(v.Type), Type: int32(v.Type),
PlayroomSet: GoUtil.MapIntToInt32(SimplePlayer.Playroom), PlayroomSet: GoUtil.MapIntToInt32(simplePlayer.Playroom),
DressSet: GoUtil.MapIntToInt32(SimplePlayer.DressSet), DressSet: GoUtil.MapIntToInt32(simplePlayer.DressSet),
FurSet: int32(SimplePlayer.PetFur), FurSet: int32(simplePlayer.PetFur),
PetName: SimplePlayer.PetName, PetName: simplePlayer.PetName,
Last: last, Last: last,
} }
} }
} }
return &proto.ResChampshipRank{ return &proto.ResChampshipRank{
MyRank: int32(MyRank), MyRank: int32(myRank),
MyScore: float32(MyScore), MyScore: float32(myScore),
RankList: RL, RankList: RL,
} }
} }
// 分组 // 分组
func (c *ChampshipMgr) group(iszero bool) (interface{}, error) { func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
Now := GoUtil.Now() now := GoUtil.Now()
Zero := GoUtil.ZeroTimestamp() zero := GoUtil.ZeroTimestamp()
if Now-Zero < 1800 && !iszero { // 0点30分钟内不分组 if now-zero < 1800 && !iszero { // 0点30分钟内不分组
return nil, nil return nil, nil
} }
c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() { // 30分钟后重新分组 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] g[i] = g[i][:len(g[i])-remainder]
} }
ChampshipData.AutoId++ ChampshipData.AutoId++
StartId := ChampshipData.AutoId startId := ChampshipData.AutoId
for j := 0; j < len(g[i]); j++ { for j := 0; j < len(g[i]); j++ {
if len(ChampshipData.Rank[ChampshipData.AutoId]) >= 10 { if len(ChampshipData.Rank[ChampshipData.AutoId]) >= 10 {
log.Error("championship error: more than 10 players in a group") log.Error("championship error: more than 10 players in a group")
} }
ChampshipData.GroupInfo[g[i][j]] = ChampshipData.AutoId 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{ ChampshipData.Rank[ChampshipData.AutoId] = append(ChampshipData.Rank[ChampshipData.AutoId], &ChampshipRank{
Uid: UserData.Uid, Uid: userData.Uid,
Score: UserData.Score, Score: userData.Score,
Time: UserData.Time, 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 { if len(ChampshipData.Rank[ChampshipData.AutoId]) >= 10 && j != len(g[i])-1 {
ChampshipData.AutoId++ 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 { 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") log.Error("championship error: more than 30 players in a group or no player in a group")
continue continue
} }
RobotNum := 30 - len(ChampshipData.Rank[j]) robotNum := 30 - len(ChampshipData.Rank[j])
//log.Debug("group AutoId:%d, player num:%d, need robot num:%d", j, len(ChampshipData.Rank[j]), RobotNum) //log.Debug("group AutoId:%d, player num:%d, need robot num:%d", j, len(ChampshipData.Rank[j]), robotNum)
RobotList := CreateRobotList(i, RobotNum, j) robotList := CreateRobotList(i, robotNum, j)
for i := 0; i < RobotNum; i++ { for i := 0; i < robotNum; i++ {
go FormatRobotInfo(RobotList[i], i+1, uids) go FormatRobotInfo(robotList[i], i+1, uids)
} }
for _, v := range RobotList { for _, v := range robotList {
ChampshipData.Robot[ChampshipData.RobotId] = v ChampshipData.Robot[ChampshipData.RobotId] = v
ChampshipData.Rank[j] = append(ChampshipData.Rank[j], &ChampshipRank{ ChampshipData.Rank[j] = append(ChampshipData.Rank[j], &ChampshipRank{
Uid: ChampshipData.RobotId, Uid: ChampshipData.RobotId,
@ -563,13 +562,13 @@ func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
// 获取分组ID // 获取分组ID
func (c *ChampshipMgr) getGroupId(Uid int) int { func (c *ChampshipMgr) getGroupId(uid int) int {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.RLock() ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock() defer ChampshipData.mu.RUnlock()
GroupId, ok := ChampshipData.GroupInfo[Uid] groupId, ok := ChampshipData.GroupInfo[uid]
if ok { if ok {
return GroupId return groupId
} }
return 0 return 0
} }
@ -578,7 +577,7 @@ func (c *ChampshipMgr) getGroupId(Uid int) int {
func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) { func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
data := m.Extra.(CRank) data := m.Extra.(CRank)
// 在加锁前获取 GroupId，避免在持有写锁时调用会获取读锁的 getGroupId 导致死锁 // 在加锁前获取 GroupId，避免在持有写锁时调用会获取读锁的 getGroupId 导致死锁
GroupId := c.getGroupId(data.Uid) groupId := c.getGroupId(data.Uid)
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.Lock() ChampshipData.mu.Lock()
@ -586,10 +585,10 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
// 再次检查 GroupId，因为可能在等待锁期间被其他协程修改 // 再次检查 GroupId，因为可能在等待锁期间被其他协程修改
if currentGroupId, ok := ChampshipData.GroupInfo[data.Uid]; ok { if currentGroupId, ok := ChampshipData.GroupInfo[data.Uid]; ok {
GroupId = currentGroupId groupId = currentGroupId
} }
if GroupId == 0 { if groupId == 0 {
ChampshipData.Pool[data.Uid] = &GroupInfo{ ChampshipData.Pool[data.Uid] = &GroupInfo{
Uid: data.Uid, Uid: data.Uid,
Score: data.Score, Score: data.Score,
@ -599,13 +598,13 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
} }
return nil, nil return nil, nil
} }
RankList, ok := ChampshipData.Rank[GroupId] rankList, ok := ChampshipData.Rank[groupId]
if !ok { if !ok {
ChampshipData.Rank[GroupId] = make([]*ChampshipRank, 0) ChampshipData.Rank[groupId] = make([]*ChampshipRank, 0)
} }
inRank := false inRank := false
Notify := make(map[int]int) notify := make(map[int]int)
for k, v := range RankList { for k, v := range rankList {
if v.Uid == data.Uid { if v.Uid == data.Uid {
if v.Score < data.Score { if v.Score < data.Score {
v.Score = data.Score v.Score = data.Score
@ -615,29 +614,29 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
} }
return nil, nil return nil, nil
} }
Notify[v.Uid] = k notify[v.Uid] = k
} }
if !inRank { if !inRank {
RankList = append(RankList, &ChampshipRank{ rankList = append(rankList, &ChampshipRank{
Uid: data.Uid, Uid: data.Uid,
Score: data.Score, Score: data.Score,
Time: GoUtil.Now(), Time: GoUtil.Now(),
}) })
} }
sort.Slice(RankList, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序 sort.Slice(rankList, func(i, j int) bool { // 排序 从大到小 数值相等按时间排序
if RankList[i].Score > RankList[j].Score { if rankList[i].Score > rankList[j].Score {
return true return true
} else if RankList[i].Score == RankList[j].Score { } else if rankList[i].Score == rankList[j].Score {
return RankList[i].Time < RankList[j].Time return rankList[i].Time < rankList[j].Time
} }
return false return false
}) })
ChampshipData.Rank[GroupId] = RankList ChampshipData.Rank[groupId] = rankList
// 收集需要通知的玩家 // 收集需要通知的玩家
notifyList := make([]int, 0) notifyList := make([]int, 0)
for k, v := range RankList { for k, v := range rankList {
if Notify[v.Uid] != k && v.Type != RANK_PLAYER_ROBOT { if notify[v.Uid] != k && v.Type != RANK_PLAYER_ROBOT {
c.SetRankCache(v.Uid) c.SetRankCache(v.Uid)
notifyList = append(notifyList, v.Uid) notifyList = append(notifyList, v.Uid)
} }
@ -653,75 +652,75 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
return nil, nil return nil, nil
} }
func (c *ChampshipMgr) getMyRank(Uid int) int { func (c *ChampshipMgr) getMyRank(uid int) int {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.RLock() ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock() defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.GroupInfo[Uid] groupId := ChampshipData.GroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return 0 return 0
} }
RankList, ok := ChampshipData.Rank[GroupId] rankList, ok := ChampshipData.Rank[groupId]
if !ok { if !ok {
return 0 return 0
} }
for k, v := range RankList { for k, v := range rankList {
if v.Uid == Uid { if v.Uid == uid {
return k + 1 return k + 1
} }
} }
return 0 return 0
} }
func (c *ChampshipMgr) unsafe_getMyRank(Uid int) int { func (c *ChampshipMgr) unsafe_getMyRank(uid int) int {
ChampshipData := c.getData() ChampshipData := c.getData()
GroupId := ChampshipData.GroupInfo[Uid] groupId := ChampshipData.GroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return 0 return 0
} }
RankList, ok := ChampshipData.Rank[GroupId] rankList, ok := ChampshipData.Rank[groupId]
if !ok { if !ok {
return 0 return 0
} }
for k, v := range RankList { for k, v := range rankList {
if v.Uid == Uid { if v.Uid == uid {
return k + 1 return k + 1
} }
} }
return 0 return 0
} }
func (c *ChampshipMgr) getLastMyRank(Uid int) int { func (c *ChampshipMgr) getLastMyRank(uid int) int {
ChampshipData := c.getData() ChampshipData := c.getData()
ChampshipData.mu.RLock() ChampshipData.mu.RLock()
defer ChampshipData.mu.RUnlock() defer ChampshipData.mu.RUnlock()
GroupId := ChampshipData.PreGroupInfo[Uid] groupId := ChampshipData.PreGroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return 0 return 0
} }
RankList, ok := ChampshipData.PreRank[GroupId] rankList, ok := ChampshipData.PreRank[groupId]
if !ok { if !ok {
return 0 return 0
} }
for k, v := range RankList { for k, v := range rankList {
if v.Uid == Uid { if v.Uid == uid {
return k + 1 return k + 1
} }
} }
return 0 return 0
} }
func (c *ChampshipMgr) unsafe_getLastMyRank(Uid int) int { func (c *ChampshipMgr) unsafe_getLastMyRank(uid int) int {
ChampshipData := c.getData() ChampshipData := c.getData()
GroupId := ChampshipData.PreGroupInfo[Uid] groupId := ChampshipData.PreGroupInfo[uid]
if GroupId == 0 { if groupId == 0 {
return 0 return 0
} }
RankList, ok := ChampshipData.PreRank[GroupId] rankList, ok := ChampshipData.PreRank[groupId]
if !ok { if !ok {
return 0 return 0
} }
for k, v := range RankList { for k, v := range rankList {
if v.Uid == Uid { if v.Uid == uid {
return k + 1 return k + 1
} }
} }
@ -732,215 +731,215 @@ func (c *ChampshipMgr) getData() *ChampshipData {
return c.data.(*ChampshipData) return c.data.(*ChampshipData)
} }
func CreateRobotList(G, Num, GroupId int) []*ChampshipRobot { func CreateRobotList(G, num, groupId int) []*ChampshipRobot {
r := make([]*ChampshipRobot, 0) r := make([]*ChampshipRobot, 0)
switch G { switch G {
case 1: case 1:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), 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(2781, 4630)), groupId))
for i := 0; i < 6; i++ { 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++ { 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++ { 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: case 2:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), 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(2781, 4630)), groupId))
for i := 0; i < 6; i++ { 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++ { 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++ { 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: case 3:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), 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(2781, 4630)), groupId))
for i := 0; i < 6; i++ { 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++ { 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++ { 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++ { 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: case 4:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), 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(2781, 4630)), groupId))
n := Num - 4 n := num - 4
for i := 0; i < int(float64(n)*0.35); i++ { 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++ { 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++ { 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++ { 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: case 5:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
r = append(r, CreateRobot(float64(GoUtil.RandNum(4631, 7530)), 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++ { 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++ { 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++ { 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++ { 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++ { 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: case 6:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), 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(7531, 12180)), groupId))
n := Num - 2 n := num - 2
for i := 0; i < int(float64(n)*0.05); i++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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: case 7:
r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), GroupId)) r = append(r, CreateRobot(float64(GoUtil.RandNum(12181, 21680)), groupId))
n := Num - 1 n := num - 1
for i := 0; i < int(float64(n)*0.05); i++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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: case 8, 9, 10, 11:
M10 := GoUtil.RandMap(map[int]int{0: 98, 1: 2}) M10 := GoUtil.RandMap(map[int]int{0: 98, 1: 2})
if M10 == 1 { 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++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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++ { 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 return r
} }
func CreateRobot(M float64, GroupId int) *ChampshipRobot { func CreateRobot(M float64, groupId int) *ChampshipRobot {
Type := GoUtil.RandMap(map[int]int{1: 25, 2: 50, 3: 25}) rType := GoUtil.RandMap(map[int]int{1: 25, 2: 50, 3: 25})
Score := M / 10 score := M / 10
PerScore := 0.0 perScore := 0.0
if Type == 2 { if rType == 2 {
PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/60)*100) / 100 perScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/60)*100) / 100
Score = M / 10 * 0.66 score = M / 10 * 0.66
} }
if Type == 3 { if rType == 3 {
PerScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/1800)*100) / 100 perScore = math.Round((M/10*0.34)/(float64(GoUtil.NextZeroTimestampDuration())/1800)*100) / 100
Score = 2 score = 2
} }
return &ChampshipRobot{ return &ChampshipRobot{
Max: M / 10, Max: M / 10,
Type: Type, Type: rType,
Name: randnameCfg.GetRandName(), Name: randnameCfg.GetRandName(),
PetName: randnameCfg.GetRandName(), PetName: randnameCfg.GetRandName(),
Avatar: avatarCfg.GetRandInitId(), Avatar: avatarCfg.GetRandInitId(),
Face: faceCfg.GetRandInitId(), Face: faceCfg.GetRandInitId(),
Level: GoUtil.RandNum(1, 10), Level: GoUtil.RandNum(1, 10),
GroupId: GroupId, GroupId: groupId,
Time: GoUtil.Now(), Time: GoUtil.Now(),
Score: Score, Score: score,
PerScore: PerScore, PerScore: perScore,
} }
} }
func FormatRobotInfo(Robot *ChampshipRobot, index int, uids []int) { func FormatRobotInfo(robot *ChampshipRobot, index int, uids []int) {
x := int(len(uids)) / 30 x := int(len(uids)) / 30
if index > int(x) { if index > int(x) {
index = int(x) index = int(x)
@ -956,24 +955,24 @@ func FormatRobotInfo(Robot *ChampshipRobot, index int, uids []int) {
if playerSimpleData == nil { if playerSimpleData == nil {
return return
} }
Robot.Level = playerSimpleData.Level robot.Level = playerSimpleData.Level
Robot.Avatar = playerSimpleData.Avatar robot.Avatar = playerSimpleData.Avatar
Robot.Face = playerSimpleData.Face robot.Face = playerSimpleData.Face
Robot.Playroom = playerSimpleData.Playroom robot.Playroom = playerSimpleData.Playroom
Robot.DressSet = playerSimpleData.DressSet robot.DressSet = playerSimpleData.DressSet
Robot.FurSet = playerSimpleData.PetFur robot.FurSet = playerSimpleData.PetFur
Robot.ActLog = playerSimpleData.ActLog robot.ActLog = playerSimpleData.ActLog
Robot.PetName = playerSimpleData.PetName robot.PetName = playerSimpleData.PetName
} }
func (c *ChampshipMgr) SetRankCache(Uid int) { func (c *ChampshipMgr) SetRankCache(uid int) {
PreRank := c.unsafe_getLastMyRank(Uid) preRank := c.unsafe_getLastMyRank(uid)
Rank := c.unsafe_getMyRank(Uid) rank := c.unsafe_getMyRank(uid)
PreGroupId := c.getData().PreGroupInfo[Uid] preGroupId := c.getData().PreGroupInfo[uid]
GroupId := c.getData().GroupInfo[Uid] groupId := c.getData().GroupInfo[uid]
key := fmt.Sprintf("champship_rank_cache_%d", 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)) 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) db.RedisSetKey(key, fmt.Sprintf("%d_%d_%d_%d", preRank, rank, preGroupId, groupId), time.Second*172800)
} }
func (c *ChampshipMgr) Debug() { func (c *ChampshipMgr) Debug() {
@ -1001,13 +1000,13 @@ func (c *ChampshipMgr) Debug() {
log.Debug("Debug player num:%d", i) log.Debug("Debug player num:%d", i)
} }
func GetRankCache(Uid int) (int, int, int, int) { func GetRankCache(uid int) (int, int, int, int) {
key := fmt.Sprintf("champship_rank_cache_%d", Uid) key := fmt.Sprintf("champship_rank_cache_%d", uid)
data, err := db.RedisGetKey(key) data, err := db.RedisGetKey(key)
if err != nil || data == "" { if err != nil || data == "" {
return 0, 0, 0, 0 return 0, 0, 0, 0
} }
var PreRank, Rank, PreGroupId, GroupId int var preRank, rank, preGroupId, groupId int
fmt.Sscanf(data, "%d_%d_%d_%d", &PreRank, &Rank, &PreGroupId, &GroupId) fmt.Sscanf(data, "%d_%d_%d_%d", &preRank, &rank, &preGroupId, &groupId)
return PreRank, Rank, PreGroupId, GroupId return preRank, rank, preGroupId, groupId
} }

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

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

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

@ -215,6 +215,7 @@ func HandleClientReq(args []interface{}) {
} }
p.(*Player).Recover(backup) //还原Player的数据 p.(*Player).Recover(backup) //还原Player的数据
} }
backup.Reclaim() // 回收备份对象
p.(*Player).lock.Unlock() //解锁 p.(*Player).lock.Unlock() //解锁
}() }()
p.(*Player).args = make(map[string]interface{}) 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 { func (p *Player) GetVisitorPlayer() int {
PlayroomMod := p.PlayMod.getPlayroomMod() PlayroomMod := p.PlayMod.getPlayroomMod()
VisitorList := PlayroomMod.GetVisitor() // 到访用户 visitorList := PlayroomMod.GetVisitor() // 到访用户
TodayVisitedUsers := PlayroomMod.GetTodayVisitedUsers() // 今日已互动用户 todayVisitedUsers := PlayroomMod.GetTodayVisitedUsers() // 今日已互动用户
FriendMod := p.PlayMod.getFriendMod() FriendMod := p.PlayMod.getFriendMod()
type sortData struct { type sortData struct {
Uid int Uid int
Time int64 Time int64
} }
PlayerList := make([]sortData, 0) playerList := make([]sortData, 0)
PlayerList2 := make([]sortData, 0) playerList2 := make([]sortData, 0)
Now := GoUtil.Now() now := GoUtil.Now()
/** /**
排除当日玩家已对其发起过交互的用户 排除当日玩家已对其发起过交互的用户
优先选择24小时内曾经与玩家进行过宠物交互的好友 优先选择24小时内曾经与玩家进行过宠物交互的好友
@ -30,30 +30,30 @@ func (p *Player) GetVisitorPlayer() int {
若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
若不存在符合条件的用户，则依据以上用户推荐算法，选择一位随机推荐用户，并且在下次触发式订单完成时，不再排除已发起过交互的用户 若不存在符合条件的用户，则依据以上用户推荐算法，选择一位随机推荐用户，并且在下次触发式订单完成时，不再排除已发起过交互的用户
*/ */
for k, v := range VisitorList { for k, v := range visitorList {
if GoUtil.InArray(k, TodayVisitedUsers) { if GoUtil.InArray(k, todayVisitedUsers) {
continue continue
} }
if v.Time < Now-86400 { if v.Time < now-86400 {
continue continue
} }
if FriendMod.CheckFriend(k) { if FriendMod.CheckFriend(k) {
PlayerList = append(PlayerList, sortData{k, v.Time}) playerList = append(playerList, sortData{k, v.Time})
} else { } else {
PlayerList2 = append(PlayerList2, sortData{k, v.Time}) playerList2 = append(playerList2, sortData{k, v.Time})
} }
} }
if len(PlayerList) != 0 { if len(playerList) != 0 {
sort.Slice(PlayerList, func(i, j int) bool { sort.Slice(playerList, func(i, j int) bool {
return PlayerList[i].Time > PlayerList[j].Time return playerList[i].Time > playerList[j].Time
}) })
return PlayerList[0].Uid return playerList[0].Uid
} }
if len(PlayerList2) != 0 { if len(playerList2) != 0 {
sort.Slice(PlayerList2, func(i, j int) bool { sort.Slice(playerList2, func(i, j int) bool {
return PlayerList2[i].Time > PlayerList2[j].Time return playerList2[i].Time > playerList2[j].Time
}) })
return PlayerList2[0].Uid return playerList2[0].Uid
} }
// 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友 // 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
var recentFriendUid int var recentFriendUid int
@ -62,14 +62,14 @@ func (p *Player) GetVisitorPlayer() int {
if uid == int(p.M_DwUin) { if uid == int(p.M_DwUin) {
continue continue
} }
if GoUtil.InArray(uid, TodayVisitedUsers) { if GoUtil.InArray(uid, todayVisitedUsers) {
continue continue
} }
ps := G_GameLogicPtr.GetSimplePlayerByUid(uid) ps := G_GameLogicPtr.GetSimplePlayerByUid(uid)
if ps == nil { if ps == nil {
continue continue
} }
if Now-ps.Loginout > 86400 { // 24小时内登录过 if now-ps.Loginout > 86400 { // 24小时内登录过
continue continue
} }
if ps.Loginout > recentLoginTime { if ps.Loginout > recentLoginTime {
@ -84,51 +84,51 @@ func (p *Player) GetVisitorPlayer() int {
if err != nil { if err != nil {
return 0 return 0
} }
var PlayerList4 []int var playerList4 []int
for _, Uid := range uids { for _, uid := range uids {
if Uid == int(p.M_DwUin) { if uid == int(p.M_DwUin) {
continue continue
} }
if G_GameLogicPtr.GetSimplePlayerByUid(Uid) == nil { if G_GameLogicPtr.GetSimplePlayerByUid(uid) == nil {
continue continue
} }
PlayerList4 = append(PlayerList4, Uid) playerList4 = append(playerList4, uid)
} }
L := GoUtil.RandSliceNum(PlayerList4, 1) lastList := GoUtil.RandSliceNum(playerList4, 1)
if len(L) == 0 { if len(lastList) == 0 {
return 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) uids, err := db.GetCommendPlayerFromDb(p.M_DwUin, GoUtil.Now()-259200, 4)
if err != nil { if err != nil {
log.Debug("GetCommendPlayerFromDb err:%v, uid=%d", err, p.M_DwUin) log.Debug("GetCommendPlayerFromDb err:%v, uid=%d", err, p.M_DwUin)
return nil return nil
} }
PlayerList1 := make([]int, 0, len(uids)) playerList1 := make([]int, 0, len(uids))
FriendMod := p.PlayMod.getFriendMod() FriendMod := p.PlayMod.getFriendMod()
for _, Uid := range uids { for _, uid := range uids {
if Uid == int(p.M_DwUin) { if uid == int(p.M_DwUin) {
continue continue
} }
if FriendMod.CheckSendApply(Uid) { if FriendMod.CheckSendApply(uid) {
continue continue
} }
if FriendMod.CheckAddBefore(Uid) { if FriendMod.CheckAddBefore(uid) {
continue continue
} }
PlayerList1 = append(PlayerList1, Uid) playerList1 = append(playerList1, uid)
} }
// 按照时间门槛筛选用户 // 按照时间门槛筛选用户
filterByTime := func(excludeSeconds int64) []int { filterByTime := func(excludeSeconds int64) []int {
now := GoUtil.Now() now := GoUtil.Now()
result := make([]int, 0, len(PlayerList1)) result := make([]int, 0, len(playerList1))
for _, Uid := range PlayerList1 { for _, uid := range playerList1 {
recommendTime := FriendMod.GetRecommendTime(Uid) recommendTime := FriendMod.GetRecommendTime(uid)
if recommendTime == 0 || recommendTime <= now-excludeSeconds { if recommendTime == 0 || recommendTime <= now-excludeSeconds {
result = append(result, Uid) result = append(result, uid)
} }
} }
return result return result
@ -145,16 +145,16 @@ func GetRecommendPlayer(p *Player, Num int) []int {
} }
if len(candidateList) == 0 { if len(candidateList) == 0 {
candidateList = append(candidateList, PlayerList1...) candidateList = append(candidateList, playerList1...)
} }
if len(candidateList) == 0 { if len(candidateList) == 0 {
candidateList = make([]int, 0, len(uids)) candidateList = make([]int, 0, len(uids))
for _, Uid := range uids { for _, uid := range uids {
if Uid == int(p.M_DwUin) { if uid == int(p.M_DwUin) {
continue continue
} }
candidateList = append(candidateList, Uid) candidateList = append(candidateList, uid)
} }
} }
levelFilterList := make([]*PlayerSimpleData, 0, len(candidateList)) levelFilterList := make([]*PlayerSimpleData, 0, len(candidateList))
@ -291,9 +291,9 @@ func GetRecommendPlayer(p *Player, Num int) []int {
return res return res
} }
if diffLimit == 10 && len(chargeFilterList) >= 5 { if diffLimit == 10 && len(chargeFilterList) >= 5 {
MaxCharge := p.GetChargeMod().GetMaxCharge() maxCharge := p.GetChargeMod().GetMaxCharge()
if MaxCharge > 0 { if maxCharge > 0 {
endFilterList = chargeFilterFunc(chargeFilterList, MaxCharge) endFilterList = chargeFilterFunc(chargeFilterList, maxCharge)
} else { } else {
if p.GetChargeMod().GetAdWatch() > 5 { if p.GetChargeMod().GetAdWatch() > 5 {
endFilterList = notChargeWatchAdFilterFunc(chargeFilterList) endFilterList = notChargeWatchAdFilterFunc(chargeFilterList)
@ -303,21 +303,21 @@ func GetRecommendPlayer(p *Player, Num int) []int {
} }
} }
recommendList := GoUtil.RandSliceNum(endFilterList, Num) recommendList := GoUtil.RandSliceNum(endFilterList, num)
for _, Uid := range recommendList { for _, uid := range recommendList {
FriendMod.AddRecommend(Uid) FriendMod.AddRecommend(uid)
} }
return recommendList return recommendList
} }
func GetUidByFaceBook(Fb string) (int, error) { func GetUidByFaceBook(fb string) (int, error) {
sqlStr := "SELECT dwUin FROM t_player_baseinfo WHERE FaceBookId = ?" sqlStr := "SELECT dwUin FROM t_player_baseinfo WHERE FaceBookId = ?"
type Result struct { type Result struct {
Uid int `db:"dwUin"` Uid int `db:"dwUin"`
} }
R := Result{} R := Result{}
err := db.SqlDb.Get(&R, sqlStr, Fb) err := db.SqlDb.Get(&R, sqlStr, fb)
log.Debug("Fb :%s;Uid :%d", Fb, R.Uid) log.Debug("Fb :%s;Uid :%d", fb, R.Uid)
return R.Uid, err 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, From: uid,
Extra: []int{2, 145}, 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": case "debugLogoutMsg":
ToUid, _ := strconv.Atoi(arg[1]) ToUid, _ := strconv.Atoi(arg[1])
uidList, err := db.GetDebugPlayer(ToUid) 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) { func (p *Player) LimitedTimeEventTrigger(addEventId int) {
Lv := p.GetPlayerBaseMod().GetLevel() lv := p.GetPlayerBaseMod().GetLevel()
EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(Lv) endTime, timeoutEvent, addEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(lv)
remainingTime := GoUtil.NextHourRemain() remainingTime := GoUtil.NextHourRemain()
if EndTime <= 0 { if endTime <= 0 {
EndTime = int(remainingTime) endTime = int(remainingTime)
} else { } else {
EndTime = min(EndTime, int(remainingTime)) endTime = min(endTime, int(remainingTime))
} }
if AddEventId != 0 { if addEventId != 0 {
AddEvent = append(AddEvent, AddEventId) addEvent = append(addEvent, addEventId)
} }
if EndTime > 0 { if endTime > 0 {
p.CallEvent(time.Duration(EndTime)*time.Second, func() { p.CallEvent(time.Duration(endTime)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
p.LimitedTimeEventTrigger(0) p.LimitedTimeEventTrigger(0)
@ -37,7 +37,7 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
}, "LimitedTimeEvent") }, "LimitedTimeEvent")
} }
for _, v := range TimeoutEvent { // 事件到期处理 for _, v := range timeoutEvent { // 事件到期处理
p.PushClientRes(&msg.LimitEventNotify{ p.PushClientRes(&msg.LimitEventNotify{
Id: int32(v), Id: int32(v),
Type: limitedTimeEvent.EVENT_NOTIFY_TYPE_DEL, Type: limitedTimeEvent.EVENT_NOTIFY_TYPE_DEL,
@ -45,15 +45,15 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
switch v { switch v {
case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER: case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
BaseMod := p.PlayMod.getBaseMod() BaseMod := p.PlayMod.getBaseMod()
EnergyMul := BaseMod.GetEnergyMul() energyMul := BaseMod.GetEnergyMul()
OrderMod := p.PlayMod.getOrderMod() OrderMod := p.PlayMod.getOrderMod()
Emit := p.PlayMod.getChessMod().GetOrderEmit() emit := p.PlayMod.getChessMod().GetOrderEmit()
ChessList := p.PlayMod.getChessMod().GetUnlockChessList() chessList := p.PlayMod.getChessMod().GetUnlockChessList()
OrderMod.ChangeEnergyMul(Lv, Emit, EnergyMul, ChessList) OrderMod.ChangeEnergyMul(lv, emit, energyMul, chessList)
p.PushClientRes(OrderMod.BackData()) p.PushClientRes(OrderMod.BackData())
p.TeLog("mutil_merge_change", map[string]interface{}{ p.TeLog("mutil_merge_change", map[string]interface{}{
"change_from": math.Pow(2, float64(EnergyMul)), "change_from": math.Pow(2, float64(energyMul)),
"change_to": math.Pow(2, float64(EnergyMul)), "change_to": math.Pow(2, float64(energyMul)),
"is_auto": true, "is_auto": true,
}) })
p.PushClientRes(p.PlayMod.getBaseMod().BackData()) 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 { switch v {
case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER: case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
Emit := p.PlayMod.getChessMod().GetOrderEmit() emit := p.PlayMod.getChessMod().GetOrderEmit()
Lv := p.GetPlayerBaseMod().GetLevel() lv := p.GetPlayerBaseMod().GetLevel()
EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul() energyMul := p.PlayMod.getBaseMod().GetEnergyMul()
p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit, EnergyMul) p.PlayMod.getOrderMod().CreateSuperOrder(lv, emit, energyMul)
p.PushClientRes(p.PlayMod.getOrderMod().BackData()) p.PushClientRes(p.PlayMod.getOrderMod().BackData())
case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL: case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
p.PlayMod.getCardMod().CreateCardFestival() p.PlayMod.getCardMod().CreateCardFestival()
@ -95,9 +95,9 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
// 限时猪猪存钱罐触发器 // 限时猪猪存钱罐触发器
func (p *Player) LimitedTimePiggyBankTrigger() { func (p *Player) LimitedTimePiggyBankTrigger() {
Remain := p.PlayMod.getPiggyBankMod().TimeOut() remain := p.PlayMod.getPiggyBankMod().TimeOut()
if Remain > 0 { if remain > 0 {
p.CallEvent(time.Duration(Remain)*time.Second, func() { p.CallEvent(time.Duration(remain)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
p.LimitedTimePiggyBankTrigger() p.LimitedTimePiggyBankTrigger()
@ -111,10 +111,10 @@ func (p *Player) LimitedTimePiggyBankTrigger() {
func (p *Player) LimitedTimeCardTrigger() { func (p *Player) LimitedTimeCardTrigger() {
FriendMod := p.PlayMod.getFriendMod() FriendMod := p.PlayMod.getFriendMod()
CardMod := p.PlayMod.getCardMod() CardMod := p.PlayMod.getCardMod()
Now := GoUtil.Now() now := GoUtil.Now()
var EndTime int64 var endTime int64
for k, v := range FriendMod.Card { for k, v := range FriendMod.Card {
if v.EndTime > 0 && v.EndTime <= Now { if v.EndTime > 0 && v.EndTime <= now {
switch v.Status { switch v.Status {
case card.STATUS_CARD_EX_1: case card.STATUS_CARD_EX_1:
delete(FriendMod.Card, k) delete(FriendMod.Card, k)
@ -137,12 +137,12 @@ func (p *Player) LimitedTimeCardTrigger() {
} }
continue continue
} }
if v.EndTime > 0 && (EndTime == 0 || v.EndTime < EndTime) { if v.EndTime > 0 && (endTime == 0 || v.EndTime < endTime) {
EndTime = v.EndTime endTime = v.EndTime
} }
} }
if EndTime > 0 { if endTime > 0 {
p.CallEvent(time.Duration(EndTime-Now)*time.Second, func() { p.CallEvent(time.Duration(endTime-now)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
p.LimitedTimeCardTrigger() 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() PlayroomMod := p.PlayMod.getPlayroomMod()
Physiology := PlayroomMod.GetPhysiology(Id) physiology := PlayroomMod.GetPhysiology(id)
if Physiology == nil { if physiology == nil {
return return
} }
NewTime, NextSecond, Num := PlayroomTrigger(Physiology.Id, Physiology.Time, Physiology.Num) newTime, nextSecond, num := PlayroomTrigger(physiology.Id, physiology.Time, physiology.Num)
Physiology.Time = NewTime physiology.Time = newTime
DiffValue := Physiology.Num - Num diffValue := physiology.Num - num
MType, MEffect := playroomCfg.GetMoodEffect(Physiology.Id) mType, mEffect := playroomCfg.GetMoodEffect(physiology.Id)
CleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN) cleanMood := PlayroomMod.GetMoodInfo(playroom.MOOD_TYPE_CLEAN)
PlayroomMod.AddMood(MType, -MEffect*DiffValue) PlayroomMod.AddMood(mType, -mEffect*diffValue)
// 上厕所数值为0 且清洁度大于50时，清洁度降至50 // 上厕所数值为0 且清洁度大于50时，清洁度降至50
if CleanMood != nil && Id == playroom.PHYSIOLOGY_TYPE_TOLIET && Num == 0 && CleanMood.Num > 50 { if cleanMood != nil && id == playroom.PHYSIOLOGY_TYPE_TOLIET && num == 0 && cleanMood.Num > 50 {
CleanMood.Num = 50 cleanMood.Num = 50
} }
Physiology.Num = Num physiology.Num = num
if PlayroomMod.GetMoodInfo(MType).Num == 0 { // 心情值为0时，重置生理状态 if PlayroomMod.GetMoodInfo(mType).Num == 0 { // 心情值为0时，重置生理状态
PlayroomMod.ResetPhysiology(MType) PlayroomMod.ResetPhysiology(mType)
NewTime = 0 newTime = 0
} }
p.PlayMod.save() p.PlayMod.save()
ResNotifyMood := PlayroomMod.NotifyMood() ResNotifyMood := PlayroomMod.NotifyMood()
p.PushClientRes(ResNotifyMood) p.PushClientRes(ResNotifyMood)
if NextSecond > 0 { if nextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() { p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
p.LimitedTimePlayroomTrigger_(Id) p.LimitedTimePlayroomTrigger_(id)
p.SendClientRes() p.SendClientRes()
}, fmt.Sprintf("Playroom_%d", Id)) }, fmt.Sprintf("Playroom_%d", id))
} }
} }
func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) { func PlayroomTrigger(id int, time int64, num int) (int64, int64, int) {
if Num == 0 { if num == 0 {
return 0, 0, 0 return 0, 0, 0
} }
Now := GoUtil.Now() now := GoUtil.Now()
NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num) needDuration := playroomCfg.GetPhysiologyDuration(id, num)
if Time+int64(NeedDuration) > Now { if time+int64(needDuration) > now {
return Time, int64(NeedDuration), Num return time, int64(needDuration), num
} }
n := 0 n := 0
for n <= 100 { for n <= 100 {
Num-- num--
NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num) needDuration := playroomCfg.GetPhysiologyDuration(id, num)
Time += int64(NeedDuration) time += int64(needDuration)
if Time >= Now { if time >= now {
return Now, int64(NeedDuration), Num return now, int64(needDuration), num
} }
if Num == 0 { if num == 0 {
return 0, 0, 0 return 0, 0, 0
} }
n++ n++
@ -220,18 +220,18 @@ func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
func LimitedTimePlayroomWorkTrigger(p *Player) { func LimitedTimePlayroomWorkTrigger(p *Player) {
PlayroomMod := p.PlayMod.getPlayroomMod() PlayroomMod := p.PlayMod.getPlayroomMod()
EndTime := PlayroomMod.Endtime endTime := PlayroomMod.Endtime
Now := GoUtil.Now() now := GoUtil.Now()
if EndTime > 0 && EndTime <= Now { if endTime > 0 && endTime <= now {
PlayroomMod.ResetWork() PlayroomMod.ResetWork()
p.PlayMod.save() p.PlayMod.save()
p.PlayroomBackData() p.PlayroomBackData()
p.SendClientRes() p.SendClientRes()
return return
} }
NextSecond := EndTime - Now nextSecond := endTime - now
if NextSecond > 0 { if nextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() { p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
LimitedTimePlayroomWorkTrigger(p) LimitedTimePlayroomWorkTrigger(p)
@ -245,50 +245,50 @@ func LimitedTimeEnergyAdd(p *Player) {
PlayerBaseMod := p.GetPlayerBaseMod() PlayerBaseMod := p.GetPlayerBaseMod()
BaseMod := p.PlayMod.getBaseMod() BaseMod := p.PlayMod.getBaseMod()
delta := curtime - BaseMod.GetRecoverTime() delta := curtime - BaseMod.GetRecoverTime()
Recover := userCfg.GetRecover(BaseMod.GetLevel()) recover := userCfg.GetRecover(BaseMod.GetLevel())
if Recover <= 0 { if recover <= 0 {
return return
} }
Addsta := int(delta) / Recover addsta := int(delta) / recover
if Addsta <= 0 { if addsta <= 0 {
return return
} }
Energy := BaseMod.GetEnergy() energy := BaseMod.GetEnergy()
MaxEnergy := PlayerBaseMod.GetMaxEnergy() maxEnergy := PlayerBaseMod.GetMaxEnergy()
if MaxEnergy > Energy { if maxEnergy > energy {
E := MaxEnergy - Energy e := maxEnergy - energy
Energy += Addsta energy += addsta
if Energy > MaxEnergy { if energy > maxEnergy {
Energy = MaxEnergy energy = maxEnergy
} }
p.TeLog("asset_change", map[string]interface{}{ p.TeLog("asset_change", map[string]interface{}{
"item_id": item.ITEM_ENERGY_ID, "item_id": item.ITEM_ENERGY_ID,
"change_type": "gain", "change_type": "gain",
"change_num": min(Addsta, E), "change_num": min(addsta, e),
"change_after": Energy, "change_after": energy,
"change_reason": "recover_server", "change_reason": "recover_server",
}) })
p.CallEvent(time.Duration(Recover)*time.Second, func() { p.CallEvent(time.Duration(recover)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
LimitedTimeEnergyAdd(p) LimitedTimeEnergyAdd(p)
}, "AddEnergy") }, "AddEnergy")
} }
BaseMod.SetEnergy(Energy) BaseMod.SetEnergy(energy)
BaseMod.SetRecoverTime(curtime) BaseMod.SetRecoverTime(curtime)
p.SendErrClienRes(PlayerBaseMod.BackAsset()) p.SendErrClienRes(PlayerBaseMod.BackAsset())
} }
func GuideTaskTrigger(p *Player) { func GuideTaskTrigger(p *Player) {
GuideTaskMod := p.PlayMod.getGuideTaskMod() GuideTaskMod := p.PlayMod.getGuideTaskMod()
UnlockTime := GuideTaskMod.UnlockTime unlockTime := GuideTaskMod.UnlockTime
if UnlockTime == 0 { if unlockTime == 0 {
return return
} }
Now := GoUtil.Now() now := GoUtil.Now()
NextSecond := 86400 - (Now-UnlockTime)%86400 nextSecond := 86400 - (now-unlockTime)%86400
if NextSecond > 0 { if nextSecond > 0 {
p.CallEvent(time.Duration(NextSecond)*time.Second, func() { p.CallEvent(time.Duration(nextSecond)*time.Second, func() {
p.lock.Lock() p.lock.Lock()
defer p.lock.Unlock() defer p.lock.Unlock()
GuideTaskMod.Login() 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) { func (m *MailMgr) AddMail(msg *msg.Msg) (interface{}, error) {
ServerMail, ok := msg.Extra.(*ServerMail) serverMail, ok := msg.Extra.(*ServerMail)
if !ok { if !ok {
log.Error("AddMail error: invalid mail data") log.Error("AddMail error: invalid mail data")
return nil, nil return nil, nil
} }
m.list[ServerMail.Id] = ServerMail m.list[serverMail.Id] = serverMail
return nil, nil return nil, nil
} }
@ -76,10 +76,10 @@ func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
return nil, err return nil, err
} }
for _, v := range data { for _, v := range data {
Uids := make([]int, 0) uids := make([]int, 0)
UidArr := strings.Split(v.To_uids, ",") uidArr := strings.Split(v.To_uids, ",")
for _, v := range UidArr { for _, v := range uidArr {
Uids = append(Uids, GoUtil.Int(v)) uids = append(uids, GoUtil.Int(v))
} }
var items []interface{} var items []interface{}
json.Unmarshal([]byte(v.Items), &items) json.Unmarshal([]byte(v.Items), &items)
@ -99,7 +99,7 @@ func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
End_time: v.End_time, End_time: v.End_time,
Mail_type: v.Mail_type, Mail_type: v.Mail_type,
Send_type: v.Send_type, Send_type: v.Send_type,
To_uids: Uids, To_uids: uids,
} }
} }
return nil, nil 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 { func (r *MailMgr) Sync(Uid int, Register int64) []ServerMail {
// 同步邮件 // 同步邮件
Now := GoUtil.Now() now := GoUtil.Now()
list := make([]ServerMail, 0) list := make([]ServerMail, 0)
for _, v := range r.list { for _, v := range r.list {
if v.Start_time > 0 && v.Start_time > Now { if v.Start_time > 0 && v.Start_time > now {
continue continue
} }
if v.End_time > 0 && v.End_time < Now { if v.End_time > 0 && v.End_time < now {
continue continue
} }
if v.Register_time > 0 && v.Register_time < Register { 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) { func (a *Activity) Fire(id int, atype int) ([]*item.Item, error) {
// AId := activityCfg.GetActivityGiftId(Id) // AId := activityCfg.GetActivityGiftId(id)
// Var := a.getGiftVar(AId) // Var := a.getGiftVar(AId)
// if Var.Buy { // if Var.Buy {
// return nil, fmt.Errorf("Id%d已购买", Id) // return nil, fmt.Errorf("Id%d已购买", id)
// } // }
// Var.Buy = true // Var.Buy = true
// Var.Time = GoUtil.Now() // Var.Time = GoUtil.Now()
if atype == ACT_TYPE_ADD_GIFT { if atype == ACT_TYPE_ADD_GIFT {
a.AddEnd = GoUtil.Now() + 7*86400 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 AddTime int64
} }
func (f *AvatarMod) Login(RegisterTime int64) { func (f *AvatarMod) Login(registerTime int64) {
for k, v := range f.List { for k, v := range f.List {
if v.AddTime == 0 { if v.AddTime == 0 {
v.AddTime = RegisterTime v.AddTime = registerTime
f.List[k] = v f.List[k] = v
} }
} }
@ -28,10 +28,9 @@ func (f *AvatarMod) Login(RegisterTime int64) {
func (a *AvatarMod) InitData() { func (a *AvatarMod) InitData() {
now := GoUtil.Now() now := GoUtil.Now()
if a.List == nil { if a.List == nil {
a.List = make(map[int]*Avatar) initId := avatarCfg.GetInitList()
InitId := avatarCfg.GetInitList() a.List = make(map[int]*Avatar, len(initId))
a.List = make(map[int]*Avatar, len(InitId)) for _, v := range initId {
for _, v := range InitId {
a.List[v] = &Avatar{ a.List[v] = &Avatar{
AddTime: now, AddTime: now,
} }
@ -43,30 +42,30 @@ func (a *AvatarMod) GetAvatarNum() int {
return len(a.List) return len(a.List)
} }
func (a *AvatarMod) SetAvatar(Id int) error { func (a *AvatarMod) SetAvatar(id int) error {
if _, ok := a.List[Id]; !ok { if _, ok := a.List[id]; !ok {
return fmt.Errorf("avatar id:%d not exist", Id) return fmt.Errorf("avatar id:%d not exist", id)
} }
a.SetId = Id a.SetId = id
return nil return nil
} }
func (a *AvatarMod) Unlock(Id, Time int) error { func (a *AvatarMod) Unlock(id, duration int) error {
v, ok := a.List[Id] v, ok := a.List[id]
if ok { if ok {
if v.Ts == 0 { if v.Ts == 0 {
return nil return nil
} }
v.Ts += int64(Time) v.Ts += int64(duration)
return nil return nil
} }
now := GoUtil.Now() now := GoUtil.Now()
ts := int64(0) ts := int64(0)
if Time > 0 { if duration > 0 {
ts = now + int64(Time) ts = now + int64(duration)
} }
a.List[Id] = &Avatar{ a.List[id] = &Avatar{
Ts: ts, Ts: ts,
AddTime: now, 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 b.CountryCode = code
} }
if b.AddCode == "" && Ip != "" { if b.AddCode == "" && Ip != "" {
Code, _ := GoUtil.GetCountryByIP(Ip) code, _ := GoUtil.GetCountryByIP(Ip)
CountryCode := conf.Server.CountryCode countryCode := conf.Server.CountryCode
if CountryCode == "" { if countryCode == "" {
CountryCode = "000" countryCode = "000"
} }
if Code != "" && len(Code) == 3 { if code != "" && len(code) == 3 {
CountryCode = Code 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 == "" { if b.NickName == "" {
b.NickName = fmt.Sprintf("Player_%d", Uid) b.NickName = fmt.Sprintf("Player_%d", Uid)
@ -71,15 +71,15 @@ func (b *Base) InitData(Uid int, Ip string) {
} }
func (b *Base) Login() int64 { func (b *Base) Login() int64 {
Now := GoUtil.Now() now := GoUtil.Now()
if !GoUtil.IsSameDay(b.LoginTime, Now) { if !GoUtil.IsSameDay(b.LoginTime, now) {
b.LoginDay += 1 b.LoginDay += 1
} }
logoutDuration := int64(0) logoutDuration := int64(0)
if b.LogoutTime != 0 { if b.LogoutTime != 0 {
logoutDuration = Now - b.LogoutTime logoutDuration = now - b.LogoutTime
} }
b.LoginTime = Now b.LoginTime = now
b.LogoutTime = 0 b.LogoutTime = 0
return logoutDuration return logoutDuration
} }
@ -231,16 +231,16 @@ func (b *Base) SetLang(lang msg.LANG_TYPE) {
b.Lang = lang 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 b.EnergyBuy += 1
Mul := baseCfg.GetEnergyByMul(b.EnergyBuy) mul := baseCfg.GetEnergyByMul(b.EnergyBuy)
Diamond := int(float64(Energy) / Mul) diamond := int(float64(energy) / mul)
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -Diamond}, {Id: item.ITEM_ENERGY_ID, Num: Energy}}, Energy, Diamond return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -diamond}, {Id: item.ITEM_ENERGY_ID, Num: energy}}, energy, diamond
} }
// HighRoller 结束时重置能量倍数 // HighRoller 结束时重置能量倍数
func (b *Base) ResetEnergyMul(Mul int) { func (b *Base) ResetEnergyMul(mul int) {
b.EnergyMul = Mul b.EnergyMul = mul
} }
func (b *Base) BackData() *msg.BaseInfo { func (b *Base) BackData() *msg.BaseInfo {
@ -259,10 +259,10 @@ func (b *Base) ZeroUpdate() {
b.TodayCumulative = 0 b.TodayCumulative = 0
} }
func (b *Base) Outline(Time int) { func (b *Base) Outline(duration int) {
b.LogoutTime = GoUtil.Now() b.LogoutTime = GoUtil.Now()
b.TodayCumulative += Time b.TodayCumulative += duration
b.Cumulative += Time b.Cumulative += duration
} }
func (b *Base) GetEnergyByAD() ([]*item.Item, error) { func (b *Base) GetEnergyByAD() ([]*item.Item, error) {
@ -273,24 +273,7 @@ func (b *Base) GetEnergyByAD() ([]*item.Item, error) {
return baseCfg.GetEnergyByADNum(), nil return baseCfg.GetEnergyByADNum(), nil
} }
func (b *Base) FormatEnergyMul(Energy int) { func (b *Base) SetId2Verify(userName, num string) {
for { b.IdCardName = userName
if b.EnergyMul <= 0 { b.IdCardNum = num
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
} }

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 { func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
Now := GoUtil.Now() now := GoUtil.Now()
Duration := cardCfg.GetCardDuration() duration := cardCfg.GetCardDuration()
HandbookItemNum := 0 handbookItemNum := 0
if c.EndTime < Now { if c.EndTime < now {
c.CardList = make(map[int]int) c.CardList = make(map[int]int)
c.ExchangeStar = 0 c.ExchangeStar = 0
c.CollectReward = make(map[int]struct{}) c.CollectReward = make(map[int]struct{})
@ -132,57 +132,57 @@ func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
if v == HANDBOOK_STATUS_GET { if v == HANDBOOK_STATUS_GET {
continue continue
} }
Round := cardCfg.GetRoundById(k) round := cardCfg.GetRoundById(k)
if Round < c.Round { if round < c.Round {
continue continue
} }
HandbookItemNum += cardCfg.GetStarById(k) handbookItemNum += cardCfg.GetStarById(k)
} }
c.Handbook = make(map[int]int) c.Handbook = make(map[int]int)
} }
if c.EndTime == 0 { 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.ReqTimes = cardCfg.GetReqTimes()
c.ExTimes = cardCfg.GetExTimes() c.ExTimes = cardCfg.GetExTimes()
c.GoldTimes = 2 c.GoldTimes = 2
return c.Login(ServerOpenTime) return c.Login(serverOpenTime)
} }
// 增加卡牌 // 增加卡牌
func (c *CardMod) AddCard(Id int) { func (c *CardMod) AddCard(id int) {
_, ok := c.CardList[Id] _, ok := c.CardList[id]
if ok { if ok {
star := cardCfg.GetStarById(Id) star := cardCfg.GetStarById(id)
c.ExchangeStar += star c.ExchangeStar += star
c.Cache.ExStar += star c.Cache.ExStar += star
c.CardList[Id]++ c.CardList[id]++
} else { } else {
c.CardList[Id] = 1 c.CardList[id] = 1
} }
_, ok = c.Handbook[Id] _, ok = c.Handbook[id]
if !ok { if !ok {
c.Handbook[Id] = HANDBOOK_STATUS_IDLE c.Handbook[id] = HANDBOOK_STATUS_IDLE
c.Cache.Handbook[Id] = 1 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 cardId := 0
newCard := make([]int, 0) newCard := make([]int, 0)
cnt := cardCfg.GetPackRewardCnt(Star) cnt := cardCfg.GetPackRewardCnt(star)
if cnt == 0 { 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 { if mustHaveStar != 0 {
cardId = randCard(c.Round, mustHaveStar, 0, newCard) cardId = randCard(c.Round, mustHaveStar, 0, newCard)
if cardId == 0 { if cardId == 0 {
@ -197,7 +197,7 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
Extra := max(1, int(total/2)) Extra := max(1, int(total/2))
cnt += Extra cnt += Extra
} }
randList := cardCfg.GetRandListByStar(Star) randList := cardCfg.GetRandListByStar(star)
for i := 0; i < cnt; i++ { for i := 0; i < cnt; i++ {
CardStar := GoUtil.RandMap(randList) CardStar := GoUtil.RandMap(randList)
switch CardStar { switch CardStar {
@ -222,10 +222,10 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
// cleanExpired 清理过期的请求和交换记录，返回有效 uid 列表 // cleanExpired 清理过期的请求和交换记录，返回有效 uid 列表
func (c *CardMod) cleanExpired() (reqUid, exUid []int64) { func (c *CardMod) cleanExpired() (reqUid, exUid []int64) {
Now := GoUtil.Now() now := GoUtil.Now()
reqUid = make([]int64, 0, len(c.ReqFriend)) reqUid = make([]int64, 0, len(c.ReqFriend))
for k, v := range c.ReqFriend { for k, v := range c.ReqFriend {
if v.EndTime < Now { if v.EndTime < now {
delete(c.ReqFriend, k) delete(c.ReqFriend, k)
continue continue
} }
@ -233,7 +233,7 @@ func (c *CardMod) cleanExpired() (reqUid, exUid []int64) {
} }
exUid = make([]int64, 0, len(c.ExCard)) exUid = make([]int64, 0, len(c.ExCard))
for k, v := range c.ExCard { for k, v := range c.ExCard {
if v.EndTime < Now { if v.EndTime < now {
delete(c.ExCard, k) delete(c.ExCard, k)
continue continue
} }
@ -251,7 +251,7 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
} }
cardList = append(cardList, &msg.Card{Id: int32(k), Count: int32(v)}) cardList = append(cardList, &msg.Card{Id: int32(k), Count: int32(v)})
} }
ReqUid, ExUid := c.cleanExpired() reqUid, exUid := c.cleanExpired()
if c.EndTime < GoUtil.Now() { if c.EndTime < GoUtil.Now() {
log.Debug("CardMod BackData EndTime < Now, reset card data") log.Debug("CardMod BackData EndTime < Now, reset card data")
@ -265,8 +265,8 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
ExTimes: int32(c.ExTimes), ExTimes: int32(c.ExTimes),
ReqTimes: int32(c.ReqTimes), ReqTimes: int32(c.ReqTimes),
AllCard: GoUtil.MapIntToInt32(c.AllCard), AllCard: GoUtil.MapIntToInt32(c.AllCard),
ReqUid: ReqUid, ReqUid: reqUid,
ExUid: ExUid, ExUid: exUid,
Round: int32(c.Round), Round: int32(c.Round),
Handbook: GoUtil.MapIntToInt32(c.Handbook), Handbook: GoUtil.MapIntToInt32(c.Handbook),
SeasonFirst: c.SeasonFirst, SeasonFirst: c.SeasonFirst,
@ -274,35 +274,35 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
} }
// 领取卡牌收集奖励 // 领取卡牌收集奖励
func (c *CardMod) GetCollectReward(Id int) ([]*item.Item, int, error) { func (c *CardMod) GetCollectReward(id int) ([]*item.Item, int, error) {
_, ok := c.CollectReward[Id] _, ok := c.CollectReward[id]
if ok { 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 { for _, v := range cardList {
count, ok := c.CardList[v] count, ok := c.CardList[v]
if !ok || count <= 0 { 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{}{} c.CollectReward[id] = struct{}{}
Item, Chess := cardCfg.GetCollectReward(Id) Item, Chess := cardCfg.GetCollectReward(id)
return Item, Chess, nil return Item, Chess, nil
} }
// 兑换星星奖励 // 兑换星星奖励
func (c *CardMod) ExStarReward(Id int) ([]*item.Item, int, error) { func (c *CardMod) ExStarReward(id int) ([]*item.Item, int, error) {
if c.ExchangeStar < Id { if c.ExchangeStar < id {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", Id) return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", id)
} }
CostStar, itemList := cardCfg.GetExchangeCfg(Id) costStar, items := cardCfg.GetExchangeCfg(id)
if c.ExchangeStar < CostStar { if c.ExchangeStar < costStar {
return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", Id) return nil, 0, fmt.Errorf("ExStarReward star not enough, Id: %d", id)
} }
c.ExchangeStar -= CostStar c.ExchangeStar -= costStar
c.Cache.ExStar -= CostStar c.Cache.ExStar -= costStar
return itemList, CostStar, nil return items, costStar, nil
} }
// 领取全收集奖励 // 领取全收集奖励
@ -310,8 +310,8 @@ func (c *CardMod) AllCollectReward() ([]*item.Item, []*item.Item, error) {
if c.AllCollect == 1 { if c.AllCollect == 1 {
return nil, nil, fmt.Errorf("AllCollectReward already collect") return nil, nil, fmt.Errorf("AllCollectReward already collect")
} }
AllCardId := cardCfg.GetAllCardId(c.Round) allCardId := cardCfg.GetAllCardId(c.Round)
for _, v := range AllCardId { for _, v := range allCardId {
count, ok := c.CardList[v] count, ok := c.CardList[v]
if !ok || count <= 0 { if !ok || count <= 0 {
return nil, nil, fmt.Errorf("card not fully collect for all collect reward, card id : %d", v) 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.AllCollect = 0
c.CollectReward = make(map[int]struct{}) c.CollectReward = make(map[int]struct{})
ExStar := 0 exStar := 0
for k, v := range c.CardList { for k, v := range c.CardList {
star := cardCfg.GetStarById(k) star := cardCfg.GetStarById(k)
ExStar += star * (v - 1) exStar += star * (v - 1)
c.CardList[k] = v - 1 c.CardList[k] = v - 1
} }
c.CardList = make(map[int]int) c.CardList = make(map[int]int)
c.ExchangeStar += ExStar c.ExchangeStar += exStar
c.Cache.ExStar += ExStar c.Cache.ExStar += exStar
Item := cardCfg.GetAllCollectReward() items := cardCfg.GetAllCollectReward()
HandbookItemNum := 0 handbookItemNum := 0
for k, v := range c.Handbook { for k, v := range c.Handbook {
if v == HANDBOOK_STATUS_GET { if v == HANDBOOK_STATUS_GET {
continue continue
} }
HandbookItemNum += cardCfg.GetStarById(k) handbookItemNum += cardCfg.GetStarById(k)
} }
c.Round++ c.Round++
c.Handbook = make(map[int]int) 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() { func (c *CardMod) ResetCardFestival() {
@ -353,8 +353,8 @@ func (c *CardMod) CreateCardFestival() {
c.CardLimit = true c.CardLimit = true
} }
func (c *CardMod) GetCardNum(Card int) int { func (c *CardMod) GetCardNum(card int) int {
return c.CardList[Card] return c.CardList[card]
} }
func (c *CardMod) SubCard(id int) error { func (c *CardMod) SubCard(id int) error {
@ -376,19 +376,19 @@ func (c *CardMod) RequestCard() error {
} }
// 增加请求卡牌记录 // 增加请求卡牌记录
func (c *CardMod) AddRequestCard(CardInfo *CardInfo) error { func (c *CardMod) AddRequestCard(cardInfo *CardInfo) error {
_, ok := c.ReqFriend[CardInfo.BUid] _, ok := c.ReqFriend[cardInfo.BUid]
if ok { 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 return nil
} }
func (c *CardMod) DelRequestCard(Uid int) (map[int]*CardInfo, error) { func (c *CardMod) DelRequestCard(uid int) (map[int]*CardInfo, error) {
ci, ok := c.ReqFriend[Uid] ci, ok := c.ReqFriend[uid]
if !ok { 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) r := make(map[int]*CardInfo)
for k, v := range c.ReqFriend { for k, v := range c.ReqFriend {
@ -397,106 +397,106 @@ func (c *CardMod) DelRequestCard(Uid int) (map[int]*CardInfo, error) {
continue continue
} }
} }
delete(c.ReqFriend, Uid) delete(c.ReqFriend, uid)
return r, nil return r, nil
} }
func (c *CardMod) AddReqTimes(Id string, Time int64) { func (c *CardMod) AddReqTimes(id string, time int64) {
n := 0 n := 0
for _, v := range c.ReqFriend { for _, v := range c.ReqFriend {
if v.Id == Id { if v.Id == id {
n++ n++
} }
} }
Zero := GoUtil.ZeroTime(Time) zero := GoUtil.ZeroTime(time)
ZeroTime := GoUtil.ZeroTimestamp() zeroTime := GoUtil.ZeroTimestamp()
if n == 0 && Zero == ZeroTime { if n == 0 && zero == zeroTime {
c.ReqTimes = min(cardCfg.GetReqTimes(), c.ReqTimes+1) c.ReqTimes = min(cardCfg.GetReqTimes(), c.ReqTimes+1)
} }
} }
func (c *CardMod) AddExTimes(CardInfo *CardInfo) { func (c *CardMod) AddExTimes(cardInfo *CardInfo) {
Zero := GoUtil.ZeroTime(CardInfo.StartTime) zero := GoUtil.ZeroTime(cardInfo.StartTime)
ZeroTime := GoUtil.ZeroTimestamp() zeroTime := GoUtil.ZeroTimestamp()
if Zero == ZeroTime { if zero == zeroTime {
c.ExTimes++ c.ExTimes++
c.ExTimes = min(cardCfg.GetExTimes(), c.ExTimes) c.ExTimes = min(cardCfg.GetExTimes(), c.ExTimes)
} }
if cardCfg.CheckCardIsGold(CardInfo.CardId) { if cardCfg.CheckCardIsGold(cardInfo.CardId) {
c.GoldTimes-- 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 { 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 { if err != nil {
return nil, err return nil, err
} }
c.ExTimes-- c.ExTimes--
Now := GoUtil.Now() now := GoUtil.Now()
Id := GoUtil.CreateCardId(From, To, CardId) id := GoUtil.CreateCardId(from, to, cardId)
CardInfo := &CardInfo{ CardInfo := &CardInfo{
Id: Id, Id: id,
AUid: From, AUid: from,
BUid: To, BUid: to,
CardId: CardId, CardId: cardId,
Type: TYPE_CARD_EX, Type: TYPE_CARD_EX,
Status: STATUS_CARD_EX_1, Status: STATUS_CARD_EX_1,
StartTime: Now, StartTime: now,
EndTime: Now + 86400, EndTime: now + 86400,
} }
c.ExCard[To] = CardInfo c.ExCard[to] = CardInfo
return CardInfo, nil 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 { 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 { if err != nil {
return nil, err return nil, err
} }
c.ExTimes-- c.ExTimes--
Now := GoUtil.Now() now := GoUtil.Now()
Id := GoUtil.CreateCardId(From, To, CardId) id := GoUtil.CreateCardId(from, to, cardId)
CardInfo := &CardInfo{ CardInfo := &CardInfo{
Id: Id, Id: id,
AUid: From, AUid: from,
BUid: To, BUid: to,
CardId: CardId, CardId: cardId,
Type: TYPE_CARD_SEND, Type: TYPE_CARD_SEND,
StartTime: Now, StartTime: now,
Status: STATUS_CARD_SEND_1, Status: STATUS_CARD_SEND_1,
} }
return CardInfo, nil return CardInfo, nil
} }
func (c *CardMod) DelExCard(CardInfo *CardInfo) { func (c *CardMod) DelExCard(cardInfo *CardInfo) {
delete(c.ExCard, CardInfo.BUid) delete(c.ExCard, cardInfo.BUid)
} }
func (c *CardMod) AddMasterCard(Id int) { func (c *CardMod) AddMasterCard(id int) {
c.Cache.Master[Id]++ c.Cache.Master[id]++
c.AllCard[Id]++ c.AllCard[id]++
} }
func (c *CardMod) MasterCardEx(Id, CardId int) error { func (c *CardMod) MasterCardEx(id, cardId int) error {
if c.AllCard[Id] <= 0 { if c.AllCard[id] <= 0 {
return fmt.Errorf("MasterCardEx card not enough, Id: %d", Id) return fmt.Errorf("MasterCardEx card not enough, Id: %d", id)
} }
if Id == MASTER_CARD_NORMAL && cardCfg.CheckCardIsGold(CardId) { if id == MASTER_CARD_NORMAL && cardCfg.CheckCardIsGold(cardId) {
return fmt.Errorf("MasterCardEx card type err, Id: %d, CardId: %d", Id, CardId) return fmt.Errorf("MasterCardEx card type err, Id: %d, CardId: %d", id, cardId)
} }
c.AllCard[Id]-- c.AllCard[id]--
c.Cache.Master[Id]-- c.Cache.Master[id]--
c.AddCard(CardId) c.AddCard(cardId)
return nil return nil
} }
@ -517,12 +517,12 @@ func (c *CardMod) NotifyCard() *msg.ResNotifyCard {
} }
func (c *CardMod) NotifyTimes() *msg.ResNotifyCardTimes { func (c *CardMod) NotifyTimes() *msg.ResNotifyCardTimes {
ReqUid, ExUid := c.cleanExpired() reqUid, exUid := c.cleanExpired()
return &msg.ResNotifyCardTimes{ return &msg.ResNotifyCardTimes{
ExTimes: int32(c.ExTimes), ExTimes: int32(c.ExTimes),
ReqTimes: int32(c.ReqTimes), ReqTimes: int32(c.ReqTimes),
ExUid: ExUid, ExUid: exUid,
ReqUid: ReqUid, ReqUid: reqUid,
GoldTimes: int32(c.GoldTimes), GoldTimes: int32(c.GoldTimes),
} }
} }
@ -551,21 +551,21 @@ func (c *CardMod) AddGoldTimes() {
c.GoldTimes = min(2, c.GoldTimes) c.GoldTimes = min(2, c.GoldTimes)
} }
func (c *CardMod) GetHandbookReward(CardId int) ([]*item.Item, error) { func (c *CardMod) GetHandbookReward(cardId int) ([]*item.Item, error) {
if v, ok := c.Handbook[CardId]; ok { if v, ok := c.Handbook[cardId]; ok {
if v == HANDBOOK_STATUS_GET { 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) star := cardCfg.GetStarById(cardId)
c.Handbook[CardId] = HANDBOOK_STATUS_GET c.Handbook[cardId] = HANDBOOK_STATUS_GET
c.Cache.Handbook[CardId] = HANDBOOK_STATUS_GET c.Cache.Handbook[cardId] = HANDBOOK_STATUS_GET
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, Star)}, nil 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 { func (c *CardMod) RandCard(star int) int {
return randCard(c.Round, Star, 0, []int{}) return randCard(c.Round, star, 0, []int{})
} }
func (c *CardMod) SeasonFirstReward() ([]*item.Item, error) { 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 { func randCard(round, star, isGold int, except []int) int {
cardList := cardCfg.GetCardListByStar(Round, Star, IsGold) cardList := cardCfg.GetCardListByStar(round, star, isGold)
cardList = GoUtil.SubSlices(cardList, Except) cardList = GoUtil.SubSlices(cardList, except)
cardId := GoUtil.RandSlice(cardList) cardId := GoUtil.RandSlice(cardList)
return cardId return cardId
} }
// 排位赛金卡 // 排位赛金卡
func RankGoldCard() (int, int) { func RankGoldCard() (int, int) {
Card1 := randCard(0, 4, 1, []int{}) card1 := randCard(0, 4, 1, []int{})
Card2 := randCard(0, 5, 1, []int{Card1}) card2 := randCard(0, 5, 1, []int{card1})
return Card1, Card2 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) { func (c *CatnipMod) Login(id int) (int, []*item.Item) {
OldId := c.Id oldId := c.Id
if Id == 0 { if id == 0 {
c.Id = 0 c.Id = 0
return OldId, nil return oldId, nil
} }
if c.Id == Id { if c.Id == id {
return 0, nil return 0, nil
} }
Items := c.GetUnGetReward() items := c.GetUnGetReward()
c.Id = Id c.Id = id
c.IsGetGrandReward = false // Reset grand reward status on login c.IsGetGrandReward = false // Reset grand reward status on login
c.Game = make(map[int]*CatnipGame) c.Game = make(map[int]*CatnipGame)
c.Mul = 1 // Default multiplier 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.InviteList = make(map[int]*InviteInfo)
c.BeInvitedList = 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{ c.Game[i] = &CatnipGame{
Id: i, Id: i,
Partner: 0, // No partner initially Partner: 0, // No partner initially
@ -76,50 +76,50 @@ func (c *CatnipMod) Login(Id int) (int, []*item.Item) {
Status: GAME_STATUS_IDLE, // Not started Status: GAME_STATUS_IDLE, // Not started
} }
} }
return OldId, Items return oldId, items
} }
func (c *CatnipMod) ZeroUpdate(Id int) { func (c *CatnipMod) ZeroUpdate(id int) {
c.Login(Id) c.Login(id)
} }
// 邀请好友 // 邀请好友
func (c *CatnipMod) Invite(Uid, Id int) error { func (c *CatnipMod) Invite(uid, id int) error {
if c.InviteList[Uid] != nil { if c.InviteList[uid] != nil {
return fmt.Errorf("user with ID %d is already invited", Uid) return fmt.Errorf("user with ID %d is already invited", uid)
} }
c.InviteList[Uid] = &InviteInfo{ c.InviteList[uid] = &InviteInfo{
InviteId: Id, InviteId: id,
Time: GoUtil.Now(), Time: GoUtil.Now(),
} }
return nil 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 // Check if the user is already invited
invite := c.BeInvitedList[Uid] invite := c.BeInvitedList[uid]
if invite != nil { 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{ c.BeInvitedList[uid] = &InviteInfo{
InviteId: Uid, InviteId: uid,
Time: Time, Time: time,
} }
return nil return nil
} }
// 同意邀请 // 同意邀请
func (c *CatnipMod) Agree(Id, Uid int) ([]int, error) { func (c *CatnipMod) Agree(id, uid int) ([]int, error) {
_, exists := c.BeInvitedList[Uid] _, exists := c.BeInvitedList[uid]
if !exists { 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 { for _, GameInfo := range c.Game {
if GameInfo.Partner == 0 { if GameInfo.Partner == 0 {
GameInfo.Partner = Uid GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil 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) { func (c *CatnipMod) BeAgree(id, uid int) ([]int, error) {
info, exists := c.InviteList[Uid] info, exists := c.InviteList[uid]
if !exists { 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] GameInfo := c.Game[info.InviteId]
if GameInfo.Partner == 0 { if GameInfo.Partner == 0 {
GameInfo.Partner = Uid GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil return nil, nil
} }
// 目标格子已有伙伴，分配到第一个空闲格 // 目标格子已有伙伴，分配到第一个空闲格
for _, GameInfo := range c.Game { for _, GameInfo := range c.Game {
if GameInfo.Partner == 0 { if GameInfo.Partner == 0 {
GameInfo.Partner = Uid GameInfo.Partner = uid
GameInfo.Status = GAME_STATUS_IN_PROGRESS GameInfo.Status = GAME_STATUS_IN_PROGRESS
return nil, nil return nil, nil
} }
@ -152,58 +152,58 @@ func (c *CatnipMod) BeAgree(Id, Uid int) ([]int, error) {
} }
// 删除邀请 // 删除邀请
func (c *CatnipMod) DelInvited(Id, Uid int) error { func (c *CatnipMod) DelInvited(id, uid int) error {
delete(c.InviteList, Uid) delete(c.InviteList, uid)
return nil return nil
} }
// 设置倍数 // 设置倍数
func (c *CatnipMod) Multiply(Mul int) error { func (c *CatnipMod) Multiply(mul int) error {
c.Mul = Mul c.Mul = mul
return nil return nil
} }
// 拒绝邀请 // 拒绝邀请
func (c *CatnipMod) Refuse(Id, Uid int) error { func (c *CatnipMod) Refuse(id, uid int) error {
delete(c.BeInvitedList, Uid) delete(c.BeInvitedList, uid)
return nil return nil
} }
// 玩游戏 // 玩游戏
func (c *CatnipMod) Play(Id int) (int, int, int, []*item.Item, []*item.Item, int, error) { func (c *CatnipMod) Play(id int) (int, int, int, []*item.Item, []*item.Item, int, error) {
GameInfo, ok := c.Game[Id] gameInfo, ok := c.Game[id]
if !ok { 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 { 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) 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) id, items, growth, friendItems := catnipCfg.GetJackpotItem(c.Mul)
Growth = Growth * c.Mul growth = growth * c.Mul
if Growth > 0 { if growth > 0 {
c.Growth(Id, Growth) c.Growth(id, growth)
} }
ItemCost := catnipCfg.GetItemCost(c.Id, c.Mul) ItemCost := catnipCfg.GetItemCost(c.Id, c.Mul)
GameInfo.Progress += Growth gameInfo.Progress += growth
return Id, Growth, GameInfo.Partner, Items, ItemCost, FriendItems, nil return id, growth, gameInfo.Partner, items, ItemCost, friendItems, nil
} }
// 领取奖励 // 领取奖励
func (c *CatnipMod) Reward(Id int) ([]*item.Item, *CatnipGame, error) { func (c *CatnipMod) Reward(id int) ([]*item.Item, *CatnipGame, error) {
GameInfo, ok := c.Game[Id] gameInfo, ok := c.Game[id]
if !ok { 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) items, ids := catnipCfg.GetProgressReward(c.Id, gameInfo.Reward, gameInfo.Progress)
ProgressNum := catnipCfg.GetProgressNum(c.Id) progressNum := catnipCfg.GetProgressNum(c.Id)
GameInfo.Reward = append(GameInfo.Reward, Ids...) gameInfo.Reward = append(gameInfo.Reward, ids...)
if len(GameInfo.Reward) == ProgressNum { if len(gameInfo.Reward) == progressNum {
GameInfo.Status = GAME_STATUS_COMPLETED gameInfo.Status = GAME_STATUS_COMPLETED
} }
if Items == nil { if items == nil {
return nil, nil, fmt.Errorf("no reward found for progress %d in game ID %d", GameInfo.Progress, Id) 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) { func (c *CatnipMod) Growth(id, growth int) {
GameInfo, ok := c.Game[Id] gameInfo, ok := c.Game[id]
if !ok { if !ok {
return // Game does not exist 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 return // Game is not in progress
} }
GameInfo.Progress += Growth gameInfo.Progress += growth
if GameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) { if gameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
GameInfo.Status = GAME_STATUS_COMPLETED gameInfo.Status = GAME_STATUS_COMPLETED
} }
} }
// 伙伴贡献增加 // 伙伴贡献增加
func (c *CatnipMod) GrowthByUid(Uid, Growth int) { func (c *CatnipMod) GrowthByUid(uid, growth int) {
for _, v := range c.Game { for _, v := range c.Game {
if v.Partner == Uid { if v.Partner == uid {
v.Progress += Growth v.Progress += growth
v.PartnerAdd += Growth v.PartnerAdd += growth
if v.Progress >= catnipCfg.GetGameMaxProgress(c.Id) { if v.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
v.Status = GAME_STATUS_COMPLETED 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 { for _, v := range c.Game {
if v.Partner == Uid { if v.Partner == uid {
v.EmojiId = EmojiId v.EmojiId = emojiId
return return
} }
} }
@ -263,24 +263,24 @@ func (c *CatnipMod) GetMultiple() int {
return c.Mul return c.Mul
} }
func (c *CatnipMod) GetGameInfo(Id int) *CatnipGame { func (c *CatnipMod) GetGameInfo(id int) *CatnipGame {
return c.Game[Id] return c.Game[id]
} }
func (c *CatnipMod) SetSendEmoji(Id, EmojiId int) { func (c *CatnipMod) SetSendEmoji(id, emojiId int) {
c.Game[Id].SendEmoji = EmojiId c.Game[id].SendEmoji = emojiId
} }
// 获取未领取的奖励 // 获取未领取的奖励
func (c *CatnipMod) GetUnGetReward() []*item.Item { func (c *CatnipMod) GetUnGetReward() []*item.Item {
var rewards []*item.Item var rewards []*item.Item
for _, v := range c.Game { for _, v := range c.Game {
Items, _, _ := c.Reward(v.Id) items, _, _ := c.Reward(v.Id)
rewards = append(rewards, Items...) rewards = append(rewards, items...)
} }
BigReward, err := c.GrandReward() bigReward, err := c.GrandReward()
if err == nil { if err == nil {
rewards = append(rewards, BigReward...) rewards = append(rewards, bigReward...)
} }
return rewards 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 return champshipCfg.GetRankReward(Rank, yesterdayActivityId), nil
} }
func (c *ChampshipMod) AddScore(Chess []int) { func (c *ChampshipMod) AddScore(chess []int) {
if !c.isActive() { if !c.isActive() {
return return
} }
score := 0 score := 0
for _, v := range Chess { for _, v := range chess {
Lv := mergeDataCfg.GetLvById(v) Lv := mergeDataCfg.GetLvById(v)
ChessScore := champshipCfg.GetChessScore(Lv) ChessScore := champshipCfg.GetChessScore(Lv)
score += ChessScore score += ChessScore
@ -57,17 +57,17 @@ func (c *ChampshipMod) AddScore(Chess []int) {
} }
func (c *ChampshipMod) GetReward(activityId, orderFactor int) []*item.Item { func (c *ChampshipMod) GetReward(activityId, orderFactor int) []*item.Item {
Reward, Items := champshipCfg.GetReward(c.Reward, c.Score, activityId, orderFactor) reward, items := champshipCfg.GetReward(c.Reward, c.Score, activityId, orderFactor)
c.Reward = Reward c.Reward = reward
c.Max = max(c.Max, c.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 rankReward := 0
if c.RankReward { if c.RankReward {
rankReward = 2 rankReward = 2
} else if MyPreRank > 0 { } else if myPreRank > 0 {
rankReward = 1 rankReward = 1
} }
status := 0 status := 0
@ -79,7 +79,7 @@ func (c *ChampshipMod) BackData(MyRank, MyPreRank, todayActivityId, yesterdayAct
Reward: int32(c.Reward), Reward: int32(c.Reward),
EndTime: int32(GoUtil.ZeroTimestamp() + 86400), EndTime: int32(GoUtil.ZeroTimestamp() + 86400),
Period: int32(GoUtil.GetServerOpenDay()), Period: int32(GoUtil.GetServerOpenDay()),
Rank: int32(MyRank), Rank: int32(myRank),
RankReward: int32(rankReward), RankReward: int32(rankReward),
Status: int32(status), Status: int32(status),
TodayActivityId: int32(todayActivityId), 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 return c.MaxCharge
} }
func (c *ChargeMod) Login(LogoutTime int64) { func (c *ChargeMod) Login(logoutTime int64) {
c.LastWorkTime = min(LogoutTime, c.PetWorkTime) c.LastWorkTime = min(logoutTime, c.PetWorkTime)
c.PetWorkTime -= c.LastWorkTime c.PetWorkTime -= c.LastWorkTime
} }
@ -125,147 +125,147 @@ func (c *ChargeMod) resetSpecialChargeIfExpired(now int64) {
} }
// 零点更新 // 零点更新
func (c *ChargeMod) ZeroUpdate(Emit []int) { func (c *ChargeMod) ZeroUpdate(emit []int) {
Now := GoUtil.Now() now := GoUtil.Now()
c.resetSpecialChargeIfExpired(Now) c.resetSpecialChargeIfExpired(now)
if GoUtil.IsFirstDayOfMonth() { if GoUtil.IsFirstDayOfMonth() {
c.MonthCharge = 0 c.MonthCharge = 0
} }
c.FreeShop = 0 c.FreeShop = 0
SpecialGrade := 1 specialGrade := 1
c.TodayCharge = 0 c.TodayCharge = 0
c.AdWatch = 0 c.AdWatch = 0
c.SpecialShop = make(map[int]*SepcialShop) c.SpecialShop = make(map[int]*SepcialShop)
SpecialShopCount := chargeCfg.GetSpecialShopCount() specialShopCount := chargeCfg.GetSpecialShopCount()
for i := 1; i <= 2; i++ { for i := 1; i <= 2; i++ {
if c.Total == 0 { if c.Total == 0 {
c.SpecialShop[i] = &SepcialShop{Grade: SpecialGrade, Count: 1} c.SpecialShop[i] = &SepcialShop{Grade: specialGrade, Count: 1}
continue continue
} }
m := c.SpecialCharge m := c.SpecialCharge
M := chargeCfg.GetSpecialShopGrade(m, i) M := chargeCfg.GetSpecialShopGrade(m, i)
a := min(2, GoUtil.FullWeeksSince(c.LastSpecialCharge)) a := min(2, GoUtil.FullWeeksSince(c.LastSpecialCharge))
SpecialGrade = max(1, M-a) specialGrade = max(1, M-a)
c.SpecialShop[i] = &SepcialShop{Grade: SpecialGrade, Count: SpecialShopCount} c.SpecialShop[i] = &SepcialShop{Grade: specialGrade, Count: specialShopCount}
} }
if c.WishList != nil { if c.WishList != nil {
c.WishList.SendList = nil c.WishList.SendList = nil
} }
if c.IsWeeklyDiscountDay() && c.WeeklyEndTime < Now { if c.IsWeeklyDiscountDay() && c.WeeklyEndTime < now {
c.WeeklyDiscount = make(map[int]int) c.WeeklyDiscount = make(map[int]int)
c.WeeklyEndTime = GoUtil.ZeroTimestamp() + secondsIn7Days c.WeeklyEndTime = GoUtil.ZeroTimestamp() + secondsIn7Days
} }
c.InitChessShop(Emit) c.InitChessShop(emit)
} }
// 十二点更新 重置商店 // 十二点更新 重置商店
func (c *ChargeMod) NoonUpdate(Emit []int) { func (c *ChargeMod) NoonUpdate(emit []int) {
c.InitChessShop(Emit) c.InitChessShop(emit)
} }
func (c *ChargeMod) FixBug(Emit []int) { func (c *ChargeMod) FixBug(emit []int) {
if len(c.ChessShop) < 5 { if len(c.ChessShop) < 5 {
c.InitChessShop(Emit) c.InitChessShop(emit)
} }
} }
// 充值 // 充值
func (c *ChargeMod) Fire(ChargeId int) (Item []*item.Item) { func (c *ChargeMod) Fire(chargeId int) (Item []*item.Item) {
Money := chargeCfg.GetMoneyCharge(ChargeId) money := chargeCfg.GetMoneyCharge(chargeId)
if Money == 0 { if money == 0 {
return return
} }
c.Charge += Money c.Charge += money
c.TodayCharge += Money c.TodayCharge += money
c.MonthCharge += Money c.MonthCharge += money
c.Total++ c.Total++
Now := GoUtil.Now() now := GoUtil.Now()
if c.FirstCharge == 0 { if c.FirstCharge == 0 {
c.FirstCharge = Now c.FirstCharge = now
} }
c.resetSpecialChargeIfExpired(Now) c.resetSpecialChargeIfExpired(now)
c.LastCharge = Now c.LastCharge = now
if Money > c.MaxCharge { if money > c.MaxCharge {
c.MaxCharge = Money c.MaxCharge = money
} }
if Money > c.SpecialCharge { if money > c.SpecialCharge {
c.LastSpecialCharge = Now c.LastSpecialCharge = now
c.SpecialCharge = Money c.SpecialCharge = money
} }
Item = c.FireDiamondShop(ChargeId) Item = c.FireDiamondShop(chargeId)
if Item != nil { if Item != nil {
return return
} }
Item = c.FireEnergyShop(ChargeId) Item = c.FireEnergyShop(chargeId)
if Item != nil { if Item != nil {
return return
} }
Item = c.FireSpecialShop(ChargeId) Item = c.FireSpecialShop(chargeId)
if Item != nil { if Item != nil {
return return
} }
Item = c.FirePetCoinShop(ChargeId) Item = c.FirePetCoinShop(chargeId)
if Item != nil { if Item != nil {
return return
} }
Item = c.FireGift(ChargeId) Item = c.FireGift(chargeId)
c.FireAd(ChargeId) c.FireAd(chargeId)
return return
} }
// 钻石商店 // 钻石商店
func (c *ChargeMod) FireDiamondShop(ChargeId int) []*item.Item { func (c *ChargeMod) FireDiamondShop(chargeId int) []*item.Item {
return chargeCfg.GetDiamondShopReward(ChargeId) return chargeCfg.GetDiamondShopReward(chargeId)
} }
// 宠物币商店 // 宠物币商店
func (c *ChargeMod) FirePetCoinShop(ChargeId int) []*item.Item { func (c *ChargeMod) FirePetCoinShop(chargeId int) []*item.Item {
return chargeCfg.GetPetCoinShopReward(ChargeId) return chargeCfg.GetPetCoinShopReward(chargeId)
} }
// 能量商店 // 能量商店
func (c *ChargeMod) FireEnergyShop(ChargeId int) []*item.Item { func (c *ChargeMod) FireEnergyShop(chargeId int) []*item.Item {
id := chargeCfg.GetEnergyShopId(ChargeId) id := chargeCfg.GetEnergyShopId(chargeId)
_, ok := c.EnergyShop[id] _, ok := c.EnergyShop[id]
c.EnergyShop[id] = struct{}{} c.EnergyShop[id] = struct{}{}
return chargeCfg.GetEnergyShopReward(ChargeId, ok) return chargeCfg.GetEnergyShopReward(chargeId, ok)
} }
// 特惠礼包 // 特惠礼包
func (c *ChargeMod) FireSpecialShop(ChargeId int) []*item.Item { func (c *ChargeMod) FireSpecialShop(chargeId int) []*item.Item {
Type := chargeCfg.GetSpecialShopType(ChargeId) cType := chargeCfg.GetSpecialShopType(chargeId)
if _, ok := c.SpecialShop[Type]; !ok { if _, ok := c.SpecialShop[cType]; !ok {
return nil return nil
} }
if c.SpecialShop[Type].Count < 1 { if c.SpecialShop[cType].Count < 1 {
log.Debug("special shop recharge max, type: %d, charge id: %d", Type, ChargeId) log.Debug("special shop recharge max, type: %d, charge id: %d", cType, chargeId)
return nil return nil
} }
c.SpecialShop[Type].Count-- c.SpecialShop[cType].Count--
return chargeCfg.GetSpecialShopReward(ChargeId) return chargeCfg.GetSpecialShopReward(chargeId)
} }
// 通用礼包 // 通用礼包
func (c *ChargeMod) FireGift(ChargeId int) []*item.Item { func (c *ChargeMod) FireGift(chargeId int) []*item.Item {
Limit := chargeCfg.GetGiftLimit(ChargeId) limit := chargeCfg.GetGiftLimit(chargeId)
if Limit == 0 { if limit == 0 {
return nil return nil
} }
Id := chargeCfg.GetGiftId(ChargeId) id := chargeCfg.GetGiftId(chargeId)
if v, ok := c.Gift[Id]; ok { if v, ok := c.Gift[id]; ok {
if v >= Limit { if v >= limit {
return nil return nil
} }
} }
c.Gift[Id]++ c.Gift[id]++
return chargeCfg.GetGiftReward(ChargeId) return chargeCfg.GetGiftReward(chargeId)
} }
// 免广告礼包 // 免广告礼包
func (c *ChargeMod) FireAd(ChargeId int) []*item.Item { func (c *ChargeMod) FireAd(chargeId int) []*item.Item {
AdChargeId := chargeCfg.GetAdChargeId() adChargeId := chargeCfg.GetAdChargeId()
if ChargeId != AdChargeId { if chargeId != adChargeId {
return nil return nil
} }
c.Ad = true c.Ad = true
@ -273,30 +273,30 @@ func (c *ChargeMod) FireAd(ChargeId int) []*item.Item {
} }
// 免广告礼包 // 免广告礼包
func (c *ChargeMod) FireAdReward(ChargeId int) []*item.Item { func (c *ChargeMod) FireAdReward(chargeId int) []*item.Item {
Items, PetWorkDay := chargeCfg.GetADReward(ChargeId) items, petWorkDay := chargeCfg.GetADReward(chargeId)
if PetWorkDay != 0 { if petWorkDay != 0 {
Now := GoUtil.Now() now := GoUtil.Now()
if c.AdEndTime < Now { if c.AdEndTime < now {
c.AdEndTime = Now + int64(PetWorkDay*secondsIn1Day) c.AdEndTime = now + int64(petWorkDay*secondsIn1Day)
} else { } else {
c.AdEndTime += int64(PetWorkDay * secondsIn1Day) c.AdEndTime += int64(petWorkDay * secondsIn1Day)
} }
c.PetWorkTime += int64(PetWorkDay * secondsIn1Day) c.PetWorkTime += int64(petWorkDay * secondsIn1Day)
c.Ad = true c.Ad = true
} }
return Items return items
} }
func (c *ChargeMod) AddAdTime(PetWorkDay int) { func (c *ChargeMod) AddAdTime(petWorkDay int) {
if PetWorkDay > 0 { if petWorkDay > 0 {
Now := GoUtil.Now() now := GoUtil.Now()
if c.AdEndTime < Now { if c.AdEndTime < now {
c.AdEndTime = Now + int64(PetWorkDay*secondsIn1Day) c.AdEndTime = now + int64(petWorkDay*secondsIn1Day)
} else { } else {
c.AdEndTime += int64(PetWorkDay * secondsIn1Day) c.AdEndTime += int64(petWorkDay * secondsIn1Day)
} }
c.PetWorkTime += int64(PetWorkDay * secondsIn1Day) c.PetWorkTime += int64(petWorkDay * secondsIn1Day)
c.Ad = true c.Ad = true
} }
} }
@ -323,53 +323,51 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
return return
} }
c.ChessShop = make(map[int]*ChessShop) c.ChessShop = make(map[int]*ChessShop)
//ColorList := make([]string, 0) randList := make([]*Rand, 0)
RandList := make([]*Rand, 0)
for _, v := range Emit { for _, v := range Emit {
ProduceList := mergeDataCfg.GetEmitProduceType(v) produceList := mergeDataCfg.GetEmitProduceType(v)
for _, p := range ProduceList { for _, p := range produceList {
ChessList := order.GetChessByDiff(v, 1, order.DIFF_MID, p) chessList := order.GetChessByDiff(v, 1, order.DIFF_MID, p)
if len(ChessList) == 1 { if len(chessList) == 1 {
ChessList = append(ChessList, ChessList[0]-1) chessList = append(chessList, chessList[0]-1)
} }
for _, c := range ChessList { for _, c := range chessList {
if c == 0 { if c == 0 {
continue continue
} }
ChessLv := mergeDataCfg.GetLvById(c) chessLv := mergeDataCfg.GetLvById(c)
DynamicLv := mergeDataCfg.GetAdjust(v, p, 0) dynamicLv := mergeDataCfg.GetAdjust(v, p, 0)
ChessLv += DynamicLv chessLv += dynamicLv
Diamond := math.Round(math.Pow(2, float64(ChessLv-1)) / 5) diamond := math.Round(math.Pow(2, float64(chessLv-1)) / 5)
Diamond = max(1, Diamond) diamond = max(1, diamond)
RandList = append(RandList, &Rand{ChessId: c, Diamond: int(Diamond)}) randList = append(randList, &Rand{ChessId: c, Diamond: int(diamond)})
} }
} }
} }
randList := make([]interface{}, len(RandList)) randList2 := make([]interface{}, len(randList))
for k, v := range RandList { for k, v := range randList {
randList[k] = v randList2[k] = v
} }
L := GoUtil.RandSliceNum2(randList, 5) newList := GoUtil.RandSliceNum2(randList2, 5)
for k, v := range L { for k, v := range newList {
Diamond := v.(*Rand).Diamond diamond := v.(*Rand).Diamond
ChessId := v.(*Rand).ChessId chessId := v.(*Rand).ChessId
if ChessId == 0 { if chessId == 0 {
continue 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 diamond := 40
if IsWeeklyDiscount { if isWeeklyDiscount {
LimitNum := c.WeeklyDiscount[0] limitNum := c.WeeklyDiscount[0]
Discount, WeeklyLimit := chargeCfg.GetWeeklyInfo(0) discount, weeklyLimit := chargeCfg.GetWeeklyInfo(0)
if LimitNum < WeeklyLimit { if limitNum < weeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(Discount) / 100.0)) diamond = int(math.Ceil(float64(diamond) * float64(discount) / 100.0))
c.WeeklyDiscount[0] = LimitNum + 1 c.WeeklyDiscount[0] = limitNum + 1
} }
} }
return []*item.Item{ 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) { func (c *ChargeMod) BuyChess(chess int, isWeeklyDiscount bool) ([]*item.Item, []*item.Item, int, error) {
v, ok := c.ChessShop[Chess] v, ok := c.ChessShop[chess]
if !ok { 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 { 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-- v.Count--
diamond := v.Diamond diamond := v.Diamond
if IsWeeklyDiscount { if isWeeklyDiscount {
LimitNum := c.WeeklyDiscount[Chess] limitNum := c.WeeklyDiscount[chess]
Discount, WeeklyLimit := chargeCfg.GetWeeklyInfo(Chess) discount, weeklyLimit := chargeCfg.GetWeeklyInfo(chess)
if LimitNum < WeeklyLimit { if limitNum < weeklyLimit {
diamond = int(math.Ceil(float64(diamond) * float64(Discount) / 100)) diamond = int(math.Ceil(float64(diamond) * float64(discount) / 100))
if diamond == v.Diamond { if diamond == v.Diamond {
diamond -= 1 diamond -= 1
} }
diamond = max(1, diamond) diamond = max(1, diamond)
c.WeeklyDiscount[Chess] = LimitNum + 1 c.WeeklyDiscount[chess] = limitNum + 1
} }
} }
return []*item.Item{ 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) { func (c *ChargeMod) TriggerChargeUnlock(lv int, emit []int) {
c.InitChessShop(Emit) c.InitChessShop(emit)
} }
// 添加心愿单 // 添加心愿单
func (c *ChargeMod) AddWish(Id, Type int) ([]*item.Item, error) { func (c *ChargeMod) AddWish(id, wType int) ([]*item.Item, error) {
ItemId := 0 itemId := 0
switch Type { switch wType {
case PLAYROOM_SHOP: case PLAYROOM_SHOP:
ItemId, _, _, _ = playroomCfg.GetShopItem(Id) itemId, _, _, _ = playroomCfg.GetShopItem(id)
} }
if ItemId == 0 { if itemId == 0 {
return nil, fmt.Errorf("AddWish itemid not exist id:%d", Id) 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 != 0 {
if c.WishList.ItemId == ItemId { if c.WishList.ItemId == itemId {
return nil, fmt.Errorf("AddWish itemid already exist id:%d", Id) 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.Count = 0
} }
c.WishList.ItemId = ItemId c.WishList.ItemId = itemId
return Items, nil return items, nil
} }
// 获取心愿单奖励 // 获取心愿单奖励
@ -443,8 +441,8 @@ func (c *ChargeMod) GetWish() ([]*item.Item, error) {
if c.WishList.ItemId == 0 { if c.WishList.ItemId == 0 {
return nil, fmt.Errorf("AddWishCount itemid not exist") return nil, fmt.Errorf("AddWishCount itemid not exist")
} }
Max := chargeCfg.GetWishCount(c.WishList.ItemId) max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count < Max { if c.WishList.Count < max {
return nil, fmt.Errorf("AddWishCount count max") return nil, fmt.Errorf("AddWishCount count max")
} }
rewardItemId := c.WishList.ItemId rewardItemId := c.WishList.ItemId
@ -469,8 +467,8 @@ func (c *ChargeMod) AddWishCount() {
if c.WishList.ItemId == 0 { if c.WishList.ItemId == 0 {
return return
} }
Max := chargeCfg.GetWishCount(c.WishList.ItemId) max := chargeCfg.GetWishCount(c.WishList.ItemId)
if c.WishList.Count >= Max { if c.WishList.Count >= max {
return return
} }
c.WishList.Count++ c.WishList.Count++
@ -478,12 +476,12 @@ func (c *ChargeMod) AddWishCount() {
// 是否在每周折扣日 // 是否在每周折扣日
func (c *ChargeMod) IsWeeklyDiscountDay() bool { func (c *ChargeMod) IsWeeklyDiscountDay() bool {
Day := chargeCfg.GetWeeklyDiscountDay() day := chargeCfg.GetWeeklyDiscountDay()
if Day == -1 { if day == -1 {
return false return false
} }
Weekday, _ := GoUtil.GetWeekdayAndHour() 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 Diamond := 0.0
if Type == 1 { if cType == 1 {
Diamond = 0.27 * math.Exp(float64(Lv)*0.56) Diamond = 0.27 * math.Exp(float64(lv)*0.56)
} else { } else {
Diamond = 2.64 * math.Pow(float64(Lv), 2.43) Diamond = 2.64 * math.Pow(float64(lv), 2.43)
} }
d := int(Diamond) d := int(Diamond)
if d > 10 { 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() { func (cb *ChessBorad) InitData() {
StartMerge := startMergeCfg.GetStartChessList() startMerge := startMergeCfg.GetStartChessList()
cb.EmitList = make(map[int]int) cb.EmitList = make(map[int]int)
cb.ChessList = StartMerge cb.ChessList = startMerge
if cb.ChessBag.List == nil { if cb.ChessBag.List == nil {
cb.ChessBag.List = make(map[int]ChessBagGrid) cb.ChessBag.List = make(map[int]ChessBagGrid)
InitNum := mergeDataCfg.GetChessBagInitNum() InitNum := mergeDataCfg.GetChessBagInitNum()
@ -110,8 +110,8 @@ func (cb *ChessBorad) ver() {
} }
if cb.ChessBag.List == nil { if cb.ChessBag.List == nil {
cb.ChessBag.List = make(map[int]ChessBagGrid) cb.ChessBag.List = make(map[int]ChessBagGrid)
InitNum := mergeDataCfg.GetChessBagInitNum() initNum := mergeDataCfg.GetChessBagInitNum()
for i := 1; i <= InitNum; i++ { for i := 1; i <= initNum; i++ {
cb.ChessBag.List[i] = ChessBagGrid{} cb.ChessBag.List[i] = ChessBagGrid{}
} }
} }
@ -141,11 +141,11 @@ func (cb *ChessBorad) GetChessBuf() []int {
// 棋子合成 // 棋子合成
func (cb *ChessBorad) ComposeChess(id int) (int, error) { func (cb *ChessBorad) ComposeChess(id int) (int, error) {
CfgRecord, err := mergeDataCfg.GetOne(id) cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil { if err != nil {
return 0, errors.New("配置错误") return 0, errors.New("配置错误")
} }
if CfgRecord.Lv == CfgRecord.MaxLv { if cfgRecord.Lv == cfgRecord.MaxLv {
return 0, errors.New("已达最大等级") return 0, errors.New("已达最大等级")
} }
count := 0 count := 0
@ -161,8 +161,8 @@ func (cb *ChessBorad) ComposeChess(id int) (int, error) {
if count < 2 { if count < 2 {
return 0, errors.New("次数不足" + fmt.Sprintf("Id: %d", id)) return 0, errors.New("次数不足" + fmt.Sprintf("Id: %d", id))
} }
ChessType := mergeDataCfg.GetTypeById(id) chessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" { if chessType == "Emitter" {
cb.EmitList[id+1]++ cb.EmitList[id+1]++
cb.EmitList[id] -= 2 cb.EmitList[id] -= 2
} }
@ -199,8 +199,8 @@ func (cb *ChessBorad) AddChess(id int) error {
cb.ChessBuff = append(cb.ChessBuff, id) cb.ChessBuff = append(cb.ChessBuff, id)
return nil return nil
} }
ChessType := mergeDataCfg.GetTypeById(id) chessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" { if chessType == "Emitter" {
cb.EmitList[id]++ cb.EmitList[id]++
} }
cb.ChessList = append(cb.ChessList, 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) { func (cb *ChessBorad) BuyChess(id int) (int, error) {
CfgRecord, err := mergeDataCfg.GetOne(id) cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil { if err != nil {
return 0, errors.New("配置错误") return 0, errors.New("配置错误")
} }
cb.ChessList = append(cb.ChessList, id) cb.ChessList = append(cb.ChessList, id)
ChessType := mergeDataCfg.GetTypeById(id) chessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" { if chessType == "Emitter" {
cb.EmitList[id]++ cb.EmitList[id]++
} }
return CfgRecord.SellNum, nil return cfgRecord.SellNum, nil
} }
// 出售棋子 // 出售棋子
func (cb *ChessBorad) SellChess(id int) ([]*item.Item, error) { func (cb *ChessBorad) SellChess(id int) ([]*item.Item, error) {
CfgRecord, err := mergeDataCfg.GetOne(id) cfgRecord, err := mergeDataCfg.GetOne(id)
if err != nil { if err != nil {
return nil, errors.New("配置错误") return nil, errors.New("配置错误")
} }
@ -243,24 +243,24 @@ func (cb *ChessBorad) SellChess(id int) ([]*item.Item, error) {
cb.ChessList = newList cb.ChessList = newList
var items []*item.Item var items []*item.Item
switch CfgRecord.SellType { switch cfgRecord.SellType {
case "star": 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": 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": 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": 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 return items, nil
} }
// 移除棋子 // 移除棋子
func (cb *ChessBorad) RemoveChess(Id int) error { func (cb *ChessBorad) RemoveChess(id int) error {
find := false find := false
for k, v := range cb.ChessList { for k, v := range cb.ChessList {
if v == Id { if v == id {
cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...) cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...)
find = true find = true
break break
@ -269,11 +269,11 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
if !find { if !find {
return errors.New("chess id not exist") return errors.New("chess id not exist")
} }
ChessType := mergeDataCfg.GetTypeById(Id) chessType := mergeDataCfg.GetTypeById(id)
if ChessType == "Emitter" { if chessType == "Emitter" {
v, ok := cb.EmitList[Id] v, ok := cb.EmitList[id]
if v > 0 && ok { if v > 0 && ok {
cb.EmitList[Id]-- cb.EmitList[id]--
} }
} }
return nil return nil
@ -282,39 +282,39 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
// emitListToSlice 将 EmitList 过滤并转换为发射器 ID 列表。 // emitListToSlice 将 EmitList 过滤并转换为发射器 ID 列表。
// retireFilter 为 true 时过滤已退役的发射器。 // retireFilter 为 true 时过滤已退役的发射器。
func (cb *ChessBorad) emitListToSlice(retireFilter bool) []int { func (cb *ChessBorad) emitListToSlice(retireFilter bool) []int {
EM := make(map[string]int) emitMap := make(map[string]int)
for k, v := range cb.EmitList { for k, v := range cb.EmitList {
if v <= 0 { if v <= 0 {
delete(cb.EmitList, k) delete(cb.EmitList, k)
continue continue
} }
EmitID := mergeDataCfg.GetEmitId(k) emitID := mergeDataCfg.GetEmitId(k)
if EmitID == "" { if emitID == "" {
continue continue
} }
if retireFilter && cb.Retire[EmitID] >= EMIT_RETIRE_START { if retireFilter && cb.Retire[emitID] >= EMIT_RETIRE_START {
continue continue
} }
if mergeDataCfg.GetEmitType(k) == "sub" { if mergeDataCfg.GetEmitType(k) == "sub" {
continue continue
} }
EM[EmitID] = max(EM[EmitID], k) emitMap[emitID] = max(emitMap[emitID], k)
} }
for _, v := range cb.ChessBag.List { for _, v := range cb.ChessBag.List {
EmitID := mergeDataCfg.GetEmitId(v.ChessId) emitID := mergeDataCfg.GetEmitId(v.ChessId)
if EmitID == "" { if emitID == "" {
continue continue
} }
if retireFilter && cb.Retire[EmitID] >= EMIT_RETIRE_START { if retireFilter && cb.Retire[emitID] >= EMIT_RETIRE_START {
continue continue
} }
if mergeDataCfg.GetEmitType(v.ChessId) == "sub" { if mergeDataCfg.GetEmitType(v.ChessId) == "sub" {
continue continue
} }
EM[EmitID] = max(EM[EmitID], (v.ChessId)) emitMap[emitID] = max(emitMap[emitID], (v.ChessId))
} }
result := make([]int, 0, len(EM)) result := make([]int, 0, len(emitMap))
for _, v := range EM { for _, v := range emitMap {
result = append(result, v) result = append(result, v)
} }
if !retireFilter { 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() unlockChessList := cb.GetUnlockChessList()
unlockChessMap := make(map[int]int) unlockChessMap := make(map[int]int)
for _, v := range unlockChessList { for _, v := range unlockChessList {
@ -344,13 +344,13 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
} }
var boardChess []int var boardChess []int
var BagChess []int var bagChess []int
for _, v := range ChessId { for _, v := range chessId {
if unlockChessMap[v] > 0 { if unlockChessMap[v] > 0 {
unlockChessMap[v]-- unlockChessMap[v]--
boardChess = append(boardChess, v) boardChess = append(boardChess, v)
} else { } else {
BagChess = append(BagChess, v) bagChess = append(bagChess, v)
} }
} }
for _, v := range boardChess { for _, v := range boardChess {
@ -359,7 +359,7 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
return err return err
} }
} }
for _, v := range BagChess { for _, v := range bagChess {
err := cb.FinishOrderChessByBag(v) err := cb.FinishOrderChessByBag(v)
if err != nil { if err != nil {
return err 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 { for k, v := range cb.ChessList {
if v == Chess { if v == chess {
cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...) cb.ChessList = append(cb.ChessList[:k], cb.ChessList[k+1:]...)
return nil 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 { for k, v := range cb.ChessBag.List {
if v.ChessId == Chess { if v.ChessId == chess {
cb.ChessBag.List[k] = ChessBagGrid{} cb.ChessBag.List[k] = ChessBagGrid{}
return nil 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 { func (cb *ChessBorad) ExChess(oldChessId, newChessId int) error {
if OldChessId > 0 { if oldChessId > 0 {
newList, b := GoUtil.PopElemSlice(cb.ChessList, OldChessId) newList, b := GoUtil.PopElemSlice(cb.ChessList, oldChessId)
if !b { if !b {
return fmt.Errorf("ExChess chess id not exist") return fmt.Errorf("ExChess chess id not exist")
} }
cb.ChessList = newList 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) cb.ChessBuff = append(cb.ChessBuff, chess)
} }
func (cb *ChessBorad) AddHonor(Id int) { func (cb *ChessBorad) AddHonor(id int) {
cb.Honor[Id] = 1 cb.Honor[id] = 1
} }
func (cb *ChessBorad) RemoveHonor(Id int) { func (cb *ChessBorad) RemoveHonor(id int) {
delete(cb.Honor, Id) delete(cb.Honor, id)
} }
// 从暂存区添加棋子到棋盘 // 从暂存区添加棋子到棋盘
func (cb *ChessBorad) GetChessFromBuff(Chess int) error { func (cb *ChessBorad) GetChessFromBuff(chess int) error {
for i, v := range cb.ChessBuff { for i, v := range cb.ChessBuff {
if v == Chess { if v == chess {
cb.ChessBuff = append(cb.ChessBuff[:i], cb.ChessBuff[i+1:]...) 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") return errors.New("chess id not exist")
} }
// 扣除零件 // 扣除零件
func (cb *ChessBorad) LosePart(PartId int, Num int) error { func (cb *ChessBorad) LosePart(partId int, num int) error {
v, ok := cb.PartBag.List[PartId] v, ok := cb.PartBag.List[partId]
if !ok || v.Num < Num { 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)) 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 v.Num -= num
cb.PartBag.List[PartId] = v cb.PartBag.List[partId] = v
return nil return nil
} }
// 返回数据 // 返回数据
func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo { func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
var ChessBagGrids []*msg.ChessBagGrid var chessBagGrids []*msg.ChessBagGrid
for k, v := range cb.ChessBag.List { for k, v := range cb.ChessBag.List {
ChessBagGrids = append(ChessBagGrids, &msg.ChessBagGrid{ chessBagGrids = append(chessBagGrids, &msg.ChessBagGrid{
Id: int32(k), Id: int32(k),
ChessId: int32(v.ChessId), ChessId: int32(v.ChessId),
EmitId: int32(v.EmitId), EmitId: int32(v.EmitId),
}) })
} }
var PartBagGrids []*msg.PartBagGrid var partBagGrids []*msg.PartBagGrid
for k, v := range cb.PartBag.List { for k, v := range cb.PartBag.List {
PartBagGrids = append(PartBagGrids, &msg.PartBagGrid{ partBagGrids = append(partBagGrids, &msg.PartBagGrid{
PartId: int32(k), PartId: int32(k),
Count: int32(v.Num), Count: int32(v.Num),
}) })
} }
Re := make([]string, 0, len(cb.Retire)) retire := make([]string, 0, len(cb.Retire))
for k, v := range cb.Retire { for k, v := range cb.Retire {
if v == EMIT_RETIRE_END { 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 { 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 { for k, v := range cb.RetireReward {
if v { if v {
Rw = append(Rw, k) retireReward = append(retireReward, k)
} }
} }
return &msg.ResPlayerChessInfo{ return &msg.ResPlayerChessInfo{
ChessList: GoUtil.SliceIntToInt32(cb.ChessList), ChessList: GoUtil.SliceIntToInt32(cb.ChessList),
ChessBuff: GoUtil.SliceIntToInt32(cb.ChessBuff), ChessBuff: GoUtil.SliceIntToInt32(cb.ChessBuff),
RetireEmit: Re, RetireEmit: retire,
RetireReward: Rw, RetireReward: retireReward,
Honor: Ho, Honor: honor,
ChessBag: &msg.ChessBag{ ChessBag: &msg.ChessBag{
ChessBagGrids: ChessBagGrids, ChessBagGrids: chessBagGrids,
ChessBuyCnt: int32(cb.ChessBag.Buy), ChessBuyCnt: int32(cb.ChessBag.Buy),
ChessFreeCnt: int32(cb.ChessBag.Free), ChessFreeCnt: int32(cb.ChessBag.Free),
}, },
PartBag: &msg.PartBag{ PartBag: &msg.PartBag{
PartBagGrids: PartBagGrids, PartBagGrids: partBagGrids,
}, },
} }
} }
@ -494,8 +504,8 @@ func (cb *ChessBorad) BuyChessBagGrid() error {
cb.ChessBag.Free-- cb.ChessBag.Free--
return nil return nil
} }
MaxBuy := mergeDataCfg.GetChessBagBugNum() maxBuy := mergeDataCfg.GetChessBagBugNum()
if cb.ChessBag.Buy >= MaxBuy { if cb.ChessBag.Buy >= maxBuy {
return fmt.Errorf("ChessBag can buy is full") return fmt.Errorf("ChessBag can buy is full")
} }
cb.ChessBag.Buy++ cb.ChessBag.Buy++
@ -507,31 +517,31 @@ func (cb *ChessBorad) GetBuyChessBagGridCost() []*item.Item {
if cb.ChessBag.Free > 0 { if cb.ChessBag.Free > 0 {
return nil return nil
} }
NeedDiamond := 10 + 15*cb.ChessBag.Buy needDiamond := 10 + 15*cb.ChessBag.Buy
return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -NeedDiamond}} return []*item.Item{{Id: item.ITEM_DIAMOND_ID, Num: -needDiamond}}
} }
// 升级触发解锁棋盘背包 // 升级触发解锁棋盘背包
func (cb *ChessBorad) TriggerChessBagUnlock(Lv int) bool { func (cb *ChessBorad) TriggerChessBagUnlock(lv int) bool {
UnlockPack := userCfg.GetUnlockPack(Lv) unlockPack := userCfg.GetUnlockPack(lv)
if UnlockPack > 0 { if unlockPack > 0 {
cb.ChessBag.Free += UnlockPack cb.ChessBag.Free += unlockPack
return true return true
} }
return false return false
} }
// 将棋子放入背包 // 将棋子放入背包
func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error { func (cb *ChessBorad) PutChessInBag(grid, chessId, emitId int) error {
err := cb.RemoveChess(ChessId) err := cb.RemoveChess(chessId)
if err != nil { if err != nil {
return err return err
} }
if Grid == 0 { // 背包id为0且发射器已退役奖励已领取 直接放入荣誉室 if grid == 0 { // 背包id为0且发射器已退役奖励已领取 直接放入荣誉室
cb.AddHonor(ChessId) cb.AddHonor(chessId)
return nil return nil
} }
v, ok := cb.ChessBag.List[Grid] v, ok := cb.ChessBag.List[grid]
if !ok { if !ok {
return errors.New("ChessBag Grid unlock") return errors.New("ChessBag Grid unlock")
} }
@ -539,132 +549,157 @@ func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error {
if v.ChessId > 0 { if v.ChessId > 0 {
return errors.New("ChessBag Grid is not empty") return errors.New("ChessBag Grid is not empty")
} }
cb.ChessBag.List[Grid] = ChessBagGrid{ cb.ChessBag.List[grid] = ChessBagGrid{
ChessId: ChessId, ChessId: chessId,
EmitId: EmitId, EmitId: emitId,
} }
return nil return nil
} }
// 将零件放入背包 // 将零件放入背包
func (cb *ChessBorad) PutPartInBag(ChessId int) error { func (cb *ChessBorad) PutPartInBag(chessId int) error {
err := cb.RemoveChess(ChessId) err := cb.RemoveChess(chessId)
if err != nil { if err != nil {
return err return err
} }
ChessLv := mergeDataCfg.GetLvById(ChessId) chessLv := mergeDataCfg.GetLvById(chessId)
ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId) chessMaxLv := mergeDataCfg.GetMaxLvById(chessId)
if ChessLv != ChessMaxLv { // 零件只能放入满级棋子 if chessLv != chessMaxLv { // 零件只能放入满级棋子
return errors.New("part Lv is not max") return errors.New("part Lv is not max")
} }
if cb.PartBag.List == nil { if cb.PartBag.List == nil {
cb.PartBag.List = make(map[int]PartBagGrid) cb.PartBag.List = make(map[int]PartBagGrid)
} }
Num := cb.PartBag.List[ChessId].Num num := cb.PartBag.List[chessId].Num
cb.PartBag.List[ChessId] = PartBagGrid{ cb.PartBag.List[chessId] = PartBagGrid{
PartId: ChessId, PartId: chessId,
Num: Num + 1, Num: num + 1,
} }
return nil return nil
} }
// 将棋子从背包取出 // 将棋子从背包取出
func (cb *ChessBorad) TakeChessOutBag(Grid int) (int, error) { func (cb *ChessBorad) TakeChessOutBag(grid int) (int, error) {
if Grid < 0 { if grid < 0 {
cb.RemoveHonor(-Grid) cb.RemoveHonor(-grid)
cb.AddChess(-Grid) cb.AddChess(-grid)
return 0, nil return 0, nil
} }
GridInfo, ok := cb.ChessBag.List[Grid] gridInfo, ok := cb.ChessBag.List[grid]
if !ok { if !ok {
return 0, errors.New("ChessBag Grid unlock") return 0, errors.New("ChessBag Grid unlock")
} }
if GridInfo.ChessId == 0 { if gridInfo.ChessId == 0 {
return 0, errors.New("ChessBag Grid is empty") return 0, errors.New("ChessBag Grid is empty")
} }
cb.ChessBag.List[Grid] = ChessBagGrid{} cb.ChessBag.List[grid] = ChessBagGrid{}
return GridInfo.ChessId, cb.AddChess(GridInfo.ChessId) 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 { func (cb *ChessBorad) GetOrderEmit() []int {
return cb.GetEmitList() 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 { func (cb *ChessBorad) GetRetireEmit() map[string]int {
return cb.Retire return cb.Retire
} }
// 获取退役发射器的棋子列表 // 获取退役发射器的棋子列表
func (cb *ChessBorad) GetRetireChess(EmitType string) []int { func (cb *ChessBorad) GetRetireChess(emitType string) []int {
v, ok := cb.RetireChessMap[EmitType] v, ok := cb.RetireChessMap[emitType]
if !ok { if !ok {
return nil return nil
} }
if len(v) == 1 { if len(v) == 1 {
cb.RetireChessMap[EmitType] = nil cb.RetireChessMap[emitType] = nil
return v return v
} }
if len(v) == 0 { if len(v) == 0 {
return nil return nil
} }
cb.RetireChessMap[EmitType] = v[2:] cb.RetireChessMap[emitType] = v[2:]
return v[:2] return v[:2]
} }
// 开始退役 // 开始退役
func (cb *ChessBorad) BeginRetire(EmitType string) error { func (cb *ChessBorad) BeginRetire(emitType string) error {
if cb.Retire == nil { if cb.Retire == nil {
cb.Retire = make(map[string]int) cb.Retire = make(map[string]int)
} }
_, ok := cb.Retire[EmitType] _, ok := cb.Retire[emitType]
if ok { if ok {
return errors.New("chess has been retired") return errors.New("chess has been retired")
} }
cb.Retire[EmitType] = EMIT_RETIRE_START cb.Retire[emitType] = EMIT_RETIRE_START
return nil return nil
} }
// 退役棋子处理 // 退役棋子处理
func (cb *ChessBorad) RetireOrder(EmitType string) error { func (cb *ChessBorad) RetireOrder(emitType string) error {
if cb.Retire[EmitType] != 1 { if cb.Retire[emitType] != 1 {
return errors.New("chess has not been retired") return errors.New("chess has not been retired")
} }
chess := make([]int, 0, len(cb.ChessMap)) chess := make([]int, 0, len(cb.ChessMap))
EmitProduct := mergeDataCfg.GetEmitOrderProduce(EmitType) emitProduct := mergeDataCfg.GetEmitOrderProduce(emitType)
for k, v := range cb.ChessMap { for _, v := range cb.ChessMap {
arr := strings.Split(k, "@") color := mergeDataCfg.GetColorById(int(v))
Color := mergeDataCfg.GetColorById(int(v)) if GoUtil.InStringArray(color, emitProduct) {
if arr[2] == "0" && GoUtil.InStringArray(Color, EmitProduct) {
chess = append(chess, int(v)) chess = append(chess, int(v))
} }
} }
sort.Sort(sort.Reverse(sort.IntSlice(chess))) sort.Sort(sort.Reverse(sort.IntSlice(chess)))
cb.RetireChessMap[EmitType] = chess cb.RetireChessMap[emitType] = chess
cb.Retire[EmitType] = EMIT_RETIRE_ING cb.Retire[emitType] = EMIT_RETIRE_ING
return nil return nil
} }
// 完成退役 // 完成退役
func (cb *ChessBorad) FinishRetire(EmitType string) error { func (cb *ChessBorad) FinishRetire(emitType string) error {
_, ok := cb.Retire[EmitType] _, ok := cb.Retire[emitType]
if !ok { if !ok {
return errors.New("chess has not been retired") return errors.New("chess has not been retired")
} }
cb.Retire[EmitType] = EMIT_RETIRE_END cb.Retire[emitType] = EMIT_RETIRE_END
return nil return nil
} }
// 获取资源宝箱奖励 // 获取资源宝箱奖励
func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) { func (cb *ChessBorad) SourceChest(chessId int) ([]*item.Item, error) {
err := cb.RemoveChess(ChessId) err := cb.RemoveChess(chessId)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if ChessId == CHESS_SOURCE_CHEST { if chessId == CHESS_SOURCE_CHEST {
return mergeDataCfg.GetSourceChestItem(), nil return mergeDataCfg.GetSourceChestItem(), nil
} }
if ChessId == CHESS_HIGH_SOURCE_CHEST { if chessId == CHESS_HIGH_SOURCE_CHEST {
return mergeDataCfg.GetHighSourceChestItem(), nil 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) { func (cb *ChessBorad) SeparateChess(chessId int) (int, error) {
ChessLv := mergeDataCfg.GetLvById(ChessId) chessLv := mergeDataCfg.GetLvById(chessId)
if ChessLv == 1 { if chessLv == 1 {
return 0, errors.New("chess lv is 1") return 0, errors.New("chess lv is 1")
} }
ChessType := mergeDataCfg.GetTypeById(ChessId) chessType := mergeDataCfg.GetTypeById(chessId)
if ChessType != "Product" { if chessType != "Product" {
return 0, errors.New("chess type is not product") return 0, errors.New("chess type is not product")
} }
err := cb.RemoveChess(ChessId) err := cb.RemoveChess(chessId)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -689,25 +724,25 @@ func (cb *ChessBorad) SeparateChess(ChessId int) (int, error) {
if err != nil { if err != nil {
return 0, err return 0, err
} }
ChessColor := mergeDataCfg.GetColorById(ChessId) chessColor := mergeDataCfg.GetColorById(chessId)
NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv-1, ChessColor) newChess := mergeDataCfg.GetChessIdByLvAndColor(chessLv-1, chessColor)
cb.AddChess(NewChess) cb.AddChess(newChess)
cb.AddChess(NewChess) cb.AddChess(newChess)
return NewChess, nil return newChess, nil
} }
// 提高棋子等级 // 提高棋子等级
func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) { func (cb *ChessBorad) UpgradeChess(chessId int) (int, error) {
ChessLv := mergeDataCfg.GetLvById(ChessId) chessLv := mergeDataCfg.GetLvById(chessId)
ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId) chessMaxLv := mergeDataCfg.GetMaxLvById(chessId)
if ChessLv == ChessMaxLv { if chessLv == chessMaxLv {
return 0, errors.New("chess lv is max") return 0, errors.New("chess lv is max")
} }
ChessType := mergeDataCfg.GetTypeById(ChessId) chessType := mergeDataCfg.GetTypeById(chessId)
if ChessType != "Product" { if chessType != "Product" {
return 0, errors.New("chess type is not product") return 0, errors.New("chess type is not product")
} }
err := cb.RemoveChess(ChessId) err := cb.RemoveChess(chessId)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -715,9 +750,9 @@ func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) {
if err != nil { if err != nil {
return 0, err return 0, err
} }
NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv+1, mergeDataCfg.GetColorById(ChessId)) newChess := mergeDataCfg.GetChessIdByLvAndColor(chessLv+1, mergeDataCfg.GetColorById(chessId))
cb.AddChess(NewChess) cb.AddChess(newChess)
return NewChess, nil return newChess, nil
} }
func (cb *ChessBorad) GetPartBag() map[int]int { func (cb *ChessBorad) GetPartBag() map[int]int {
@ -728,14 +763,14 @@ func (cb *ChessBorad) GetPartBag() map[int]int {
return res return res
} }
func (cb *ChessBorad) GetRetireReward(Id string) ([]*item.Item, error) { func (cb *ChessBorad) GetRetireReward(id string) ([]*item.Item, error) {
if cb.RetireReward[Id] == true { if cb.RetireReward[id] == true {
return nil, errors.New("emit retire reward has been get") 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") return nil, errors.New("emit not finish retire")
} }
cb.RetireReward[Id] = true cb.RetireReward[id] = true
return mergeDataCfg.GetRetireReward(), nil 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 c.C20250910 = true
} }
func (c *Compensation) Compensation20250910(UserName string) []*item.Item { func (c *Compensation) Compensation20250910(userName string) []*item.Item {
c.Set20250910() c.Set20250910()
// 获取补偿物品 // 获取补偿物品
items := make([]*item.Item, 0, len(Compensation20250910_UserList)) items := make([]*item.Item, 0, len(Compensation20250910_UserList))
for i := 1; i <= len(Compensation20250910_UserList); i++ { 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] return Compensation20250910_Mail_Item[i]
} }
} }

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

@ -8,12 +8,11 @@ import (
"sort" "sort"
) )
func getTaskReward(Id, AreaId, activityId int) []*item.Item { func getTaskReward(id, areaId, activityId int) []*item.Item {
switch id {
switch Id {
case 2: case 2:
StarNum := int(50 * math.Pow(1.04, float64(AreaId))) starNum := int(50 * math.Pow(1.04, float64(areaId)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: StarNum}} return []*item.Item{{Id: item.ITEM_STAR_ID, Num: starNum}}
case 3: case 3:
return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 10}} return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 10}}
default: // case 1 及其他 default: // case 1 及其他
@ -24,16 +23,16 @@ func getTaskReward(Id, AreaId, activityId int) []*item.Item {
// randJackpot 随机选取 num 个奖池项，约束：不允许连续两个 is_card=1 的项相邻。 // randJackpot 随机选取 num 个奖池项，约束：不允许连续两个 is_card=1 的项相邻。
// 最多尝试 100 次，超时则返回最后一次结果。 // 最多尝试 100 次，超时则返回最后一次结果。
func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.Item { func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.Item {
Ids := GoUtil.GetMapKey(jackpot) ids := GoUtil.GetMapKey(jackpot)
var lastIds1 []int var lastIds1 []int
for t := 0; t <= 100; t++ { for t := 0; t <= 100; t++ {
Ids1 := GoUtil.RandSliceNum(Ids, num) ids1 := GoUtil.RandSliceNum(ids, num)
sort.Ints(Ids1) sort.Ints(ids1)
lastIds1 = Ids1 lastIds1 = ids1
prevIsCard := 0 prevIsCard := 0
valid := true valid := true
cardCount := 0 cardCount := 0
for _, k := range Ids1 { for _, k := range ids1 {
curIsCard := jackpot[k].Is_card curIsCard := jackpot[k].Is_card
if prevIsCard == 1 && curIsCard == 1 { if prevIsCard == 1 && curIsCard == 1 {
valid = false valid = false
@ -49,7 +48,7 @@ func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.
} }
if valid { if valid {
r := make(map[int][]*item.Item, num) r := make(map[int][]*item.Item, num)
for _, k := range Ids1 { for _, k := range ids1 {
r[k] = jackpot[k].Items r[k] = jackpot[k].Items
} }
return r 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 { if _, ok := d.FinishList[decorateId]; ok {
return nil, fmt.Errorf("decorateId already finished") return nil, fmt.Errorf("decorateId already finished")
} }
SortList := decorateCfg.GetAllSortIdByAreaId(areaId) sortList := decorateCfg.GetAllSortIdByAreaId(areaId)
if !GoUtil.InArray(decorateId, SortList) { if !GoUtil.InArray(decorateId, sortList) {
return nil, fmt.Errorf("decorateId not in areaId") return nil, fmt.Errorf("decorateId not in areaId")
} }
d.FinishList[decorateId] = struct{}{} d.FinishList[decorateId] = struct{}{}
d.Progress++ d.Progress++
Item := decorateCfg.GetProgressReward(areaId, d.Progress) items := decorateCfg.GetProgressReward(areaId, d.Progress)
Item1 := decorateCfg.GetDecoarteReward(areaId, decorateId) items1 := decorateCfg.GetDecoarteReward(areaId, decorateId)
Item = append(Item, Item1...) items = append(items, items1...)
if d.Progress >= len(SortList) { if d.Progress >= len(sortList) {
d.AreaId++ d.AreaId++
d.Progress = 0 d.Progress = 0
d.FinishList = make(map[int]struct{}) d.FinishList = make(map[int]struct{})
@ -82,31 +82,31 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
} }
d.DecorateNum++ d.DecorateNum++
return Item, nil return items, nil
} }
// 获取装饰增加体力 // 获取装饰增加体力
func (d *Decorate) GetDecorateAddEnergy(cnt int) []*item.Item { func (d *Decorate) GetDecorateAddEnergy(cnt int) []*item.Item {
EnergyNum := decorateCfg.GetDecorateAddEnergy() energyNum := decorateCfg.GetDecorateAddEnergy()
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, EnergyNum*cnt)} 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) { func (d *Decorate) GetDecorateCostItem(areaId, decorateId int, decorateOffIsExist bool) ([]*item.Item, int, []*item.Item) {
Item := decorateCfg.GetStarCost(AreaId, DecorateId) itemNum := decorateCfg.GetStarCost(areaId, decorateId)
PetExp := decorateCfg.GetDecoratePExp(AreaId, DecorateId) petExp := decorateCfg.GetDecoratePExp(areaId, decorateId)
Id := decorateCfg.GetIdBySenceAndLv(AreaId, DecorateId) id := decorateCfg.GetIdBySenceAndLv(areaId, decorateId)
if DecorateOffIsExist { if decorateOffIsExist {
OffRate := limitedTimeEventCfg.GetDecorateOffDiscount(AreaId, DecorateId) offRate := limitedTimeEventCfg.GetDecorateOffDiscount(areaId, decorateId)
Item = int(math.Ceil(float64(Item) * float64(OffRate))) itemNum = int(math.Ceil(float64(itemNum) * float64(offRate)))
} }
Items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, Item)} items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, itemNum)}
PartItem := d.PartCost[Id] partCostInfo := d.PartCost[id]
PartItemList := make([]*item.Item, 0) partItems := make([]*item.Item, 0)
if PartItem != nil { if partCostInfo != nil {
Items = append(Items, PartItem.Items...) items = append(items, partCostInfo.Items...)
PartItemList = PartItem.Items partItems = partCostInfo.Items
delete(d.PartCost, Id) delete(d.PartCost, id)
} }
// 清理旧区域零件；若当前区域全部消耗完则预加载下一区域 // 清理旧区域零件；若当前区域全部消耗完则预加载下一区域
for k := range d.PartCost { for k := range d.PartCost {
@ -117,17 +117,17 @@ func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExis
if len(d.PartCost) == 0 { if len(d.PartCost) == 0 {
d.initPartCost(d.AreaId + 1) d.initPartCost(d.AreaId + 1)
} }
return Items, PetExp, PartItemList return items, petExp, partItems
} }
func (d *Decorate) GetNextNeedStar() int { func (d *Decorate) GetNextNeedStar() int {
DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId) decorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList)) subAlice := GoUtil.SubSlices(decorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
orderFactor := orderCfg.GetOrderFactor(d.GetAreaId()) orderFactor := orderCfg.GetOrderFactor(d.GetAreaId())
sort.Ints(SubAlice) sort.Ints(subAlice)
if len(SubAlice) > 0 { if len(subAlice) > 0 {
NeedStar := decorateCfg.GetStarCost(d.AreaId, SubAlice[0]) needStar := decorateCfg.GetStarCost(d.AreaId, subAlice[0])
return (NeedStar*orderFactor)/1000 + NeedStar return (needStar*orderFactor)/1000 + needStar
} }
return 0 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) { func (d *Decorate) DecorateAll(star int, decorateOffIsExist bool) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId) decorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList)) subAlice := GoUtil.SubSlices(decorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
sort.Ints(SubAlice) sort.Ints(subAlice)
SubItem := 0 subItem := 0
SubItems := make([]*item.Item, 0) subItems := make([]*item.Item, 0)
AddItem := make([]*item.Item, 0) addItem := make([]*item.Item, 0)
DecorateList := make([]int, 0) decorateList := make([]int, 0)
Log := make([]interface{}, 0) logList := make([]interface{}, 0)
Num := 0 num := 0
PetExp := 0 petExp := 0
for _, v := range SubAlice { for _, v := range subAlice {
Id := decorateCfg.GetIdBySenceAndLv(d.AreaId, v) id := decorateCfg.GetIdBySenceAndLv(d.AreaId, v)
PartItem := d.PartCost[Id] partItem := d.PartCost[id]
if PartItem != nil { if partItem != nil {
break break
} }
NeedStar := decorateCfg.GetStarCost(d.AreaId, v) needStar := decorateCfg.GetStarCost(d.AreaId, v)
if DecorateOffIsExist { if decorateOffIsExist {
OffRate := limitedTimeEventCfg.GetDecorateOffDiscount(d.AreaId, v) offRate := limitedTimeEventCfg.GetDecorateOffDiscount(d.AreaId, v)
NeedStar = int(math.Ceil(float64(NeedStar) * float64(OffRate))) needStar = int(math.Ceil(float64(needStar) * float64(offRate)))
} }
if Star < NeedStar { if star < needStar {
break break
} }
Star -= NeedStar star -= needStar
SubItem += NeedStar subItem += needStar
d.FinishList[v] = struct{}{} d.FinishList[v] = struct{}{}
d.Progress++ d.Progress++
d.DecorateNum++ d.DecorateNum++
Num++ num++
Item := decorateCfg.GetProgressReward(d.AreaId, d.Progress) items := decorateCfg.GetProgressReward(d.AreaId, d.Progress)
Item = append(Item, decorateCfg.GetDecoarteReward(d.AreaId, v)...) items = append(items, decorateCfg.GetDecoarteReward(d.AreaId, v)...)
if len(Item) > 0 { if len(items) > 0 {
if d.Progress >= len(DecorateAll) { if d.Progress >= len(decorateAll) {
Log = append(Log, map[string]interface{}{ logList = append(logList, map[string]interface{}{
"deco_step_id": fmt.Sprintf("%d_%d", d.AreaId+1, 0), "deco_step_id": fmt.Sprintf("%d_%d", d.AreaId+1, 0),
"item_list": Item, "item_list": items,
}) })
} else { } else {
Log = append(Log, map[string]interface{}{ logList = append(logList, map[string]interface{}{
"deco_step_id": fmt.Sprintf("%d_%d", d.AreaId, d.Progress), "deco_step_id": fmt.Sprintf("%d_%d", d.AreaId, d.Progress),
"item_list": Item, "item_list": items,
}) })
} }
} }
PetExp += decorateCfg.GetDecoratePExp(d.AreaId, v) petExp += decorateCfg.GetDecoratePExp(d.AreaId, v)
AddItem = append(AddItem, Item...) addItem = append(addItem, items...)
DecorateList = append(DecorateList, v) decorateList = append(decorateList, v)
} }
if d.Progress >= len(DecorateAll) { if d.Progress >= len(decorateAll) {
d.AreaId++ d.AreaId++
d.Progress = 0 d.Progress = 0
d.FinishList = make(map[int]struct{}) d.FinishList = make(map[int]struct{})
d.prunePartCost() d.prunePartCost()
} }
SubItems = append(SubItems, item.NewItem(item.ITEM_STAR_ID, SubItem)) subItems = append(subItems, item.NewItem(item.ITEM_STAR_ID, subItem))
return SubItems, AddItem, Num, DecorateList, Log, PetExp return subItems, addItem, num, decorateList, logList, petExp
} }
// 获取装饰信息 // 获取装饰信息
func (d *Decorate) BackData() *msg.ResDecorateInfo { func (d *Decorate) BackData() *msg.ResDecorateInfo {
var PartRes []*msg.DecoratePart var partRes []*msg.DecoratePart
for k, v := range d.PartCost { for k, v := range d.PartCost {
PartRes = append(PartRes, &msg.DecoratePart{ partRes = append(partRes, &msg.DecoratePart{
Id: int32(k), Id: int32(k),
Items: item.ItemToMsg(v.Items), Items: item.ItemToMsg(v.Items),
}) })
@ -212,7 +212,7 @@ func (d *Decorate) BackData() *msg.ResDecorateInfo {
AreaId: int32(d.AreaId), AreaId: int32(d.AreaId),
MFinishList: GoUtil.MapIntToSlice(d.FinishList), MFinishList: GoUtil.MapIntToSlice(d.FinishList),
RewardArea: GoUtil.IntToInt32(d.AreaReward), 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() d.initPartPool()
res := make(map[int]int) res := make(map[int]int)
ClassNum := min(Num, 3) classNum := min(num, 3)
ClassList := d.GetPartClass(ClassNum) classList := d.GetPartClass(classNum)
NewClassList := d.sortClass(ClassList) newClassList := d.sortClass(classList)
for i := range Num { for i := range num {
Class := NewClassList[i%ClassNum] class := newClassList[i%classNum]
d.PartPool[Class]-- d.PartPool[class]--
res[Class]++ res[class]++
} }
return res return res
} }
func (d *Decorate) sortClass(Class []int) []int { func (d *Decorate) sortClass(class []int) []int {
d.initPartPool() d.initPartPool()
type sortItem struct { type sortItem struct {
Id int Id int
Num int Num int
} }
sortList := make([]sortItem, len(Class)) sortList := make([]sortItem, len(class))
for i, v := range Class { for i, v := range class {
sortList[i] = sortItem{Id: v, Num: d.PartPool[v]} sortList[i] = sortItem{Id: v, Num: d.PartPool[v]}
} }
sort.Slice(sortList, func(i, j int) bool { sort.Slice(sortList, func(i, j int) bool {
return sortList[i].Num > sortList[j].Num return sortList[i].Num > sortList[j].Num
}) })
res := make([]int, len(Class)) res := make([]int, len(class))
for i, v := range sortList { for i, v := range sortList {
res[i] = v.Id res[i] = v.Id
} }
return res return res
} }
func (d *Decorate) GetPartClass(Num int) []int { func (d *Decorate) GetPartClass(num int) []int {
res := make([]int, 0, Num) res := make([]int, 0, num)
for range Num { for i := 0; i < num; i++ {
if len(d.PartClassPool) == 0 { if len(d.PartClassPool) == 0 {
d.initPartClassPool() d.initPartClassPool()
} }
Id, newPool := GoUtil.PopSlice(d.PartClassPool) id, newPool := GoUtil.PopSlice(d.PartClassPool)
d.PartClassPool = newPool d.PartClassPool = newPool
res = append(res, Id) res = append(res, id)
} }
return res return res
} }
@ -288,35 +288,35 @@ func (d *Decorate) GetPartClass(Num int) []int {
// 初始化零件类别池，优先保证每个类别至少出现一次 // 初始化零件类别池，优先保证每个类别至少出现一次
func (d *Decorate) initPartClassPool() { func (d *Decorate) initPartClassPool() {
if len(d.PartClassPool) == 0 { if len(d.PartClassPool) == 0 {
ClassList := decorateCfg.GetAllPartId() classList := decorateCfg.GetAllPartId()
r1 := GoUtil.SubSlices(ClassList, d.LastPart) r1 := GoUtil.SubSlices(classList, d.LastPart)
c1 := GoUtil.RandSlice(r1) c1 := GoUtil.RandSlice(r1)
r2 := GoUtil.SubSlices(ClassList, []int{c1}) r2 := GoUtil.SubSlices(classList, []int{c1})
r3 := GoUtil.ShuffleArray(r2) r3 := GoUtil.ShuffleArray(r2)
d.PartClassPool = append([]int{c1}, r3...) d.PartClassPool = append([]int{c1}, r3...)
} }
} }
func (d *Decorate) initPartPool() { func (d *Decorate) initPartPool() {
IsEmpty := true isEmpty := true
for _, v := range d.PartPool { for _, v := range d.PartPool {
if v > 0 { if v > 0 {
IsEmpty = false isEmpty = false
break break
} }
} }
if IsEmpty { if isEmpty {
PartList := decorateCfg.GetAllPartId() partList := decorateCfg.GetAllPartId()
for _, v := range PartList { for _, v := range partList {
d.PartPool[v] = 7 d.PartPool[v] = 7
} }
} }
} }
// 初始化零件消耗，预加载当前区域和下一区域的零件消耗，减少玩家装饰时的卡顿感 // 初始化零件消耗，预加载当前区域和下一区域的零件消耗，减少玩家装饰时的卡顿感
func (d *Decorate) initPartCost(AreaId int) { func (d *Decorate) initPartCost(areaId int) {
AllPartList := decorateCfg.GetPartNumByAreaId(AreaId) allPartList := decorateCfg.GetPartNumByAreaId(areaId)
for k, v := range AllPartList { for k, v := range allPartList {
// 初始零件消耗写死 // 初始零件消耗写死
if k == 33 { if k == 33 {
d.PartCost[k] = &PartCostInfo{ d.PartCost[k] = &PartCostInfo{
@ -336,13 +336,13 @@ func (d *Decorate) initPartCost(AreaId int) {
} }
continue continue
} }
PartList := d.GetPart(v) partList := d.GetPart(v)
Items := make([]*item.Item, 0) items := make([]*item.Item, 0)
for k1, v1 := range PartList { for k1, v1 := range partList {
Items = append(Items, item.NewItem(k1, v1)) items = append(items, item.NewItem(k1, v1))
} }
d.PartCost[k] = &PartCostInfo{ 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表示清空该类型表情 // 设置表情，Id为0表示清空该类型表情
func (e *EmojiMod) SetEmoji(Id, Type int) error { func (e *EmojiMod) SetEmoji(id, eType int) error {
if Id == 0 { if id == 0 {
e.Set[Type] = Id e.Set[eType] = id
return nil return nil
} }
if _, ok := e.List[Id]; !ok { if _, ok := e.List[id]; !ok {
return fmt.Errorf("emoji id not exist") return fmt.Errorf("emoji id not exist")
} }
e.Set[Type] = Id e.Set[eType] = id
return nil return nil
} }
// 解锁表情，Time为解锁时长，单位为秒 // 解锁表情，Time为解锁时长，单位为秒
func (e *EmojiMod) Unlock(Id, Time int) error { func (e *EmojiMod) Unlock(id, time int) error {
v, ok := e.List[Id] v, ok := e.List[id]
if ok { if ok {
if v.Ts == 0 { if v.Ts == 0 {
return nil return nil
} }
v.Ts += int64(Time) v.Ts += int64(time)
return nil return nil
} }
now := GoUtil.Now() now := GoUtil.Now()
e.List[Id] = &Emoji{ e.List[id] = &Emoji{
Ts: now + int64(Time), Ts: now + int64(time),
AddTime: now, AddTime: now,
} }
return nil 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.List = make(map[int]*Endless)
e.Auto = 1 e.Auto = 1
FirstMoney := 0.0 firstMoney := 0.0
if MaxMoney > 0 { if maxMoney > 0 {
m := MaxMoney / 10 m := maxMoney / 10
GradeList := []float64{1.99, 3.99, 5.99, 7.99, 9.99} gradeList := []float64{1.99, 3.99, 5.99, 7.99, 9.99}
type duch struct { type duch struct {
Grade float64 Grade float64
Num float64 Num float64
} }
duchList := make([]duch, 0, len(GradeList)) duchList := make([]duch, 0, len(gradeList))
for _, v := range GradeList { for _, v := range gradeList {
duchList = append(duchList, duch{ duchList = append(duchList, duch{
Grade: v, Grade: v,
Num: math.Abs(v - m), 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 { sort.Slice(duchList, func(i, j int) bool {
return duchList[i].Num < duchList[j].Num return duchList[i].Num < duchList[j].Num
}) })
FirstMoney = duchList[0].Grade firstMoney = duchList[0].Grade
if FirstMoney == 0 { if firstMoney == 0 {
FirstMoney = 9.99 firstMoney = 9.99
} }
} }
money := FirstMoney money := firstMoney
for range 3 { for range 3 {
e.appendGrade(money, Lv) e.appendGrade(money, lv)
money = endlessCfg.NextMoney(money) money = endlessCfg.NextMoney(money)
} }
e.Id = 1 e.Id = 1
} }
// appendGrade 初始化一档礼包并合并到列表 // appendGrade 初始化一档礼包并合并到列表
func (e *EndlessMod) appendGrade(money float64, Lv int) { func (e *EndlessMod) appendGrade(money float64, lv int) {
r, autoNext := initGrade(money, e.Auto, Lv) r, autoNext := initGrade(money, e.Auto, lv)
e.Auto = autoNext e.Auto = autoNext
for k, v := range r { for k, v := range r {
e.List[k] = v 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] v, ok := e.List[e.Id]
if !ok { if !ok {
return nil, fmt.Errorf("EndlessMod Reward Id:%d not found", e.Id) 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) delete(e.List, e.Id)
e.Id++ e.Id++
if v1 := e.List[e.Id]; v1 != nil && v1.Type == ENDLESS_TYPE_CHARGE { //领完一阶段 随机新的一阶段 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 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] v, ok := e.List[e.Id]
if !ok { if !ok {
return nil return nil
} }
if v.ChargeId != ChargeId { if v.ChargeId != chargeId {
return nil return nil
} }
delete(e.List, e.Id) 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} numRand := map[int]int{1: 30, 2: 60, 3: 10}
Num := Util.RandMap(numRand) num := Util.RandMap(numRand)
PerEnergy := endlessCfg.GetPerEnergy(item.ITEM_ENERGY_ID) perEnergy := endlessCfg.GetPerEnergy(item.ITEM_ENERGY_ID)
getNum := func(energy, preEnergy float64) int { getNum := func(energy, perEnergy float64) int {
num := int(energy / preEnergy) num := int(energy / perEnergy)
num = int(math.Round(float64(num)/5.0) * 5) num = int(math.Round(float64(num)/5.0) * 5)
return max(num, 5) // 最少5个能量 return max(num, 5) // 最少5个能量
} }
if Num == 1 { if num == 1 {
ItemNum := getNum(Energy, PerEnergy) itemNum := getNum(energy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum)} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum)}
} }
if Num == 2 { if num == 2 {
ItemId := endlessCfg.GetItemId(Energy, 0, Lv) itemId := endlessCfg.GetItemId(energy, 0, lv)
if len(ItemId) == 0 { if len(itemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(Energy, PerEnergy))} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(energy, perEnergy))}
} }
RandItem := Util.RandSlice(ItemId) randItem := Util.RandSlice(itemId)
ItemEnergy := endlessCfg.GetEnergyByItemId(RandItem) itemEnergy := endlessCfg.GetEnergyByItemId(randItem)
LastEnergy := Energy - ItemEnergy lastEnergy := energy - itemEnergy
ItemNum := getNum(LastEnergy, PerEnergy) itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem, 1)} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem, 1)}
} }
if Num == 3 { if num == 3 {
ItemId := endlessCfg.GetItemId(Energy, 0, Lv) itemId := endlessCfg.GetItemId(energy, 0, lv)
if len(ItemId) == 0 { if len(itemId) == 0 {
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(Energy, PerEnergy))} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, getNum(energy, perEnergy))}
} }
RandItem1 := Util.RandSlice(ItemId) randItem1 := Util.RandSlice(itemId)
Type := endlessCfg.GetType(RandItem1) itemType := endlessCfg.GetType(randItem1)
ItemEnergy := endlessCfg.GetEnergyByItemId(RandItem1) itemEnergy := endlessCfg.GetEnergyByItemId(randItem1)
LastEnergy := Energy - ItemEnergy lastEnergy := energy - itemEnergy
ItemId = endlessCfg.GetItemId(LastEnergy, Type, Lv) itemId = endlessCfg.GetItemId(lastEnergy, itemType, lv)
if len(ItemId) == 0 { if len(itemId) == 0 {
ItemNum := getNum(LastEnergy, PerEnergy) itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem1, 1)} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem1, 1)}
} }
RandItem2 := Util.RandSlice(ItemId) randItem2 := Util.RandSlice(itemId)
ItemEnergy = endlessCfg.GetEnergyByItemId(RandItem2) itemEnergy = endlessCfg.GetEnergyByItemId(randItem2)
LastEnergy = LastEnergy - ItemEnergy lastEnergy = lastEnergy - itemEnergy
ItemNum := getNum(LastEnergy, PerEnergy) itemNum := getNum(lastEnergy, perEnergy)
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, ItemNum), item.NewItem(RandItem1, 1), item.NewItem(RandItem2, 1)} return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum), item.NewItem(randItem1, 1), item.NewItem(randItem2, 1)}
} }
return nil return nil
} }
// 初始化档次奖励 // 初始化档次奖励
func initGrade(Money float64, Auto, Lv int) (map[int]*Endless, int) { func initGrade(money float64, auto, lv int) (map[int]*Endless, int) {
Energy := endlessCfg.GetEnergy(Money) energy := endlessCfg.GetEnergy(money)
Per := []float64{0.5, 0.3, 0.2, 0.1} per := []float64{0.5, 0.3, 0.2, 0.1}
result := make(map[int]*Endless) result := make(map[int]*Endless)
for i := 1; i < 5; i++ { for i := 1; i < 5; i++ {
Type := ENDLESS_TYPE_FREE Type := ENDLESS_TYPE_FREE
Charge := 0 Charge := 0
if i == 1 { if i == 1 {
if Money > 0 { if money > 0 {
Type = ENDLESS_TYPE_CHARGE Type = ENDLESS_TYPE_CHARGE
Charge = endlessCfg.GetChargeId(Money) Charge = endlessCfg.GetChargeId(money)
} else { } else {
Type = ENDLESS_TYPE_AD Type = ENDLESS_TYPE_AD
} }
} }
result[Auto] = &Endless{ result[auto] = &Endless{
ChargeId: Charge, ChargeId: Charge,
Type: Type, 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 AddTime int64
} }
func (f *FaceMod) Login(RegisterTime int64) { func (f *FaceMod) Login(registerTime int64) {
for _, v := range f.List { for _, v := range f.List {
if v.AddTime == 0 { 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.List = make(map[int]*Face)
f.SetId = 1 f.SetId = 1
} }
InitId := faceCfg.GetInitList() initId := faceCfg.GetInitList()
for _, v := range InitId { for _, v := range initId {
if _, ok := f.List[v]; ok { if _, ok := f.List[v]; ok {
continue continue
} }
@ -51,29 +51,29 @@ func (f *FaceMod) GetFaceNum() int {
} }
// 设置表情，Id为0表示清空表情 // 设置表情，Id为0表示清空表情
func (f *FaceMod) SetFace(Id int) error { func (f *FaceMod) SetFace(id int) error {
if Id != 0 { if id != 0 {
if _, ok := f.List[Id]; !ok { if _, ok := f.List[id]; !ok {
return fmt.Errorf("face id not exist") return fmt.Errorf("face id not exist")
} }
} }
f.SetId = Id f.SetId = id
return nil return nil
} }
// 解锁表情 // 解锁表情
func (f *FaceMod) Unlock(Id, Time int) error { func (f *FaceMod) Unlock(id, time int) error {
v, ok := f.List[Id] v, ok := f.List[id]
if ok { if ok {
if v.Ts == 0 { if v.Ts == 0 {
return nil return nil
} }
v.Ts += int64(Time) v.Ts += int64(time)
return nil return nil
} }
now := GoUtil.Now() now := GoUtil.Now()
f.List[Id] = &Face{ f.List[id] = &Face{
Ts: now + int64(Time), Ts: now + int64(time),
AddTime: now, AddTime: now,
} }
return nil 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 { if f.FriendList == nil {
f.FriendList = make(map[int]struct{}) f.FriendList = make(map[int]struct{})
} }
@ -225,11 +225,11 @@ func (f *FriendMod) InitData(M_DwUin int64) {
f.NewApplyList = make(map[int]*ApplyInfo) f.NewApplyList = make(map[int]*ApplyInfo)
} }
for k, v := range f.Card { 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) delete(f.Card, k)
continue 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) delete(f.Card, k)
continue continue
} }
@ -259,16 +259,16 @@ func (f *FriendMod) version() {
Uid int Uid int
Time int64 Time int64
} }
PlayerList := make([]sortData, 0) playerList := make([]sortData, 0)
for k, v := range f.NewApplyList { 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 { sort.Slice(playerList, func(i, j int) bool {
return PlayerList[i].Time > PlayerList[j].Time 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() { 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 { if _, ok := f.NewFriendList[id]; !ok {
return return
} }
for _, v := range f.NewFriendList[id].Interact { for _, v := range f.NewFriendList[id].Interact {
if v.Type == t && v.VisitTime < T { if v.Type == t && v.VisitTime < visitTime {
v.VisitTime = T v.VisitTime = visitTime
return return
} }
} }
f.NewFriendList[id].Interact = append(f.NewFriendList[id].Interact, &Interact{ f.NewFriendList[id].Interact = append(f.NewFriendList[id].Interact, &Interact{
VisitTime: T, VisitTime: visitTime,
Type: t, Type: t,
}) })
if len(f.NewFriendList[id].Interact) > 30 { if len(f.NewFriendList[id].Interact) > 30 {
@ -332,14 +332,14 @@ func (f *FriendMod) GetInteractTime(id int) int64 {
if _, ok := f.NewFriendList[id]; !ok { if _, ok := f.NewFriendList[id]; !ok {
return 0 return 0
} }
var LastTime int64 var lastTime int64
// 获取最近一次拜访或点赞的时间 // 获取最近一次拜访或点赞的时间
for _, v := range f.NewFriendList[id].Interact { for _, v := range f.NewFriendList[id].Interact {
if v.VisitTime > LastTime { if v.VisitTime > lastTime {
LastTime = v.VisitTime 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) { func (f *FriendMod) SetCardInfo(cardInfo *card.CardInfo) {
f.Card[CardInfo.Id] = CardInfo f.Card[cardInfo.Id] = cardInfo
} }
// 删除卡牌交换信息 // 删除卡牌交换信息
func (f *FriendMod) DelCardInfo(Id string) { func (f *FriendMod) DelCardInfo(id string) {
delete(f.Card, Id) delete(f.Card, id)
} }
// 删除好友 // 删除好友
@ -389,8 +389,8 @@ func (f *FriendMod) DelFriend(id int) {
} }
// 检查是否好友 // 检查是否好友
func (f *FriendMod) CheckFriend(Uid int) bool { func (f *FriendMod) CheckFriend(uid int) bool {
v, ok := f.NewFriendList[Uid] v, ok := f.NewFriendList[uid]
return ok && v.DelTime == 0 return ok && v.DelTime == 0
} }
@ -433,14 +433,14 @@ func (f *FriendMod) GetFriendList() map[int]*FriendInfo {
// 获取好友uid列表 // 获取好友uid列表
func (f *FriendMod) GetSimpleFriendList() []int { 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 { for k, v := range f.NewFriendList {
if v.DelTime != 0 { if v.DelTime != 0 {
continue 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() { if f.DailyGetApply >= friendCfg.GetDailyGetApplyLimit() {
return true 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 return true
} }
var minTime int64 var minTime int64
@ -478,8 +478,8 @@ func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
} }
} }
} }
f.NewApplyList[Uid] = &ApplyInfo{ f.NewApplyList[uid] = &ApplyInfo{
Type: Type, Type: aType,
Time: sendTime, Time: sendTime,
} }
f.DailyGetApply++ f.DailyGetApply++
@ -487,29 +487,29 @@ func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
} }
// 发送申请 // 发送申请
func (f *FriendMod) AddSendApply(Uid int) bool { func (f *FriendMod) AddSendApply(uid int) bool {
f.SendApply[Uid] = GoUtil.Now() f.SendApply[uid] = GoUtil.Now()
return false return false
} }
func (f *FriendMod) CheckSendApply(Id int) bool { func (f *FriendMod) CheckSendApply(uid int) bool {
_, ok := f.SendApply[Id] _, ok := f.SendApply[uid]
return ok return ok
} }
// 获取发送申请时间 // 获取发送申请时间
func (f *FriendMod) GetSendApplyTime(Id int) int64 { func (f *FriendMod) GetSendApplyTime(uid int) int64 {
if t, ok := f.SendApply[Id]; ok { if t, ok := f.SendApply[uid]; ok {
return t return t
} }
return 0 return 0
} }
// 同意申请 // 同意申请
func (f *FriendMod) AgreeApply(UId int) { func (f *FriendMod) AgreeApply(uid int) {
f.AddFriend(UId) f.AddFriend(uid)
delete(f.SendApply, UId) delete(f.SendApply, uid)
delete(f.NewApplyList, 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: case LOG_TYPE_HANDBOOK_UPVOTE, LOG_TYPE_PLAYROOM_UPVOTE:
f.AddBubble(f.AutoId, ltype, nil) f.AddBubble(f.AutoId, ltype, nil)
case LOG_TYPE_TREASURE_HELP: case LOG_TYPE_TREASURE_HELP:
ItemNum := GoUtil.RandNum(2, 5) itemNum := GoUtil.RandNum(2, 5)
ItemList := []*item.Item{item.NewItem(item.ITEM_STAR_ID, ItemNum)} items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, itemNum)}
f.AddBubble(f.AutoId, ltype, ItemList) f.AddBubble(f.AutoId, ltype, items)
} }
if len(f.Log) > 30 { if len(f.Log) > 30 {
f.Log = f.Log[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) { func (f *FriendMod) AddBubble(id, bType int, items []*item.Item) {
f.Bubble[Id] = &BubbleInfo{ f.Bubble[id] = &BubbleInfo{
Id: Id, Id: id,
Time: GoUtil.Now(), Time: GoUtil.Now(),
Type: Type, Type: bType,
ItemList: ItemList, ItemList: items,
} }
} }
// 获取气泡信息 // 获取气泡信息
func (f *FriendMod) GetBubble(Id int) *msg.FriendBubbleInfo { func (f *FriendMod) GetBubble(id int) *msg.FriendBubbleInfo {
if v, ok := f.Bubble[Id]; ok { if v, ok := f.Bubble[id]; ok {
return &msg.FriendBubbleInfo{ return &msg.FriendBubbleInfo{
Id: int32(v.Id), Id: int32(v.Id),
Type: int32(v.Type), Type: int32(v.Type),
@ -559,16 +559,16 @@ func (f *FriendMod) GetBubble(Id int) *msg.FriendBubbleInfo {
} }
func (f *FriendMod) BubbleBackData() *msg.ResFriendBubble { 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 { for _, v := range f.Bubble {
rs = append(rs, &msg.FriendBubbleInfo{ res = append(res, &msg.FriendBubbleInfo{
Id: int32(v.Id), Id: int32(v.Id),
Type: int32(v.Type), Type: int32(v.Type),
Items: item.ItemToMsg(v.ItemList), Items: item.ItemToMsg(v.ItemList),
}) })
} }
return &msg.ResFriendBubble{ 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{ f.ActivityLog = append(f.ActivityLog, &ActLogInfo{
Type: Type, Type: actType,
Time: GoUtil.Now(), Time: GoUtil.Now(),
Param: Param, Param: param,
}) })
if len(f.ActivityLog) > 20 { if len(f.ActivityLog) > 20 {
f.ActivityLog = f.ActivityLog[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{} info := &LogInfo{}
for _, v := range f.Log { for _, v := range f.Log {
if v.Id == Id { if v.Id == id {
info = v info = v
break break
} }
@ -613,8 +613,8 @@ func (f *FriendMod) Upvote(Id int) ([]*item.Item, int, error) {
} }
// 获取时间线点赞奖励 // 获取时间线点赞奖励
func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) { func (f *FriendMod) GetReward(id int) ([]*item.Item, error) {
info, ok := f.Bubble[Id] info, ok := f.Bubble[id]
if !ok { if !ok {
return nil, fmt.Errorf("bubble not exist") return nil, fmt.Errorf("bubble not exist")
} }
@ -627,13 +627,12 @@ func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
default: default:
return nil, fmt.Errorf("log type not support") return nil, fmt.Errorf("log type not support")
} }
delete(f.Bubble, Id) delete(f.Bubble, id)
return reward, nil return reward, nil
} }
// 增加心愿单申请 // 增加心愿单申请
func (f *FriendMod) AddWishApply(Uid int64) error { func (f *FriendMod) AddWishApply(uid int64) error {
return nil 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") 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++ f.AutoId++
Reply := &ReplyInfo{ reply := &ReplyInfo{
Id: f.AutoId, Id: f.AutoId,
Uid: Uid, Uid: uid,
Type: Type, Type: rType,
Param: Param, Param: param,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
EndTime: EndTime, EndTime: endTime,
Items: Items, Items: items,
} }
f.ReplyList = append(f.ReplyList, Reply) f.ReplyList = append(f.ReplyList, reply)
if len(f.ReplyList) > 20 { if len(f.ReplyList) > 20 {
f.ReplyList = f.ReplyList[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 { for _, v := range f.ReplyList {
if v.Id == LogId { if v.Id == logId {
v.Status = 1 v.Status = 1
v.ReplyTime = GoUtil.Now() v.ReplyTime = GoUtil.Now()
return v 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() now := GoUtil.Now()
if v, ok := f.RecommendList[Uid]; ok { if v, ok := f.RecommendList[uid]; ok {
v.Time = now v.Time = now
return return
} }
f.RecommendList[Uid] = &Recommend{ f.RecommendList[uid] = &Recommend{
Uid: Uid, Uid: uid,
Time: now, Time: now,
} }
} }
@ -749,14 +747,14 @@ func (f *FriendMod) AddDailyRecommend() error {
return nil return nil
} }
func (f *FriendMod) GreetingFriend(Uid int) { func (f *FriendMod) GreetingFriend(uid int) {
if v, ok := f.NewFriendList[Uid]; ok { if v, ok := f.NewFriendList[uid]; ok {
v.Greeting = true v.Greeting = true
} }
} }
func (f *FriendMod) CheckGreeting(Uid int) bool { func (f *FriendMod) CheckGreeting(uid int) bool {
if v, ok := f.NewFriendList[Uid]; ok { if v, ok := f.NewFriendList[uid]; ok {
return v.Greeting return v.Greeting
} }
return false return false

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

@ -6,7 +6,6 @@ import (
"server/game/mod/item" "server/game/mod/item"
GoUtil "server/game_util" GoUtil "server/game_util"
"server/msg" "server/msg"
"server/pkg/github.com/name5566/leaf/log"
) )
type FriendTreasureMod struct { type FriendTreasureMod struct {
@ -47,11 +46,11 @@ func (f *FriendTreasureMod) ZeroUpdate() {
} }
// 初始化游戏数据 // 初始化游戏数据
func (f *FriendTreasureMod) InitGame(List []*msg.TreasureInfo, List2 []int32) { func (f *FriendTreasureMod) InitGame(list []*msg.TreasureInfo, list2 []int32) {
for _, v := range List { for _, v := range list {
f.List[int(v.Pos)] = v f.List[int(v.Pos)] = v
} }
f.List2 = List2 f.List2 = list2
f.Status = GAME_STATUS_START 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 { if f.Status == GAME_STATUS_IDLE {
return nil, 0, fmt.Errorf("game not start") return nil, 0, fmt.Errorf("game not start")
} }
f.Shift++ f.Shift++
info, ok := f.List[Pos] info, ok := f.List[pos]
if !ok { if !ok {
return nil, 0, fmt.Errorf("invalid position") return nil, 0, fmt.Errorf("invalid position")
} }
info.Status = GAME_STATUS_START info.Status = GAME_STATUS_START
if info.Uid != 0 { if info.Uid != 0 {
log.Debug("uid:%v", info.Uid)
f.Uids = append(f.Uids, info.Uid) f.Uids = append(f.Uids, info.Uid)
} }
if info.Type == FRIEND_TYPE_ALIVE { 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 { func (g *GuessColorMod) Login(id int) int {
OldId := g.Id oldId := g.Id
if Id == 0 { if id == 0 {
g.Id = 0 g.Id = 0
return 0 return 0
} }
if g.Id == Id { if g.Id == id {
return 0 return 0
} }
g.Id = Id g.Id = id
g.Pass = 1 g.Pass = 1
g.Opponent = simplePlayer{ g.Opponent = simplePlayer{
Name: randnameCfg.GetRandName(), Name: randnameCfg.GetRandName(),
@ -71,11 +71,11 @@ func (g *GuessColorMod) Login(Id int) int {
g.MapList = nil g.MapList = nil
g.OMap = nil g.OMap = nil
g.WinTime = guesscolorCfg.GetWinTime(g.Pass) g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
return OldId return oldId
} }
func (g *GuessColorMod) ZeroUpdate(Id int) { func (g *GuessColorMod) ZeroUpdate(id int) {
g.Login(Id) g.Login(id)
} }
func (g *GuessColorMod) FirstIn() []*item.Item { 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) { func (g *GuessColorMod) Take(guessMap map[int32]int32, oMap map[int32]int32) {
if len(Map) > 0 { if len(guessMap) > 0 {
g.MapList = append(g.MapList, Map) g.MapList = append(g.MapList, guessMap)
g.Guess++ g.Guess++
} }
g.OMap = OMap g.OMap = oMap
} }
// 获取失败奖励 // 获取失败奖励
func (g *GuessColorMod) GetLoseItem() []*item.Item { func (g *GuessColorMod) GetLoseItem() []*item.Item {
Items := guesscolorCfg.GetLoseItem(g.Id) items := guesscolorCfg.GetLoseItem(g.Id)
Num := guesscolorCfg.GetPassNum(g.Pass) num := guesscolorCfg.GetPassNum(g.Pass)
if len(g.MapList) > 0 { if len(g.MapList) > 0 {
LastMap := g.MapList[len(g.MapList)-1] lastMap := g.MapList[len(g.MapList)-1]
for _, v := range LastMap { for _, v := range lastMap {
if v > 10 { 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 { if g.Guess < g.WinTime {
return nil, fmt.Errorf("guess process not finish") return nil, fmt.Errorf("guess process not finish")
} }
Type := GAME_STATUS_FAIL gType := GAME_STATUS_FAIL
if g.Guess == guesscolorCfg.GetPassNum(g.Pass) { 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.Pass++
g.Guess = 0 g.Guess = 0
g.WinTime = guesscolorCfg.GetWinTime(g.Pass) g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
g.MapList = nil g.MapList = nil
g.OMap = 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) { func (g *Guide) GetReward(id int) ([]*item.Item, error) {
Items, Num := guidecfg.GetGuideReward(Id) items, num := guidecfg.GetGuideReward(id)
n := g.Reward[Id] n := g.Reward[id]
if n >= Num { if n >= num {
return nil, fmt.Errorf("Guide GetReward Id:%v has been received", Id) return nil, fmt.Errorf("Guide GetReward Id:%v has been received", id)
} }
g.Reward[Id]++ g.Reward[id]++
return Items, nil return items, nil
} }
func (g *Guide) BackData() *msg.ResGuideInfo { 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 { if gt.UnlockTime == 0 {
return return
} }
LoginDay := (GoUtil.Now()-gt.UnlockTime)/86400 + 1 loginDay := (GoUtil.Now()-gt.UnlockTime)/86400 + 1
gt.LoginDay[int(LoginDay)] = struct{}{} gt.LoginDay[int(loginDay)] = struct{}{}
gt.Trigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_GUIDE_LOGIN, A: []interface{}{len(gt.LoginDay)}}) gt.Trigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_GUIDE_LOGIN, A: []interface{}{len(gt.LoginDay)}})
} }
// 解锁引导任务 // 解锁引导任务
func (gt *GuideTaskMod) Unlock(lv int) bool { func (gt *GuideTaskMod) Unlock(lv int) bool {
UnLockLv := GuideTaskCfg.GetUnlockLv() unLockLv := GuideTaskCfg.GetUnlockLv()
if lv >= UnLockLv && gt.UnlockTime == 0 { if lv >= unLockLv && gt.UnlockTime == 0 {
gt.UnlockTime = GoUtil.Now() gt.UnlockTime = GoUtil.Now()
gt.Login() gt.Login()
return true return true
@ -77,7 +77,7 @@ func (gt *GuideTaskMod) CheckOpen() bool {
return GoUtil.Now()-gt.UnlockTime <= guideTaskOpenSeconds 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() { if !gt.CheckOpen() {
return false return false
} }
@ -89,7 +89,7 @@ func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
if v.Quest.Label == quest.TRIGGER_LABEL_GUIDE_LOGIN { if v.Quest.Label == quest.TRIGGER_LABEL_GUIDE_LOGIN {
v.Quest.A = []interface{}{gt.UnlockTime} v.Quest.A = []interface{}{gt.UnlockTime}
} }
update = quest.TriggerQuestProgress(&v.Quest, Tr) || update update = quest.TriggerQuestProgress(&v.Quest, tr) || update
if v.Quest.Status { if v.Quest.Status {
v.Status = quest.QUEST_STATUS_FINISH 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) { func (gt *GuideTaskMod) GetTaskReward(id int) ([]*item.Item, error) {
task, ok := gt.Tasks[Id] task, ok := gt.Tasks[id]
if !ok { 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 { 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 task.Status = quest.QUEST_STATUS_REWARD
gt.Active += GuideTaskCfg.GetTaskActive(Id) gt.Active += GuideTaskCfg.GetTaskActive(id)
return GuideTaskCfg.GetTaskRewardById(Id), nil 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 { for _, v := range gt.Reward {
if v == Id { if v == id {
return nil, fmt.Errorf("active reward already got") return nil, fmt.Errorf("active reward already got")
} }
} }
items, needActive := GuideTaskCfg.GetActiveReward(Id) items, needActive := GuideTaskCfg.GetActiveReward(id)
if items == nil { 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 { if gt.Active < needActive {
return nil, fmt.Errorf("active not enough") return nil, fmt.Errorf("active not enough")
} }
gt.Reward = append(gt.Reward, Id) gt.Reward = append(gt.Reward, id)
return items, nil 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 { func (h *Handbook) SetHandbook(id int) bool {
if Id <= 0 { if id <= 0 {
return false return false
} }
_, ok := h.BookList[Id] _, ok := h.BookList[id]
if ok { if ok {
return false return false
} }
h.BookList[Id] = STATUS_IDLE h.BookList[id] = STATUS_IDLE
return true return true
} }
// 领取图鉴奖励 // 领取图鉴奖励
func (h *Handbook) GetHandbookReward(Id int) error { func (h *Handbook) GetHandbookReward(id int) error {
status, ok := h.BookList[Id] status, ok := h.BookList[id]
if !ok { if !ok {
return errors.New("图鉴未解锁") return errors.New("图鉴未解锁")
} }
if status == STATUS_REWARD { if status == STATUS_REWARD {
return errors.New("图鉴奖励已领取") return errors.New("图鉴奖励已领取")
} }
h.BookList[Id] = STATUS_REWARD h.BookList[id] = STATUS_REWARD
return nil 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 { for _, v := range AllChess {
if _, ok := h.BookList[v]; !ok { if _, ok := h.BookList[v]; !ok {
return nil, fmt.Errorf("图鉴未解锁") return nil, fmt.Errorf("图鉴未解锁")
} }
} }
if _, ok := h.Collect[Id]; ok { if _, ok := h.Collect[id]; ok {
return nil, fmt.Errorf("已经领取过该奖励") return nil, fmt.Errorf("已经领取过该奖励")
} }
Reward := handbookCfg.GetHandbookReward(Id) reward := handbookCfg.GetHandbookReward(id)
if Reward == nil { if reward == nil {
return nil, fmt.Errorf("奖励不存在") return nil, fmt.Errorf("奖励不存在")
} }
h.Collect[Id] = struct{}{} h.Collect[id] = struct{}{}
return Reward, nil return reward, nil
} }
func (h *Handbook) BackData() *msg.Handbook { 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 { for k, v := range h.BookList {
BookList = append(BookList, &msg.HandbookInfo{ bookList = append(bookList, &msg.HandbookInfo{
ChessId: int32(k), ChessId: int32(k),
Status: int32(v), Status: int32(v),
}) })
} }
Collect := make([]string, 0, len(h.Collect)) collect := make([]string, 0, len(h.Collect))
for k := range h.Collect { for k := range h.Collect {
Collect = append(Collect, k) collect = append(collect, k)
} }
return &msg.Handbook{ return &msg.Handbook{
Handbooks: BookList, Handbooks: bookList,
Collect: Collect, 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 return nil
} }
func (i *InviteMod) GetReward(Index int) ([]*item.Item, error) { func (i *InviteMod) GetReward(index int) ([]*item.Item, error) {
if Index <= i.GetIndex { if index <= i.GetIndex {
return nil, fmt.Errorf("index error") return nil, fmt.Errorf("index error")
} }
var Items []*item.Item var items []*item.Item
cur := i.GetIndex cur := i.GetIndex
for cur < Index { for cur < index {
cur++ cur++
Need, Reward := inviteCfg.GetInviteReward(cur) need, reward := inviteCfg.GetInviteReward(cur)
if Need == 0 { if need == 0 {
return nil, fmt.Errorf("invite reward not found") 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") return nil, fmt.Errorf("invite not enough")
} }
Items = item.Merge(Items, Reward) items = item.Merge(items, reward)
} }
i.GetIndex = cur i.GetIndex = cur
return Items, nil return items, nil
} }
func (i *InviteMod) BackData() *msg.ResInviteFriendData { 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 { func Merge(item1, item2 []*Item) []*Item {
if Item1 == nil { if item1 == nil {
return Item2 return item2
} }
if Item2 == nil { if item2 == nil {
return Item1 return item1
} }
l := make(map[int]int) l := make(map[int]int)
for _, v := range Item1 { for _, v := range item1 {
l[v.Id] += v.Num l[v.Id] += v.Num
} }
for _, v := range Item2 { for _, v := range item2 {
l[v.Id] += v.Num l[v.Id] += v.Num
} }
res := make([]*Item, 0, len(l)) res := make([]*Item, 0, len(l))
@ -207,12 +207,12 @@ func Merge(Item1, Item2 []*Item) []*Item {
} }
return res return res
} }
func MutilItem(i []*Item, num int) []*Item { func MutilItem(item1 []*Item, num int) []*Item {
if i == nil { if item1 == nil {
return nil return nil
} }
res := make([]*Item, 0, len(i)) res := make([]*Item, 0, len(item1))
for _, v := range i { for _, v := range item1 {
res = append(res, &Item{ res = append(res, &Item{
Id: v.Id, Id: v.Id,
Num: v.Num * num, Num: v.Num * num,
@ -221,12 +221,12 @@ func MutilItem(i []*Item, num int) []*Item {
return res return res
} }
func MutilItemFloat(i []*Item, num float64) []*Item { func MutilItemFloat(item1 []*Item, num float64) []*Item {
if i == nil { if item1 == nil {
return nil return nil
} }
res := make([]*Item, 0, len(i)) res := make([]*Item, 0, len(item1))
for _, v := range i { for _, v := range item1 {
res = append(res, &Item{ res = append(res, &Item{
Id: v.Id, Id: v.Id,
Num: int(math.Round(float64(v.Num) * num)), 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" limitedTimeEventCfg "server/conf/limited_time_event"
mergeDataCfg "server/conf/merge_data" mergeDataCfg "server/conf/merge_data"
"server/game/mod/item" "server/game/mod/item"
"server/game/mod/order"
GoUtil "server/game_util" GoUtil "server/game_util"
"server/msg" "server/msg"
) )
@ -85,7 +84,7 @@ type PaybackDay struct {
Count int Count int
} }
func (l *LimitedTimeEventMod) InitData(Lv int) { func (l *LimitedTimeEventMod) InitData(lv int) {
if l.EventList == nil { if l.EventList == nil {
l.EventList = make(map[int]*LTEInfo) l.EventList = make(map[int]*LTEInfo)
} }
@ -98,8 +97,8 @@ func (l *LimitedTimeEventMod) InitData(Lv int) {
} }
if l.ProgressMax == 0 { if l.ProgressMax == 0 {
l.Lv = Lv l.Lv = lv
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(Lv, l.BonusNum) l.ProgressMax = limitedTimeEventCfg.GetProgressMax(lv, l.BonusNum)
} }
if !l.First { if !l.First {
l.First = true l.First = true
@ -115,25 +114,25 @@ func (l *LimitedTimeEventMod) InitData(Lv int) {
} }
if len(l.ProgressReward) == 0 { if len(l.ProgressReward) == 0 {
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv) SelectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv) BonusLv := limitedTimeEventCfg.GetBonusLv(lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv) RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
l.fillProgressReward(RandMap, SelectNum) l.fillProgressReward(RandMap, SelectNum)
} }
} }
func (l *LimitedTimeEventMod) ZeroUpdate(Lv int) { func (l *LimitedTimeEventMod) ZeroUpdate(lv int) {
if !l.FirstReward { if !l.FirstReward {
return return
} }
l.Lv = Lv l.Lv = lv
l.BonusNum = 0 l.BonusNum = 0
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(Lv, l.BonusNum) l.ProgressMax = limitedTimeEventCfg.GetProgressMax(lv, l.BonusNum)
} }
// 判断限时事件是否存在 // 判断限时事件是否存在
func (l *LimitedTimeEventMod) CheckExist(EventId int) bool { func (l *LimitedTimeEventMod) CheckExist(eventId int) bool {
info, ok := l.EventList[EventId] info, ok := l.EventList[eventId]
if !ok { if !ok {
return false return false
} }
@ -142,16 +141,15 @@ func (l *LimitedTimeEventMod) CheckExist(EventId int) bool {
} }
// 触发限时事件 // 触发限时事件
func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) { func (l *LimitedTimeEventMod) Trigger(lv int) (int, []int, []int) {
if Lv < 4 { if lv < 4 {
return 0, nil, nil return 0, nil, nil
} }
TriggerEvent := limitedTimeEventCfg.GetLimitedTimeEventCfg() triggerEvent := limitedTimeEventCfg.GetLimitedTimeEventCfg()
TimeoutEvent := make([]int, 0) timeoutEvent := make([]int, 0)
AddEvent := make([]int, 0) addEvent := make([]int, 0)
Now := GoUtil.Now() now := GoUtil.Now()
for _, v := range triggerEvent {
for _, v := range TriggerEvent {
if _, ok := l.Triggered[v.Id]; ok { //不重复触发 if _, ok := l.Triggered[v.Id]; ok { //不重复触发
continue continue
} }
@ -159,57 +157,54 @@ func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) {
info.Remian += int64(v.Duration) info.Remian += int64(v.Duration)
} else { } else {
LTEInfo := &LTEInfo{ LTEInfo := &LTEInfo{
StartT: Now, StartT: now,
Remian: int64(v.Duration), Remian: int64(v.Duration),
} }
initEventInfo(LTEInfo, v.EventId) initEventInfo(LTEInfo, v.EventId)
l.EventList[v.EventId] = LTEInfo l.EventList[v.EventId] = LTEInfo
AddEvent = append(AddEvent, v.EventId) addEvent = append(addEvent, v.EventId)
} }
l.Triggered[v.Id] = struct{}{} l.Triggered[v.Id] = struct{}{}
} }
Remain := 0 remain := 0
//删除过期事件 //删除过期事件
for k, v := range l.EventList { for k, v := range l.EventList {
EndTime := v.StartT + v.Remian endTime := v.StartT + v.Remian
if k == EVENT_TYPE_CAT_TRICK { if endTime <= now {
EndTime += 5 * 60 // 猫咪戏法事件显示时间为5分钟
}
if EndTime <= Now {
delete(l.EventList, k) delete(l.EventList, k)
TimeoutEvent = append(TimeoutEvent, k) timeoutEvent = append(timeoutEvent, k)
continue continue
} }
NowRemain := (v.StartT + v.Remian) - Now nowRemain := (v.StartT + v.Remian) - now
if Remain > 0 { if remain > 0 {
Remain = min(Remain, int(NowRemain)) remain = min(remain, int(nowRemain))
} else { } else {
Remain = int(NowRemain) remain = int(nowRemain)
} }
} }
return Remain, TimeoutEvent, AddEvent return remain, timeoutEvent, addEvent
} }
// 增加限时事件 // 增加限时事件
func (l *LimitedTimeEventMod) AddEvent(EventId, Duration int) int64 { func (l *LimitedTimeEventMod) AddEvent(eventId, duration int) int64 {
v, ok := l.EventList[EventId] v, ok := l.EventList[eventId]
if EventId == EVENT_TYPE_CAT_DAY_SALE { if eventId == EVENT_TYPE_CAT_DAY_SALE {
l.LastCatDaySale = GoUtil.Now() l.LastCatDaySale = GoUtil.Now()
} }
if ok && v.StartT+v.Remian > GoUtil.Now() { if ok && v.StartT+v.Remian > GoUtil.Now() {
// 事件未过期 // 事件未过期
v.Remian += int64(Duration) v.Remian += int64(duration)
addEventInfo(v, EventId, Duration) addEventInfo(v, eventId, duration)
} else { } else {
Event := &LTEInfo{ Event := &LTEInfo{
Remian: int64(Duration), Remian: int64(duration),
StartT: GoUtil.Now(), StartT: GoUtil.Now(),
} }
initEventInfo(Event, EventId) initEventInfo(Event, eventId)
l.EventList[EventId] = Event 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{}) l.Triggered = make(map[int]struct{})
} }
func (l *LimitedTimeEventMod) GetMoneyCatReward(ChessList []int) []*item.Item { func (l *LimitedTimeEventMod) GetMoneyCatReward(chessList []int) []*item.Item {
L := l.EventList[EVENT_TYPE_MONEY_CAT] eventInfo := l.EventList[EVENT_TYPE_MONEY_CAT]
if L == nil { if eventInfo == nil {
return nil
}
star := mergeDataCfg.GetMergeStar(chessList)
d, ok := eventInfo.D.(*MoneyCat)
if !ok {
return nil return nil
} }
Star := mergeDataCfg.GetMergeStar(ChessList)
d := L.D.(*MoneyCat)
mul := d.Mul mul := d.Mul
maxId := limitedTimeEventCfg.GetMoneyCatMax()
MaxId := limitedTimeEventCfg.GetMoneyCatMax() nextId := min(d.Id+1, maxId)
NextId := min(d.Id+1, MaxId) nextMul, Cd := limitedTimeEventCfg.GetMoneyCat(nextId)
NextMul, Cd := limitedTimeEventCfg.GetMoneyCat(NextId) d.Id = nextId
d.Id = NextId d.Mul = nextMul
d.Mul = NextMul
d.EndTime = GoUtil.Now() + int64(Cd) d.EndTime = GoUtil.Now() + int64(Cd)
Star = int(math.Ceil(float64(Star) * (mul - 1))) star = int(math.Ceil(float64(star) * (mul - 1)))
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: star}}
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: Star}}
} }
func (l *LimitedTimeEventMod) BackData() *msg.ResLimitEvent { func (l *LimitedTimeEventMod) BackData() *msg.ResLimitEvent {
Res := &msg.ResLimitEvent{} res := &msg.ResLimitEvent{}
EventList := make(map[int32]*msg.LimitEvent) eventList := make(map[int32]*msg.LimitEvent)
for k, v := range l.EventList { for k, v := range l.EventList {
EventList[int32(k)] = getLimitEventMsg(k, v) eventList[int32(k)] = getLimitEventMsg(k, v)
} }
Res.LimitEventList = EventList res.LimitEventList = eventList
return Res return res
} }
func (l *LimitedTimeEventMod) ProgressBackData() *msg.ResLimitEventProgress { 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 { func (l *LimitedTimeEventMod) GetMeteorReward(virtualEnergy int) []*item.Item {
energy := order.GetVirtualEnergy(MergeList, EmitList) newStar := int(max(math.Ceil(float64(virtualEnergy)/0.36*0.1), 1))
NewStar := int(max(math.Ceil(float64(energy)/0.36*0.1), 1)) return []*item.Item{{Id: item.ITEM_STAR_ID, Num: newStar}}
return []*item.Item{{Id: item.ITEM_STAR_ID, Num: NewStar}}
} }
// 获取宝箱雨奖励 // 获取宝箱雨奖励
func (l *LimitedTimeEventMod) GetChestReward(MergeList, EmitList []int) []*item.Item { func (l *LimitedTimeEventMod) GetChestReward(virtualEnergy int) []*item.Item {
energy := order.GetVirtualEnergy(MergeList, EmitList) star := math.Ceil(float64(virtualEnergy) / 10 / 2.5)
star := math.Ceil(float64(energy) / 10 / 2.5)
return []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, int(star))} 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") return 0, nil, fmt.Errorf("no dash times")
} }
limitInfo.Info["Times"] = times - 1 limitInfo.Info["Times"] = times - 1
ProbList := limitedTimeEventCfg.GetSenceJackpotProb() probList := limitedTimeEventCfg.GetSenceJackpotProb()
Id := GoUtil.RandMap(ProbList) id := GoUtil.RandMap(probList)
Items := limitedTimeEventCfg.GetSenceJackpotReward(Id) items := limitedTimeEventCfg.GetSenceJackpotReward(id)
if len(Items) > 1 { 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) { 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 { if !ok {
return nil, fmt.Errorf("FastProduce event not exist") return nil, fmt.Errorf("FastProduce event not exist")
} }
Now := GoUtil.Now() now := GoUtil.Now()
if Now < GoUtil.Int64(Event.Info["NextPlay"]) { if now < GoUtil.Int64(event.Info["NextPlay"]) {
return nil, fmt.Errorf("FastProduce CD") return nil, fmt.Errorf("FastProduce CD")
} }
return limitedTimeEventCfg.GetFastProduceReward(Energy), nil return limitedTimeEventCfg.GetFastProduceReward(Energy), nil
} }
func (l *LimitedTimeEventMod) ResetFastProduceCD() { func (l *LimitedTimeEventMod) ResetFastProduceCD() {
Event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE] event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
if !ok { if !ok {
return return
} }
Event.Info["NextPlay"] = 0 event.Info["NextPlay"] = 0
} }
func (l *LimitedTimeEventMod) GetFastProduceInfo() (int64, int) { func (l *LimitedTimeEventMod) GetFastProduceInfo() (int64, int) {
Event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE] event, ok := l.EventList[EVENT_TYPE_FAST_PRODUCE]
if !ok { if !ok {
return 0, 0 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) { func (l *LimitedTimeEventMod) AddProgress(lv int) {
UnlockLv := limitedTimeEventCfg.GetUnlockLv() unlockLv := limitedTimeEventCfg.GetUnlockLv()
if Lv < UnlockLv { if lv < unlockLv {
return return
} }
l.Progress++ l.Progress++
} }
// 选择进度奖励 // 选择进度奖励
func (l *LimitedTimeEventMod) SelectProgressReward(Id, Lv, Energy int) ([]*item.Item, int, int, map[int]int, error) { func (l *LimitedTimeEventMod) SelectProgressReward(id, lv, energy int) ([]*item.Item, int, int, map[int]int, error) {
RewardId, ok := l.ProgressReward[Id] rewardId, ok := l.ProgressReward[id]
RewardList := l.ProgressReward rewardList := l.ProgressReward
if !ok { if !ok {
return nil, 0, 0, nil, fmt.Errorf("RewardId not exist") return nil, 0, 0, nil, fmt.Errorf("RewardId not exist")
} }
Item := limitedTimeEventCfg.GetProgressReward(RewardId) items := limitedTimeEventCfg.GetProgressReward(rewardId)
OrderNum := l.ProgressMax orderNum := l.ProgressMax
l.LastSelect = RewardId l.LastSelect = rewardId
l.ProgressReward = make(map[int]int) l.ProgressReward = make(map[int]int)
l.Progress = 0 l.Progress = 0
l.BonusNum++ l.BonusNum++
l.ProgressMax = limitedTimeEventCfg.GetProgressMax(l.Lv, l.BonusNum) l.ProgressMax = limitedTimeEventCfg.GetProgressMax(l.Lv, l.BonusNum)
// 重新生成进度奖励 // 重新生成进度奖励
SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv) selectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv) bonusLv := limitedTimeEventCfg.GetBonusLv(lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv) randMap := limitedTimeEventCfg.GetProgressRewardRand(bonusLv)
// 体力小于200 high roller事件不进池子 // 体力小于200 high roller事件不进池子
if Energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() { if energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER)) delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
} }
if GoUtil.Now()-l.LastCatDaySale < limitedTimeEventCfg.GetCatSaleCD() { 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 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) selectNum := limitedTimeEventCfg.GetProgressSelectNum(lv)
BonusLv := limitedTimeEventCfg.GetBonusLv(Lv) bonusLv := limitedTimeEventCfg.GetBonusLv(lv)
RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv) randMap := limitedTimeEventCfg.GetProgressRewardRand(bonusLv)
// 体力小于200 high roller事件不进池子 // 体力小于200 high roller事件不进池子
if Energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() { if energy < limitedTimeEventCfg.GetHighRollerNeedEnergy() {
delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER)) delete(randMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_HIGH_ROLLER))
} }
if GoUtil.Now()-l.LastCatDaySale < limitedTimeEventCfg.GetCatSaleCD() { 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 return l.ProgressReward
} }
// fillProgressReward 随机填充进度奖励（最多尝试10次避免与上次相同） // fillProgressReward 随机填充进度奖励（最多尝试10次避免与上次相同）
func (l *LimitedTimeEventMod) fillProgressReward(RandMap map[int]int, SelectNum int) { func (l *LimitedTimeEventMod) fillProgressReward(randMap map[int]int, selectNum int) {
LastOption := l.LastOption lastOption := l.LastOption
var r []int var r []int
for n := 0; n < 10; n++ { for n := 0; n < 10; n++ {
r = GoUtil.RandMapNum(RandMap, SelectNum) r = GoUtil.RandMapNum(randMap, selectNum)
Id := 1 Id := 1
for _, v := range r { for _, v := range r {
l.ProgressReward[Id] = v l.ProgressReward[Id] = v
Id++ Id++
} }
if !GoUtil.SliceEqual(LastOption, r) { if !GoUtil.SliceEqual(lastOption, r) {
break break
} }
} }
@ -411,33 +405,39 @@ func (l *LimitedTimeEventMod) RemoveSuperOrder() bool {
return false return false
} }
func (l *LimitedTimeEventMod) LuckyCat(ChessId int) error { func (l *LimitedTimeEventMod) LuckyCat(chessId int) error {
L := l.EventList[EVENT_TYPE_LUCKY_CAT] L := l.EventList[EVENT_TYPE_LUCKY_CAT]
if L == nil { if L == nil {
return fmt.Errorf("LuckyCat event not exist") return fmt.Errorf("LuckyCat event not exist")
} }
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(L.Remian)) maxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(L.Remian))
d := L.D.(*LuckyCat) d, ok := L.D.(*LuckyCat)
Lv := mergeDataCfg.GetLvById(ChessId) if !ok {
Earn := math.Pow(2, float64(Lv-1)) return fmt.Errorf("LuckyCat event data error")
d.Earnings += int(Earn) }
if d.Earnings >= MaxEarning { 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) delete(l.EventList, EVENT_TYPE_LUCKY_CAT)
} }
return nil return nil
} }
func (l *LimitedTimeEventMod) AddCatTrickEnergy(Energy int) { func (l *LimitedTimeEventMod) AddCatTrickEnergy(energy int) {
Event, ok := l.EventList[EVENT_TYPE_CAT_TRICK] event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
if !ok { if !ok {
return return
} }
if Event.Remian+Event.StartT <= GoUtil.Now() { if event.Remian+event.StartT <= GoUtil.Now() {
return return
} }
// 事件未过期 // 事件未过期
d := Event.D.(*CatTrick) d, ok := event.D.(*CatTrick)
d.Energy += Energy if !ok {
return
}
d.Energy += energy
} }
func (l *LimitedTimeEventMod) SubPaybackDay() error { func (l *LimitedTimeEventMod) SubPaybackDay() error {
@ -445,120 +445,123 @@ func (l *LimitedTimeEventMod) SubPaybackDay() error {
} }
func (l *LimitedTimeEventMod) GetCatTrickReward() ([]*item.Item, 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 { if !ok {
return nil, fmt.Errorf("CatTrick event not exist") return nil, fmt.Errorf("CatTrick event not exist")
} }
d := Event.D.(*CatTrick) d, ok := event.D.(*CatTrick)
if d.Energy < 100 { 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") return nil, fmt.Errorf("CatTrick energy not enough")
} }
d.Energy -= 100 count := d.Energy / energy
d.Energy = d.Energy % energy
// TODO 放到配置中 // TODO 放到配置中
return []*item.Item{ return []*item.Item{
{Id: item.ITEM_DIAMOND_ID, Num: 5}, {Id: item.ITEM_DIAMOND_ID, Num: diamond * count},
}, nil }, nil
} }
// #region 事件信息初始化 // #region 事件信息初始化
func initEventInfo(E *LTEInfo, EventType int) { func initEventInfo(event *LTEInfo, eventType int) {
switch EventType { switch eventType {
case EVENT_TYPE_SENCE_DASH: case EVENT_TYPE_SENCE_DASH:
E.Info = map[string]interface{}{ event.Info = map[string]interface{}{
"Times": 0, "Times": 0,
} }
case EVENT_TYPE_FAST_PRODUCE: case EVENT_TYPE_FAST_PRODUCE:
E.Info = map[string]interface{}{ event.Info = map[string]interface{}{
"Times": 0, "Times": 0,
"NextPlay": 0, "NextPlay": 0,
} }
case EVENT_TYPE_MONEY_CAT: case EVENT_TYPE_MONEY_CAT:
E.D = &MoneyCat{ event.D = &MoneyCat{
Id: 1, Id: 1,
Mul: 1.1, Mul: 1.1,
} }
case EVENT_TYPE_LUCKY_CAT: case EVENT_TYPE_LUCKY_CAT:
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(E.Remian)) MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(event.Remian))
E.D = &LuckyCat{ event.D = &LuckyCat{
MaxEarings: MaxEarning, MaxEarings: MaxEarning,
} }
case EVENT_TYPE_PAYBACK_DAY: case EVENT_TYPE_PAYBACK_DAY:
E.D = &PaybackDay{ event.D = &PaybackDay{
Count: limitedTimeEventCfg.GetPaybackDay(), Count: limitedTimeEventCfg.GetPaybackDay(),
} }
case EVENT_TYPE_CAT_TRICK: case EVENT_TYPE_CAT_TRICK:
Type := limitedTimeEventCfg.GetCatTrickType(int(E.Remian)) event.D = &CatTrick{}
E.D = &CatTrick{
List: []CatTrickInfo{
{
Id: 1,
Type: Type,
},
},
}
} }
} }
func addEventInfo(E *LTEInfo, EventType, Duration int) { func addEventInfo(event *LTEInfo, eventType, duration int) {
switch EventType { 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),
})
case EVENT_TYPE_LUCKY_CAT: case EVENT_TYPE_LUCKY_CAT:
MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(Duration) MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(duration)
d := E.D.(*LuckyCat) d, ok := event.D.(*LuckyCat)
if !ok {
return
}
d.MaxEarings += MaxEarning d.MaxEarings += MaxEarning
case EVENT_TYPE_PAYBACK_DAY: case EVENT_TYPE_PAYBACK_DAY:
d := E.D.(*PaybackDay) d, ok := event.D.(*PaybackDay)
if !ok {
return
}
d.Count += limitedTimeEventCfg.GetPaybackDay() d.Count += limitedTimeEventCfg.GetPaybackDay()
} }
} }
func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent { func getLimitEventMsg(eType int, event *LTEInfo) *msg.LimitEvent {
Cd := 0 cd := 0
Mul := 0.0 mul := 0.0
Param := make(map[string]int32) param := make(map[string]int32)
ShowTime := int32(e.StartT + e.Remian) showTime := int32(event.StartT + event.Remian)
EndTime := int32(e.StartT + e.Remian) endTime := int32(event.StartT + event.Remian)
switch t { switch eType {
case EVENT_TYPE_FAST_PRODUCE: case EVENT_TYPE_FAST_PRODUCE:
NextPlay := GoUtil.Int64(e.Info["NextPlay"]) nextPlay := GoUtil.Int64(event.Info["NextPlay"])
Cd = int(max(NextPlay-GoUtil.Now(), 0)) cd = int(max(nextPlay-GoUtil.Now(), 0))
case EVENT_TYPE_MONEY_CAT: case EVENT_TYPE_MONEY_CAT:
d := e.D.(*MoneyCat) d, ok := event.D.(*MoneyCat)
Cd = int(d.EndTime) if !ok {
Mul = d.Mul return nil
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分钟
} }
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: case EVENT_TYPE_PAYBACK_DAY:
d := e.D.(*PaybackDay) d, ok := event.D.(*PaybackDay)
Param[msg.LimitEventParam_PAYBACK_DAY_COUNT.String()] = int32(d.Count) if !ok {
return nil
}
param[msg.LimitEventParam_PAYBACK_DAY_COUNT.String()] = int32(d.Count)
case EVENT_TYPE_SENCE_DASH: case EVENT_TYPE_SENCE_DASH:
Times := GoUtil.Int(e.Info["Times"]) times := GoUtil.Int(event.Info["Times"])
Param[msg.LimitEventParam_SENCE_DASH_TIMES.String()] = int32(Times) param[msg.LimitEventParam_SENCE_DASH_TIMES.String()] = int32(times)
} }
return &msg.LimitEvent{ return &msg.LimitEvent{
EndTime: EndTime, EndTime: endTime,
ShowTime: ShowTime, ShowTime: showTime,
Cd: int32(Cd), Cd: int32(cd),
Mul: float32(Mul), Mul: float32(mul),
StartTime: int32(e.StartT), StartTime: int32(event.StartT),
Param: Param, Param: param,
} }
} }
@ -575,13 +578,13 @@ func (l *LimitedTimeEventMod) GetCatDaySaleEndTime() int64 {
} }
func (l *LimitedTimeEventMod) AddSenceDashTimes() bool { func (l *LimitedTimeEventMod) AddSenceDashTimes() bool {
SenceInfo, ok := l.EventList[EVENT_TYPE_SENCE_DASH] senceInfo, ok := l.EventList[EVENT_TYPE_SENCE_DASH]
if !ok { if !ok {
return false return false
} }
if SenceInfo.Info == nil { if senceInfo.Info == nil {
return false return false
} }
SenceInfo.Info["Times"] = GoUtil.Int(SenceInfo.Info["Times"]) + 1 senceInfo.Info["Times"] = GoUtil.Int(senceInfo.Info["Times"]) + 1
return true 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 { func (m *MiningMod) Login(id int) int {
OldId := m.Id oldId := m.Id
if Id == 0 { if id == 0 {
m.Id = 0 m.Id = 0
return OldId return oldId
} }
if m.Id == Id { if m.Id == id {
return 0 return 0
} }
m.Id = Id m.Id = id
m.Map = make(map[int32]string) m.Map = make(map[int32]string)
m.Gem = nil m.Gem = nil
m.Pass = 1 m.Pass = 1
m.Mining = 0 m.Mining = 0
m.InitItem = false m.InitItem = false
return OldId return oldId
} }
func (m *MiningMod) GetInitItem() []*item.Item { func (m *MiningMod) GetInitItem() []*item.Item {
@ -55,8 +55,8 @@ func (m *MiningMod) GetInitItem() []*item.Item {
return nil return nil
} }
func (m *MiningMod) ZeroUpdate(Id int) { func (m *MiningMod) ZeroUpdate(id int) {
m.Login(Id) m.Login(id)
} }
func (m *MiningMod) GetMap() map[int32]string { func (m *MiningMod) GetMap() map[int32]string {
@ -75,7 +75,7 @@ func (m *MiningMod) GetMining() int {
return m.Mining 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) AreaNum := miningCfg.GetPassArea(m.Pass)
if AreaNum == 0 { if AreaNum == 0 {
return nil, fmt.Errorf("pass is not exist") 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 { if m.Mining+1 > AreaNum {
return nil, fmt.Errorf("mining is full") return nil, fmt.Errorf("mining is full")
} }
if Gem > 0 { if gem > 0 {
GemList := miningCfg.GetPassGem(m.Pass) GemList := miningCfg.GetPassGem(m.Pass)
if len(m.Gem)+1 > len(GemList) { if len(m.Gem)+1 > len(GemList) {
return nil, fmt.Errorf("gem is full") return nil, fmt.Errorf("gem is full")
} }
m.Map = Map m.Map = miningMap
m.Mining++ m.Mining++
m.Gem = append(m.Gem, Gem) m.Gem = append(m.Gem, gem)
return nil, nil return nil, nil
} }
m.Map = Map m.Map = miningMap
m.Mining++ m.Mining++
Items := miningCfg.GetRandItem() items := miningCfg.GetRandItem()
return Items, nil return items, nil
} }
func (m *MiningMod) GetReward(orderFactor int) ([]*item.Item, int, error) { func (m *MiningMod) GetReward(orderFactor int) ([]*item.Item, int, error) {
GemList := miningCfg.GetPassGem(m.Pass) gemList := miningCfg.GetPassGem(m.Pass)
if len(m.Gem) < len(GemList) { if len(m.Gem) < len(gemList) {
return nil, 0, fmt.Errorf("gem is not full") return nil, 0, fmt.Errorf("gem is not full")
} }
Items := miningCfg.GetPassItem(m.Pass, orderFactor) items := miningCfg.GetPassItem(m.Pass, orderFactor)
m.Pass++ m.Pass++
Ming := m.Mining mining := m.Mining
m.Mining = 0 m.Mining = 0
m.Map = nil m.Map = nil
m.Gem = 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 // 玩家登录处理 HANDLE_TYPE_LOGIN // 玩家登录处理
SERVER_PLAYER_SYNC_LOGOUT_MSG // 玩家处理完离线消息 SERVER_PLAYER_SYNC_LOGOUT_MSG // 玩家处理完离线消息
HANDLE_TYPE_ACTIVITY_RELOAD // 活动重新加载
) )
const ( const (
@ -396,6 +398,8 @@ func formatType(t int) string {
return "player_login" return "player_login"
case SERVER_PLAYER_SYNC_LOGOUT_MSG: case SERVER_PLAYER_SYNC_LOGOUT_MSG:
return "player_sync_logout" return "player_sync_logout"
case HANDLE_TYPE_ACTIVITY_RELOAD:
return "activity_reload"
default: default:
return fmt.Sprintf("Unknown(%d)", t) 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) { func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
ItemList := make([]*item.Item, 0) items := make([]*item.Item, 0)
MergeList := make([]int, 0) mergeList := make([]int, 0)
if v, ok := o.OrderList[id]; ok { if v, ok := o.OrderList[id]; ok {
o.LastOrder = v o.LastOrder = v
delete(o.OrderList, id) delete(o.OrderList, id)
Star := 0 star := 0
for _, v := range v.MergeId { for _, v := range v.MergeId {
Star += mergeDataCfg.GetStarById(v) star += mergeDataCfg.GetStarById(v)
} }
ItemList = v.Items items = v.Items
if v.Type == Guide_type { if v.Type == Guide_type {
return nil, v.MergeId, v.Type, 0, nil 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) { if GoUtil.InArray(79, o.FinishOrder) {
o.AutoEmit, _ = GoUtil.PopStringElemSlice(o.AutoEmit, "I") 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 { func (o *OrderMod) CreateOrderSeed(Order *Order) error {
for k, v := range o.OrderPool { for k, v := range o.OrderPool {
@ -145,41 +145,41 @@ func (o *OrderMod) CreateOrderSeed(Order *Order) error {
return nil 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) o.OrderPool = make(map[int]*Order)
index := 1 index := 1
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_LOW) chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_LOW)
if len(ChessList) == 0 { if len(chessList) == 0 {
continue continue
} }
o.OrderPool[index] = &Order{ o.OrderPool[index] = &Order{
MergeId: ChessList, MergeId: chessList,
Diff: DIFF_LOW, Diff: DIFF_LOW,
Timestamp: int64(index), Timestamp: int64(index),
} }
index++ index++
} }
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_MID) chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_MID)
if len(ChessList) == 0 { if len(chessList) == 0 {
continue continue
} }
o.OrderPool[index] = &Order{ o.OrderPool[index] = &Order{
MergeId: ChessList, MergeId: chessList,
Diff: DIFF_LOW, Diff: DIFF_MID,
Timestamp: int64(index), Timestamp: int64(index),
} }
index++ index++
} }
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_HIGH) chessList := o.CreateNormalOrderSeed(lv, emit, energyMul, DIFF_HIGH)
if len(ChessList) == 0 { if len(chessList) == 0 {
continue continue
} }
o.OrderPool[index] = &Order{ o.OrderPool[index] = &Order{
MergeId: ChessList, MergeId: chessList,
Diff: DIFF_LOW, Diff: DIFF_HIGH,
Timestamp: int64(index), Timestamp: int64(index),
} }
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 { func (o *OrderMod) TriggerOrder(lv int, oType string, emit []int, energyMul int) error {
TriggerOrderList := orderCfg.GetStartOrderList() triggerOrderList := orderCfg.GetStartOrderList()
FixedOrder := 0 fixedOrder := 0
for _, v := range o.OrderList { for _, v := range o.OrderList {
if v.Type == Fixed_type { 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 { 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) { if GoUtil.InArray(v.Id, o.FinishOrder) {
continue continue
} }
orderInfo, exists := OrderList[v.Id] orderInfo, exists := orderList[v.Id]
if exists && v.Preview == "" { if exists && v.Preview == "" {
continue continue
} }
// 预览条件不为空且未存在且未完成 // 预览条件不为空且未存在且未完成
if v.Preview != "" && !exists && !GoUtil.InArray(v.Id, o.FinishOrder) { 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) o.addFixOrder(v.Id, v.MergeList, Preview_type, v.Items)
} }
} }
if v.Appear != "" { if v.Appear != "" {
if o.CheckCondition(lv, v.Appear, Type, Emit, FixedOrder, OrderList) { if o.CheckCondition(lv, v.Appear, oType, emit, fixedOrder, orderList) {
Type := Fixed_type oType1 := Fixed_type
OrderType := orderCfg.GetOrderType(v.Id) orderType := orderCfg.GetOrderType(v.Id)
if OrderType != 0 { if orderType != 0 {
Type = OrderType oType1 = orderType
} }
if exists { if exists {
orderInfo.Type = Fixed_type orderInfo.Type = Fixed_type
o.OrderList[v.Id] = orderInfo o.OrderList[v.Id] = orderInfo
} else { } else {
o.addFixOrder(v.Id, v.MergeList, Type, v.Items) o.addFixOrder(v.Id, v.MergeList, oType1, v.Items)
if v.Id == 78 { if v.Id == 78 {
o.Retire("D") o.Retire("D")
o.AutoEmit = append(o.AutoEmit, "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 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, "|") r1 := strings.Split(condition, "|")
for _, v := range r1 { for _, v := range r1 {
r2 := strings.Split(v, "=") 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 { if !GoUtil.InArray(id, o.FinishOrder) && id != 0 {
return false return false
} }
if id == 0 && Type != TRIGGER_TYPE_ORDER { if id == 0 && cType != TRIGGER_TYPE_ORDER {
return false return false
} }
case "Lv": case "Lv":
@ -262,34 +262,34 @@ func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, Fi
} }
case "OrderNum": case "OrderNum":
id := GoUtil.Int(r2[1]) id := GoUtil.Int(r2[1])
if FixedOrder != id { if fixedOrder != id {
return false return false
} }
case "Order": case "Order":
id := GoUtil.Int(r2[1]) id := GoUtil.Int(r2[1])
_, ok := OrderList[id] _, ok := orderList[id]
if !GoUtil.InArray(id, o.FinishOrder) && !ok { if !GoUtil.InArray(id, o.FinishOrder) && !ok {
return false return false
} }
case "Emit": case "Emit":
Class := []string{} class := []string{}
for _, v := range Emit { for _, v := range emit {
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 return false
} }
case "EmitMax": case "EmitMax":
Class := []string{} class := []string{}
for _, v := range Emit { for _, v := range emit {
EmitLv := mergeDataCfg.GetLvById(v) emitLv := mergeDataCfg.GetLvById(v)
MaxLv := mergeDataCfg.GetMaxLvById(v) maxLv := mergeDataCfg.GetMaxLvById(v)
if EmitLv < MaxLv { if emitLv < maxLv {
continue 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 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 { func (o *OrderMod) CreateOrder(lv int, emit []int, energyMul, orderType int) error {
if len(Emit) == 0 { if len(emit) == 0 {
return nil return nil
} }
/// 生成优先订单 // 生成优先订单
if o.CreatePriorityOrder(lv, Emit) { if o.CreatePriorityOrder(lv, emit) {
return nil return nil
} }
err := o.CreateNormalOrder(lv, Emit, EnergyMul, OrderType) err := o.CreateNormalOrder(lv, emit, energyMul, orderType)
return err return err
} }
func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool { func (o *OrderMod) CreatePriorityOrder(lv int, emit []int) bool {
if len(Emit) == 0 { if len(emit) == 0 {
return false return false
} }
ChessList := make(map[string]int) chessList := make(map[string]int)
for _, v := range o.OrderList { for _, v := range o.OrderList {
for _, vv := range v.MergeId { for _, vv := range v.MergeId {
Color := mergeDataCfg.GetColorById(vv) color := mergeDataCfg.GetColorById(vv)
if vvv, ok := ChessList[Color]; ok { if vvv, ok := chessList[color]; ok {
OldLv := mergeDataCfg.GetLvById(vvv) oldLv := mergeDataCfg.GetLvById(vvv)
NewLv := mergeDataCfg.GetLvById(vv) newLv := mergeDataCfg.GetLvById(vv)
if NewLv > OldLv { if newLv > oldLv {
ChessList[Color] = vv chessList[color] = vv
} }
} else { } else {
ChessList[Color] = vv chessList[color] = vv
} }
} }
} }
for v := range Emit { for v := range emit {
Produce := mergeDataCfg.GetEmitProduceChessType(v) produce := mergeDataCfg.GetEmitProduceChessType(v)
if len(Produce) < 2 { if len(produce) < 2 {
continue continue
} }
for k, v := range ChessList { for k, v := range chessList {
if k == Produce[0] { if k == produce[0] {
MaxLv := mergeDataCfg.GetMaxLvById(v) maxLv := mergeDataCfg.GetMaxLvById(v)
DurLv := int((MaxLv - 3) * 1 / 3) durLv := int((maxLv - 3) * 1 / 3)
ChessLv := mergeDataCfg.GetLvById(v) chessLv := mergeDataCfg.GetLvById(v)
if ChessLv > (3 + DurLv*2) { if chessLv > (3 + durLv*2) {
B := GoUtil.RandMap(map[int]int{0: 80, 1: 20}) B := GoUtil.RandMap(map[int]int{0: 80, 1: 20})
if B == 1 { if B == 1 {
NewColor := GoUtil.RandStringSlice(Produce[1:]) newColor := GoUtil.RandStringSlice(produce[1:])
DiffLv := GoUtil.RandMap(map[int]int{DIFF_LOW: 70, DIFF_MID: 30}) diffLv := GoUtil.RandMap(map[int]int{DIFF_LOW: 70, DIFF_MID: 30})
NewChessId := 0 newChessId := 0
switch DiffLv { switch diffLv {
case DIFF_LOW: case DIFF_LOW:
NewLv := GoUtil.RandNum(4, 3+DurLv) newLv := GoUtil.RandNum(4, 3+durLv)
NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor) newChessId = mergeDataCfg.GetChessIdByLvAndColor(newLv, newColor)
case DIFF_MID: case DIFF_MID:
NewLv := GoUtil.RandNum(4+DurLv, 3+DurLv*2) newLv := GoUtil.RandNum(4+durLv, 3+durLv*2)
NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor) newChessId = mergeDataCfg.GetChessIdByLvAndColor(newLv, newColor)
} }
if NewChessId == 0 { if newChessId == 0 {
continue continue
} }
o.addOrder([]int{NewChessId}, DiffLv, Common_type) o.addOrder([]int{newChessId}, diffLv, Common_type)
return true 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 { func (o *OrderMod) CreateNormalOrderSeed(lv int, emit []int, energyMul int, diff int) []int {
if len(Emit) == 0 { if len(emit) == 0 {
return nil return nil
} }
randNum := 0 randNum := 0
@ -379,7 +379,7 @@ func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff
break break
} }
randNum++ randNum++
mergeList, _, err = randOrderChessSeed(o, Emit, EnergyMul, Diff) mergeList, _, err = randOrderChessSeed(o, emit, energyMul, diff)
if err != nil { if err != nil {
continue 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 { func (o *OrderMod) CreateNormalOrder(lv int, emit []int, energyMul, orderType int) error {
if len(Emit) == 0 { if len(emit) == 0 {
return nil return nil
} }
randNum := 0 randNum := 0
@ -413,7 +413,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType in
break break
} }
randNum++ randNum++
mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul, OrderType) mergeList, OrderDiff, err = randOrderChess(o, lv, emit, energyMul, orderType)
if err != nil { if err != nil {
continue continue
} }
@ -435,7 +435,54 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType in
return nil 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 return nil
} }
@ -444,16 +491,16 @@ func (o *OrderMod) DeleteOrder(OrderId int) {
} }
// 生成超级订单 // 生成超级订单
func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error { func (o *OrderMod) CreateSuperOrder(lv int, emit []int, energyMul int) error {
if len(Emit) == 0 { if len(emit) == 0 {
return nil return nil
} }
randNum := 0 randNum := 0
mergeList := make([]int, 0) mergeList := make([]int, 0)
// 忽视上一个订单的难度，生成此订单时，难度默认为50%概率的中难度、50%概率的高难度 // 忽视上一个订单的难度，生成此订单时，难度默认为50%概率的中难度、50%概率的高难度
OrderDiff := DIFF_MID orderDiff := DIFF_MID
if GoUtil.RandNum(1, 100) <= 50 { if GoUtil.RandNum(1, 100) <= 50 {
OrderDiff = DIFF_HIGH orderDiff = DIFF_HIGH
} }
var err error var err error
for { for {
@ -461,7 +508,7 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
break break
} }
randNum++ randNum++
mergeList, OrderDiff, err = randSuperOrderChess(o, lv, Emit, EnergyMul, OrderDiff) mergeList, orderDiff, err = randSuperOrderChess(o, lv, emit, energyMul, orderDiff)
if err != nil { if err != nil {
continue continue
} }
@ -478,92 +525,92 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
} }
break break
} }
o.addOrder(mergeList, OrderDiff, Super_type) o.addOrder(mergeList, orderDiff, Super_type)
return nil 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++ o.Auto_id++
Order := Order{ Order := Order{
MergeId: ChessList, MergeId: chessList,
Diff: Diff, Diff: diff,
Type: Type, Type: oType,
Timestamp: time.Now().Unix(), Timestamp: time.Now().Unix(),
Items: nil, Items: nil,
} }
o.OrderList[o.Auto_id] = Order o.OrderList[o.Auto_id] = Order
if Type == Common_type { if oType == Common_type {
o.LastNormalOrder = Order o.LastNormalOrder = Order
} }
o.LastDiff = Diff o.LastDiff = diff
return o.Auto_id return o.Auto_id
} }
func (o *OrderMod) AddExtraOrder(ChessList []int) { func (o *OrderMod) AddExtraOrder(chessList []int) {
o.addOrder(ChessList, DIFF_LOW, Extra_type) o.addOrder(chessList, DIFF_LOW, Extra_type)
} }
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) {
o.addFixOrder(Id, ChessList, Type, Items) 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{ Order := Order{
MergeId: ChessList, MergeId: chessList,
Type: Type, Type: oType,
Timestamp: time.Now().Unix(), Timestamp: time.Now().Unix(),
Items: Items, Items: items,
} }
o.OrderList[Id] = Order o.OrderList[Id] = Order
} }
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 {
return o.addPreheatOrder(ChessList, Diff, Type, Items) 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++ o.Auto_id++
Order := Order{ Order := Order{
MergeId: ChessList, MergeId: chessList,
Diff: Diff, Diff: diff,
Type: Type, Type: oType,
Timestamp: time.Now().Unix(), Timestamp: time.Now().Unix(),
Items: Items, Items: items,
} }
o.OrderList[o.Auto_id] = Order o.OrderList[o.Auto_id] = Order
return o.Auto_id return o.Auto_id
} }
func (o *OrderMod) CreateCleanOrder(ChessList []int) bool { func (o *OrderMod) CreateCleanOrder(chessList []int) bool {
o.addOrder(ChessList, DIFF_LOW, Clean_type) o.addOrder(chessList, DIFF_LOW, Clean_type)
return true return true
} }
func (o *OrderMod) CreateCleanOrder2(ChessList []int) bool { func (o *OrderMod) CreateCleanOrder2(chessList []int) bool {
o.addOrder(ChessList, DIFF_LOW, Clean_Order_type) o.addOrder(chessList, DIFF_LOW, Clean_Order_type)
return true return true
} }
func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, EnergyMul, Level int) bool { func (o *OrderMod) CreateExtraOrder(addChess, addNewEmit, chessList []int, energyMul, level int) bool {
BeginExtraEmitId := orderCfg.GetEmitExtraOrder() // 从发射器F系列开始 beginExtraEmitId := orderCfg.GetEmitExtraOrder() // 从发射器F系列开始
b1 := false b1 := false
OrderEmit := 0 orderEmit := 0
MaxLvChess := make(map[int]int) maxLvChess := make(map[int]int)
for _, v := range AddNewEmit { for _, v := range addNewEmit {
Emit_Id := mergeDataCfg.GetEmitId(v) emit_Id := mergeDataCfg.GetEmitId(v)
ok := Emit_Id >= BeginExtraEmitId ok := emit_Id >= beginExtraEmitId
_, ok1 := o.EimtOrder[Emit_Id] _, ok1 := o.EimtOrder[emit_Id]
ChessColor := mergeDataCfg.GetEmitProduceChessType(v) ChessColor := mergeDataCfg.GetEmitProduceChessType(v)
if ok && !ok1 && len(ChessColor) > 0 { if ok && !ok1 && len(ChessColor) > 0 {
b1 = true b1 = true
OrderEmit = v orderEmit = v
o.EimtOrder[Emit_Id] = struct{}{} o.EimtOrder[emit_Id] = struct{}{}
break break
} }
} }
for _, ChessId := range AddChess { for _, ChessId := range addChess {
Lv := mergeDataCfg.GetLvById(ChessId) lv := mergeDataCfg.GetLvById(ChessId)
Type := mergeDataCfg.GetTypeById(ChessId) cType := mergeDataCfg.GetTypeById(ChessId)
if Type != "Product" { if cType != "Product" {
continue continue
} }
MaxLv := mergeDataCfg.GetMaxLvById(ChessId) maxLv := mergeDataCfg.GetMaxLvById(ChessId)
if Lv == MaxLv { if lv == maxLv {
MaxLvChess[ChessId]++ maxLvChess[ChessId]++
} }
} }
b3 := false b3 := false
@ -586,15 +633,15 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
// } // }
//额外订单补充1；CDEG发射器首次合成时，生成其对应2及棋子订单，完成后生成3及，再完成生成4及的； //额外订单补充1；CDEG发射器首次合成时，生成其对应2及棋子订单，完成后生成3及，再完成生成4及的；
if b1 { if b1 {
ChessColor := mergeDataCfg.GetEmitProduceChessType(OrderEmit) chessColor := mergeDataCfg.GetEmitProduceChessType(orderEmit)
if len(ChessColor) == 0 { if len(chessColor) == 0 {
return b1 return b1
} }
ChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+1, ChessColor[0]) chessId := mergeDataCfg.GetChessIdByLvAndColor(energyMul+1, chessColor[0])
if ChessId != 0 { if chessId != 0 {
o.PreheatStep[ChessColor[0]] = 1 o.PreheatStep[chessColor[0]] = 1
Items := PreheatItems[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 return b1 || b3
@ -602,19 +649,19 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
// 返回订单列表 // 返回订单列表
func (o *OrderMod) BackData() *msg.ResOrderList { func (o *OrderMod) BackData() *msg.ResOrderList {
OrderList := make([]*msg.Order, 0) orderList := make([]*msg.Order, 0)
for k, v := range o.OrderList { for k, v := range o.OrderList {
mergeList := GoUtil.IntToInt32(v.MergeId) mergeList := GoUtil.IntToInt32(v.MergeId)
Order := &msg.Order{ order := &msg.Order{
Id: int32(k), Id: int32(k),
ChessId: mergeList, ChessId: mergeList,
Type: int32(v.Type), Type: int32(v.Type),
Items: item.ItemToMsg(v.Items), Items: item.ItemToMsg(v.Items),
} }
OrderList = append(OrderList, Order) orderList = append(orderList, order)
} }
return &msg.ResOrderList{ 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 { for k, v := range o.OrderList {
if v.Type == Preheat_type { // 预热订单 修改倍数时修改棋子等级 if v.Type == Preheat_type { // 预热订单 修改倍数时修改棋子等级
ChessId := v.MergeId[0] chessId := v.MergeId[0]
ChessColor := mergeDataCfg.GetColorById(ChessId) chessColor := mergeDataCfg.GetColorById(chessId)
PreheatStep := o.PreheatStep[ChessColor] preheatStep := o.PreheatStep[chessColor]
NewChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+PreheatStep, ChessColor) newChessId := mergeDataCfg.GetChessIdByLvAndColor(energyMul+preheatStep, chessColor)
if NewChessId == 0 { if newChessId == 0 {
continue continue
} }
delete(o.OrderList, k) delete(o.OrderList, k)
Items, ok := PreheatItems[PreheatStep] items, ok := PreheatItems[preheatStep]
if !ok { 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() maxStep := orderCfg.GetMaxStep()
if o.Step < MaxStep { // 还在新手引导阶段 if o.Step < maxStep { // 还在新手引导阶段
return return
} }
for k, v := range o.OrderList { for k, v := range o.OrderList {
NeedTrigger := false needTrigger := false
for _, vv := range v.MergeId { for _, vv := range v.MergeId {
Lv := mergeDataCfg.GetLvById(vv) lv := mergeDataCfg.GetLvById(vv)
Color := mergeDataCfg.GetColorById(vv) color := mergeDataCfg.GetColorById(vv)
EmitId := GetEmitByColor(Emit, Color) emitId := GetEmitByColor(emit, color)
_, Max := getChesslvRange(EmitId, EnergyMul, o.IsCharge) _, max := getChesslvRange(emitId, energyMul, o.IsCharge)
Adjust := mergeDataCfg.GetAdjust(EmitId, Color, EnergyMul) adjust := mergeDataCfg.GetAdjust(emitId, color, energyMul)
if Lv >= EnergyMul+1 && Lv <= Max-Adjust { if lv >= energyMul+1 && lv <= max-adjust {
continue continue
} }
NeedTrigger = true needTrigger = true
} }
if v.Type != Common_type && v.Type != Pet_type { 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 且该棋子在棋盘上没有 订单棋子等级>n+11 且该棋子在棋盘上没有
则删除该订单，重新生成一个普通订单 则删除该订单，重新生成一个普通订单
*/ */
if NeedTrigger { if needTrigger {
delete(o.OrderList, k) delete(o.OrderList, k)
o.CreateNormalOrder(lv, Emit, EnergyMul, v.Type) o.CreateNormalOrder(lv, emit, energyMul, v.Type)
} }
} }
} }
func (o *OrderMod) Retire(EmitId string) { func (o *OrderMod) Retire(emitId string) {
ChessPool := make([]int, 0) chessPool := make([]int, 0)
Product := mergeDataCfg.GetEmitOrderProduce(EmitId) product := mergeDataCfg.GetEmitOrderProduce(emitId)
for _, v := range o.ChessPool { for _, v := range o.ChessPool {
Color := mergeDataCfg.GetColorById(v) color := mergeDataCfg.GetColorById(v)
if GoUtil.InStringArray(Color, Product) { if GoUtil.InStringArray(color, product) {
continue continue
} }
ChessPool = append(ChessPool, v) chessPool = append(chessPool, v)
} }
o.ChessPool = ChessPool o.ChessPool = chessPool
o.ColorShuffle = nil o.ColorShuffle = nil
} }
func (o *OrderMod) DelOrder(OrderId int) (*Order, error) { func (o *OrderMod) DelOrder(orderId int) (*Order, error) {
Order, ok := o.OrderList[OrderId] order, ok := o.OrderList[orderId]
if !ok { if !ok {
return nil, fmt.Errorf("order not exist") 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") return nil, fmt.Errorf("order type wrong")
} }
delete(o.OrderList, OrderId) delete(o.OrderList, orderId)
return &Order, nil 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
} }
func (o *OrderMod) ResetChessPool() { 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) InitData() {
} }
func (p *PassMod) ZeroUpdate(Id int) { func (p *PassMod) ZeroUpdate(id int) {
p.Login(Id) p.Login(id)
} }
func (p *PassMod) GetRewardItems() ([]*item.Item, []int) { func (p *PassMod) GetRewardItems() ([]*item.Item, []int) {
template := passCfg.GetTemplate(p.Id) template := passCfg.GetTemplate(p.Id)
NewLevel := passCfg.GetNewLevel(template, p.Num, p.Reward) newLevel := passCfg.GetNewLevel(template, p.Num, p.Reward)
if len(NewLevel) == 0 { if len(newLevel) == 0 {
return nil, nil return nil, nil
} }
var Items []*item.Item var items []*item.Item
Items = append(Items, passCfg.GetFreeChargeItems(template, p.Reward)...) items = append(items, passCfg.GetFreeChargeItems(template, p.Reward)...)
if p.LowPass != 0 { if p.LowPass != 0 {
Items = append(Items, passCfg.GetLowChargeItems(template, p.Reward)...) items = append(items, passCfg.GetLowChargeItems(template, p.Reward)...)
} }
if p.HighPass != 0 { 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...) p.Reward = append(p.Reward, newLevel...)
return Items, NewLevel return items, newLevel
} }
func (p *PassMod) Login(Id int) int { func (p *PassMod) Login(id int) int {
OldId := p.Id oldId := p.Id
if Id == 0 { if id == 0 {
p.Id = 0 p.Id = 0
return OldId return oldId
} }
if p.Id == Id { if p.Id == id {
return 0 return 0
} }
p.Id = Id p.Id = id
p.LowPass = 0 p.LowPass = 0
p.HighPass = 0 p.HighPass = 0
p.Num = 0 p.Num = 0
p.Reward = nil p.Reward = nil
return OldId return oldId
} }
func (p *PassMod) GetLowChargeItems() []*item.Item { func (p *PassMod) GetLowChargeItems() []*item.Item {
if p.LowPass != 0 { if p.LowPass != 0 {
return nil return nil
} }
Template := passCfg.GetTemplate(p.Id) template := passCfg.GetTemplate(p.Id)
if Template == 0 { if template == 0 {
return nil return nil
} }
Items := passCfg.GetLowChargeItems(Template, p.Reward) items := passCfg.GetLowChargeItems(template, p.Reward)
p.LowPass = GoUtil.Now() p.LowPass = GoUtil.Now()
return Items return items
} }
func (p *PassMod) GetHighChargeItems() []*item.Item { func (p *PassMod) GetHighChargeItems() []*item.Item {
if p.HighPass != 0 { if p.HighPass != 0 {
return nil return nil
} }
Template := passCfg.GetTemplate(p.Id) template := passCfg.GetTemplate(p.Id)
if Template == 0 { if template == 0 {
return nil return nil
} }
Items := passCfg.GetHighChargeItems(Template, p.Reward) items := passCfg.GetHighChargeItems(template, p.Reward)
p.HighPass = GoUtil.Now() p.HighPass = GoUtil.Now()
return Items return items
} }
func (p *PassMod) AddExp(Score int) { func (p *PassMod) AddExp(score int) {
p.Num += Score 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) InitData() {
} }
func (p *PiggyBankMod) AddPiggyBank(Type int) { func (p *PiggyBankMod) AddPiggyBank(pType int) {
p.List = append(p.List, Type) p.List = append(p.List, pType)
} }
func (p *PiggyBankMod) Fire(ChargeId int) []*item.Item { func (p *PiggyBankMod) Fire(chargeId int) []*item.Item {
PiggyBankChargeId := chargeCfg.GetPiggyBankChargeId() piggyBankChargeId := chargeCfg.GetPiggyBankChargeId()
if ChargeId != PiggyBankChargeId && ChargeId != 0 { if chargeId != piggyBankChargeId && chargeId != 0 {
return nil return nil
} }
reward := []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, p.Diamond)} 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 { func (p *PiggyBankMod) TimeOut() int64 {
Now := GoUtil.Now() now := GoUtil.Now()
Remain := p.EndTime - Now remain := p.EndTime - now
if Remain > 0 { if remain > 0 {
return Remain return remain
} }
if len(p.List) == 0 { if len(p.List) == 0 {
return 0 return 0
} }
var Type int var pType int
Type, p.List = GoUtil.PopSlice(p.List) pType, p.List = GoUtil.PopSlice(p.List)
p.Type = Type p.Type = pType
Duration := int64(chargeCfg.GetPiggyDuration()) duration := int64(chargeCfg.GetPiggyDuration())
p.EndTime = Now + Duration p.EndTime = now + duration
return Duration return duration
} }
func (p *PiggyBankMod) Trigger() { func (p *PiggyBankMod) Trigger() {
Now := GoUtil.Now() now := GoUtil.Now()
if p.EndTime < Now { if p.EndTime < now {
return return
} }
minDia, maxDia := chargeCfg.GetPiggyRandDia() 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 { if p.NewCollect == nil {
p.NewCollect = make(map[int]*CollectInfo) p.NewCollect = make(map[int]*CollectInfo)
} }
InitCollect := playroomCfg.GetInitDecorate() initCollect := playroomCfg.GetInitDecorate()
if len(p.NewCollect) == 0 { if len(p.NewCollect) == 0 {
for _, v := range InitCollect { for _, v := range initCollect {
p.NewCollect[v] = &CollectInfo{ p.NewCollect[v] = &CollectInfo{
Id: v, Id: v,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
@ -196,7 +196,7 @@ func (p *PlayroomMod) InitData() {
} }
p.Collect = make(map[int]int) p.Collect = make(map[int]int)
} }
for _, v := range InitCollect { for _, v := range initCollect {
p.Collect[v] = 1 p.Collect[v] = 1
} }
if p.Room == nil { if p.Room == nil {
@ -229,8 +229,8 @@ func (p *PlayroomMod) InitData() {
} }
if len(p.NewPetAir) == 0 { if len(p.NewPetAir) == 0 {
p.NewPetAir = make(map[int]*PetAirInfo) p.NewPetAir = make(map[int]*PetAirInfo)
InitPetAir := playroomCfg.GetInitAirList() initPetAir := playroomCfg.GetInitAirList()
for _, v := range InitPetAir { for _, v := range initPetAir {
p.NewPetAir[v] = &PetAirInfo{ p.NewPetAir[v] = &PetAirInfo{
Id: v, Id: v,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
@ -253,12 +253,12 @@ func (p *PlayroomMod) InitData() {
p.NewDress = make(map[int]*DressInfo) p.NewDress = make(map[int]*DressInfo)
} }
if len(p.NewDress) == 0 { if len(p.NewDress) == 0 {
InitDressList := playroomCfg.GetInitDressList() initDressList := playroomCfg.GetInitDressList()
for _, v := range InitDressList { for _, v := range initDressList {
Part := playroomCfg.GetDressPart(v) part := playroomCfg.GetDressPart(v)
p.NewDress[v] = &DressInfo{ p.NewDress[v] = &DressInfo{
Id: v, Id: v,
Part: Part, Part: part,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Num: 1, Num: 1,
} }
@ -268,10 +268,10 @@ func (p *PlayroomMod) InitData() {
if len(p.Dress) != 0 { if len(p.Dress) != 0 {
for _, v := range p.Dress { for _, v := range p.Dress {
for _, id := range v { for _, id := range v {
Part := playroomCfg.GetDressPart(id) part := playroomCfg.GetDressPart(id)
p.NewDress[id] = &DressInfo{ p.NewDress[id] = &DressInfo{
Id: id, Id: id,
Part: Part, Part: part,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Num: 1, Num: 1,
} }
@ -300,34 +300,34 @@ func (p *PlayroomMod) ZeroUpdate() {
func (p *PlayroomMod) InitDailyTask() { func (p *PlayroomMod) InitDailyTask() {
p.DailyTask = make(map[int]*DailyTask) p.DailyTask = make(map[int]*DailyTask)
Index := 1 index := 1
TaskList1 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_ONE) taskList1 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_ONE)
for k, v := range TaskList1 { for k, v := range taskList1 {
Items := playroomCfg.GetDailyTaskReward(Index) items := playroomCfg.GetDailyTaskReward(index)
Quest, _ := quest.ParseQuest(v) quest, _ := quest.ParseQuest(v)
p.DailyTask[k] = &DailyTask{ p.DailyTask[k] = &DailyTask{
Items: Items, Items: items,
Quest: Quest, Quest: quest,
UnLock: true, UnLock: true,
Index: Index, Index: index,
} }
Index++ index++
} }
TaskList2 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_TWO) taskList2 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_TWO)
for k, v := range TaskList2 { for k, v := range taskList2 {
Items := playroomCfg.GetDailyTaskReward(Index) items := playroomCfg.GetDailyTaskReward(index)
Quest, _ := quest.ParseQuest(v) quest, _ := quest.ParseQuest(v)
p.DailyTask[k] = &DailyTask{ p.DailyTask[k] = &DailyTask{
Items: Items, Items: items,
Quest: Quest, Quest: quest,
UnLock: false, 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 update := false
unlock := true unlock := true
for k, v := range p.DailyTask { 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 { if v.Status != quest.QUEST_STATUS_UNFINISH {
continue continue
} }
update = quest.TriggerQuestProgress(&v.Quest, Tr) || update update = quest.TriggerQuestProgress(&v.Quest, tr) || update
if v.Quest.Status { if v.Quest.Status {
v.Status = quest.QUEST_STATUS_FINISH v.Status = quest.QUEST_STATUS_FINISH
} }
Type := playroomCfg.GetDailyTaskType(k) qType := playroomCfg.GetDailyTaskType(k)
if Type == DAILY_TASK_TYPE_ONE && v.Status == quest.QUEST_STATUS_UNFINISH { if qType == DAILY_TASK_TYPE_ONE && v.Status == quest.QUEST_STATUS_UNFINISH {
unlock = false unlock = false
} }
} }
@ -356,9 +356,9 @@ func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
return update return update
} }
func (p *PlayroomMod) DailyTaskCanReward(Id int) bool { func (p *PlayroomMod) DailyTaskCanReward(id int) bool {
IdList := playroomCfg.GetDailyTaskListById(Id) idList := playroomCfg.GetDailyTaskListById(id)
for _, v := range IdList { for _, v := range idList {
v, ok := p.DailyTask[v] v, ok := p.DailyTask[v]
if !ok { if !ok {
return false return false
@ -370,8 +370,8 @@ func (p *PlayroomMod) DailyTaskCanReward(Id int) bool {
return true return true
} }
func (p *PlayroomMod) GetDailyTaskReward(Id int) ([]*item.Item, error) { func (p *PlayroomMod) GetDailyTaskReward(id int) ([]*item.Item, error) {
v, ok := p.DailyTask[Id] v, ok := p.DailyTask[id]
if !ok { if !ok {
return nil, fmt.Errorf("GetDailyTaskReward Id is not ok") return nil, fmt.Errorf("GetDailyTaskReward Id is not ok")
} }
@ -414,12 +414,12 @@ func (p *PlayroomMod) GetPhysiologyList() map[int]int {
return Physiology return Physiology
} }
func (p *PlayroomMod) GetMoodInfo(Id int) *Mood { func (p *PlayroomMod) GetMoodInfo(id int) *Mood {
return p.MoodInfo[Id] return p.MoodInfo[id]
} }
func (p *PlayroomMod) GetPhysiology(Id int) *Physiology { func (p *PlayroomMod) GetPhysiology(id int) *Physiology {
return p.Physiology[Id] return p.Physiology[id]
} }
func (p *PlayroomMod) GetCollect() map[int]*CollectInfo { func (p *PlayroomMod) GetCollect() map[int]*CollectInfo {
@ -438,154 +438,154 @@ func (p *PlayroomMod) GetChip() int {
return len(p.ChipList) 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() { if len(p.ChipList) >= playroomCfg.GetChipNum() {
return return
} }
p.ChipList = append(p.ChipList, &ChipInfo{Uid: Uid, Time: Time, Emoji: Emoji}) p.ChipList = append(p.ChipList, &ChipInfo{Uid: uid, Time: time, Emoji: emoji})
p.RevengeUid = int64(Uid) p.RevengeUid = int64(uid)
} }
func (p *PlayroomMod) SetTarget(Target int) { func (p *PlayroomMod) SetTarget(target int) {
p.Target = Target p.Target = target
p.Status = 1 p.Status = 1
p.HasVisit[Target] = GoUtil.Now() p.HasVisit[target] = GoUtil.Now()
} }
func (p *PlayroomMod) SetGameId(GameId int) { func (p *PlayroomMod) SetGameId(gameId int) {
p.GameId = GameId p.GameId = gameId
} }
func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) { func (p *PlayroomMod) CreateOrderReward(star int, itemMod *item.ItemMod) {
if Star == 0 { if star == 0 {
return return
} }
FoodItem := playroomCfg.GetFoodItem() foodItem := playroomCfg.GetFoodItem()
CleanItem := playroomCfg.GetCleanItem() cleanItem := playroomCfg.GetCleanItem()
ToyItem := playroomCfg.GetToyItem() toyItem := playroomCfg.GetToyItem()
DailyItem := playroomCfg.GetDailyItem() dailyItem := playroomCfg.GetDailyItem()
FoodItemNum := itemMod.GetItemNumByList(FoodItem) foodItemNum := itemMod.GetItemNumByList(foodItem)
CleanItemNum := itemMod.GetItemNumByList(CleanItem) cleanItemNum := itemMod.GetItemNumByList(cleanItem)
ToyItemNum := itemMod.GetItemNumByList(ToyItem) toyItemNum := itemMod.GetItemNumByList(toyItem)
DailyItemNum := itemMod.GetItemNumByList(DailyItem) dailyItemNum := itemMod.GetItemNumByList(dailyItem)
type d struct { type d struct {
Id []int Id []int
Num int Num int
} }
sortList := []d{ sortList := []d{
{Id: FoodItem, Num: FoodItemNum}, {Id: foodItem, Num: foodItemNum},
{Id: CleanItem, Num: CleanItemNum}, {Id: cleanItem, Num: cleanItemNum},
{Id: ToyItem, Num: ToyItemNum}, {Id: toyItem, Num: toyItemNum},
{Id: DailyItem, Num: DailyItemNum}, {Id: dailyItem, Num: dailyItemNum},
} }
sort.Slice(sortList, func(i, j int) bool { sort.Slice(sortList, func(i, j int) bool {
return sortList[i].Num < sortList[j].Num return sortList[i].Num < sortList[j].Num
}) })
Prob := GoUtil.RandSlice(sortList[0].Id) prob := GoUtil.RandSlice(sortList[0].Id)
p.Reward = []*item.Item{{Id: Prob, Num: 1}} p.Reward = []*item.Item{{Id: prob, Num: 1}}
} }
func (p *PlayroomMod) GetReward() []*item.Item { func (p *PlayroomMod) GetReward() []*item.Item {
return p.Reward return p.Reward
} }
func (p *PlayroomMod) Interact(Id, Type int) ([]*item.Item, int, error) { func (p *PlayroomMod) Interact(id, iType int) ([]*item.Item, int, error) {
MoodType, ItemList, Effect := playroomCfg.GetInteract(Id, Type) moodType, items, effect := playroomCfg.GetInteract(id, iType)
if MoodType == 0 { if moodType == 0 {
return nil, 0, fmt.Errorf("Interact MoodType is 0") return nil, 0, fmt.Errorf("Interact MoodType is 0")
} }
if Effect > 0 { if effect > 0 {
p.AllMood = min(100, p.AllMood+10) p.AllMood = min(100, p.AllMood+10)
} }
PType, PEffect := playroomCfg.GetInteractPhysiology(Id) pType, pEffect := playroomCfg.GetInteractPhysiology(id)
p.AddPhysiology(PType, PEffect) p.AddPhysiology(pType, pEffect)
p.AddMood(MoodType, Effect) p.AddMood(moodType, effect)
return ItemList, PType, nil return items, pType, nil
} }
func (p *PlayroomMod) AddInteractNum(Lv int) { func (p *PlayroomMod) AddInteractNum(lv int) {
Unlock := playroomCfg.GetInteractUnlock() unlock := playroomCfg.GetInteractUnlock()
if Lv < Unlock { if lv < unlock {
return return
} }
p.InteractNum++ p.InteractNum++
p.InteractNum = min(p.InteractNum, playroomCfg.GetInteractNum()) p.InteractNum = min(p.InteractNum, playroomCfg.GetInteractNum())
} }
func (p *PlayroomMod) AddMood(Id, Num int) { func (p *PlayroomMod) AddMood(id, num int) {
_, ok := p.MoodInfo[Id] _, ok := p.MoodInfo[id]
if !ok { 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)) p.MoodInfo[id].Num = max(0, min(p.MoodInfo[id].Num+num, 100))
if p.MoodInfo[Id].Num != 0 && p.MoodInfo[Id].Time == 0 { if p.MoodInfo[id].Num != 0 && p.MoodInfo[id].Time == 0 {
p.MoodInfo[Id].Time = GoUtil.Now() p.MoodInfo[id].Time = GoUtil.Now()
} }
if p.MoodInfo[Id].Num == 0 { if p.MoodInfo[id].Num == 0 {
p.MoodInfo[Id].Time = 0 p.MoodInfo[id].Time = 0
} }
} }
func (p *PlayroomMod) GetMoodNum(MoodType int) int { func (p *PlayroomMod) GetMoodNum(moodType int) int {
Mood, ok := p.MoodInfo[MoodType] mood, ok := p.MoodInfo[moodType]
if !ok { if !ok {
return 0 return 0
} }
return Mood.Num return mood.Num
} }
func (p *PlayroomMod) AddPhysiology(Id, Num int) { func (p *PlayroomMod) AddPhysiology(id, num int) {
Phy := p.GetPhysiology(Id) phy := p.GetPhysiology(id)
if Phy == nil { if phy == nil {
Phy = &Physiology{Id: Id} phy = &Physiology{Id: id}
p.Physiology[Id] = Phy p.Physiology[id] = phy
} }
Max := playroomCfg.GetPhysiologyMax(Id) maxNum := playroomCfg.GetPhysiologyMax(id)
Phy.Num = max(0, min(Phy.Num+Num, Max)) phy.Num = max(0, min(phy.Num+num, maxNum))
Phy.Time = GoUtil.Now() phy.Time = GoUtil.Now()
if Phy.Num == 0 { if phy.Num == 0 {
Phy.Time = 0 phy.Time = 0
} }
} }
func (p *PlayroomMod) AddVisitor(Id int, Time int64) { func (p *PlayroomMod) AddVisitor(id int, time int64) {
v, ok := p.Visitor[Id] v, ok := p.Visitor[id]
if !ok { if !ok {
p.Visitor[Id] = &Info{Time: Time, Times: 1} p.Visitor[id] = &Info{Time: time, Times: 1}
return return
} }
v.Times++ v.Times++
v.Time = Time v.Time = time
} }
func (p *PlayroomMod) SetRoom(Room map[int]int) (map[int]int, error) { func (p *PlayroomMod) SetRoom(room map[int]int) (map[int]int, error) {
diff := GoUtil.DiffMap(p.Room, Room) diff := GoUtil.DiffMap(p.Room, room)
p.Room = Room p.Room = room
return diff, nil return diff, nil
} }
func (p *PlayroomMod) AddCollect(Id int, Label string) { func (p *PlayroomMod) AddCollect(id int, label string) {
p.NewCollect[Id] = &CollectInfo{ p.NewCollect[id] = &CollectInfo{
Id: Id, Id: id,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Label: Label, Label: label,
} }
} }
func (p *PlayroomMod) AddDress(Id int, Label string) { func (p *PlayroomMod) AddDress(id int, label string) {
Part := playroomCfg.GetDressPart(Id) part := playroomCfg.GetDressPart(id)
if _, ok := p.NewDress[Id]; !ok { if _, ok := p.NewDress[id]; !ok {
p.NewDress[Id] = &DressInfo{ p.NewDress[id] = &DressInfo{
Id: Id, Id: id,
Part: Part, Part: part,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Label: Label, Label: label,
Num: 1, Num: 1,
} }
} else { } else {
p.NewDress[Id].Num++ p.NewDress[id].Num++
} }
} }
@ -606,43 +606,44 @@ func (p *PlayroomMod) ResetLose() {
p.LoseItem = nil p.LoseItem = nil
} }
func (p *PlayroomMod) SetGameReward(Chess1, Chess2, Star int) { func (p *PlayroomMod) SetGameReward(chess1, chess2, star int) {
p.GameReward[1] = &item.Item{Id: Chess1, Num: 1} p.GameReward[1] = &item.Item{Id: chess1, Num: 1}
p.GameReward[2] = &item.Item{Id: Chess2, Num: 1} p.GameReward[2] = &item.Item{Id: chess2, Num: 1}
p.GameReward[3] = &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) { func (p *PlayroomMod) SetGameReward2(chess1, star int) {
p.GameReward[1] = &item.Item{Id: Chess1, Num: 1} p.GameReward[1] = &item.Item{Id: chess1, Num: 1}
p.GameReward[2] = &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} p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
} }
func (p *PlayroomMod) SetGameReward3(Star int) { func (p *PlayroomMod) SetGameReward3(star int) {
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star} 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[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: star}
p.GameReward[3] = &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) { // N1, N2, N3分别是铜、银、金翻牌的奖励数量，经过玩家的加成后再设置到GameReward中
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: N1} func (p *PlayroomMod) SetGameRewardFlip(n1, n2, n3 int) {
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: N2} p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: n1}
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: N3} 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 { func (p *PlayroomMod) SelectReward(id int) []*item.Item {
v, ok := p.GameReward[Id] v, ok := p.GameReward[id]
if !ok { if !ok {
return nil return nil
} }
var Items []*item.Item var items []*item.Item
Items = append(Items, v) items = append(items, v)
if Id < 3 { if id < 3 {
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 5)) items = append(items, item.NewItem(item.ITEM_STAR_ID, 5))
} }
return Items return items
} }
func (p *PlayroomMod) Lose(Item []*item.Item) { func (p *PlayroomMod) Lose(items []*item.Item) {
p.LoseItem = append(p.LoseItem, Item...) p.LoseItem = append(p.LoseItem, items...)
} }
func (p *PlayroomMod) Work() ([]*item.Item, error) { func (p *PlayroomMod) Work() ([]*item.Item, error) {
@ -653,16 +654,19 @@ func (p *PlayroomMod) Work() ([]*item.Item, error) {
p.Starttime = GoUtil.Now() p.Starttime = GoUtil.Now()
p.Endtime = GoUtil.Now() + 86400 p.Endtime = GoUtil.Now() + 86400
p.WorkStatus = 1 p.WorkStatus = 1
ItemId := playroomCfg.GetWorkItem() itemId := playroomCfg.GetWorkItem()
return []*item.Item{item.NewItem(ItemId, 1)}, nil if itemId == 0 {
return nil, fmt.Errorf("Work ItemId is 0")
}
return []*item.Item{item.NewItem(itemId, 1)}, nil
} }
func (p *PlayroomMod) Rest() { func (p *PlayroomMod) Rest() {
p.WorkStatus = 2 p.WorkStatus = 2
} }
func (p *PlayroomMod) SetWorkOutline(Status int) { func (p *PlayroomMod) SetWorkOutline(status int) {
p.WorkOutline = Status p.WorkOutline = status
} }
func (p *PlayroomMod) ResetWork() { func (p *PlayroomMod) ResetWork() {
@ -674,16 +678,16 @@ func (p *PlayroomMod) Outline() {
p.WorkOutline = 1 p.WorkOutline = 1
} }
func (p *PlayroomMod) GetVisitorInfo(Id int) (int, int64) { func (p *PlayroomMod) GetVisitorInfo(id int) (int, int64) {
v, ok := p.Visitor[Id] v, ok := p.Visitor[id]
if !ok { if !ok {
return 0, 0 return 0, 0
} }
return v.Times, v.Time return v.Times, v.Time
} }
func (p *PlayroomMod) GetTaskReward(Type int) (int, []*item.Item, error) { func (p *PlayroomMod) GetTaskReward(taskType int) (int, []*item.Item, error) {
if GoUtil.InArray(Type, p.DailyTaskReward) { if GoUtil.InArray(taskType, p.DailyTaskReward) {
return 0, nil, fmt.Errorf("GetTaskReward Type is already in DailyTaskReward") return 0, nil, fmt.Errorf("GetTaskReward Type is already in DailyTaskReward")
} }
finish := 0 finish := 0
@ -692,42 +696,39 @@ func (p *PlayroomMod) GetTaskReward(Type int) (int, []*item.Item, error) {
finish++ 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) 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) return 0, nil, fmt.Errorf("GetTaskReward Type is DAILY_TASK_TYPE_TWO but finish is %d", finish)
} }
p.DailyTaskReward = append(p.DailyTaskReward, Type) p.DailyTaskReward = append(p.DailyTaskReward, taskType)
Id := 0 id := 0
var Items []*item.Item var items []*item.Item
ProbList := playroomCfg.GetTaskJackpotProb() probList := playroomCfg.GetTaskJackpotProb()
Id = GoUtil.RandMap(ProbList) id = GoUtil.RandMap(probList)
Items = playroomCfg.GetTaskJackpotReward(Id) items = playroomCfg.GetTaskJackpotReward(id)
if len(Items) > 1 { 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) { func (p *PlayroomMod) Draw() (int, []*item.Item, error) {
// if p.AllMood < 100 {
// return 0, nil, fmt.Errorf("Draw AllMood < 100")
// }
if p.JackpotNum == 0 { if p.JackpotNum == 0 {
return 0, nil, fmt.Errorf("Draw JackpotNum is 0") return 0, nil, fmt.Errorf("Draw JackpotNum is 0")
} }
p.JackpotNum-- p.JackpotNum--
p.AllMood = 0 p.AllMood = 0
ProbList := limitedTimeEventCfg.GetSenceJackpotProb() probList := limitedTimeEventCfg.GetSenceJackpotProb()
Id := GoUtil.RandMap(ProbList) id := GoUtil.RandMap(probList)
Items := limitedTimeEventCfg.GetSenceJackpotReward(Id) items := limitedTimeEventCfg.GetSenceJackpotReward(id)
if len(Items) > 1 { 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 { func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
@ -738,25 +739,25 @@ func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
} }
func (p *PlayroomMod) NotifyLose() *msg.NotifyPlayroomLose { 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 { for _, v := range p.ChipList {
ChipMessage = append(ChipMessage, &msg.ChipInfo{ chipMessage = append(chipMessage, &msg.ChipInfo{
Uid: int64(v.Uid), Uid: int64(v.Uid),
}) })
} }
return &msg.NotifyPlayroomLose{ return &msg.NotifyPlayroomLose{
LoseItem: item.ItemToMsg(p.LoseItem), LoseItem: item.ItemToMsg(p.LoseItem),
Chip: ChipMessage, Chip: chipMessage,
Revenge: p.RevengeUid, Revenge: p.RevengeUid,
} }
} }
func (p *PlayroomMod) ResetPhysiology(MoodType int) { func (p *PlayroomMod) ResetPhysiology(MoodType int) {
PhysiologyList := playroomCfg.GetPhysiologyList(MoodType) physiologyList := playroomCfg.GetPhysiologyList(MoodType)
for _, v := range PhysiologyList { for _, v := range physiologyList {
Phy := p.GetPhysiology(v) phy := p.GetPhysiology(v)
if Phy != nil { if phy != nil {
Phy.Num = 0 phy.Num = 0
Phy.Time = 0 phy.Time = 0
} }
} }
} }
@ -767,9 +768,9 @@ func (p *PlayroomMod) NotifyStatus() *msg.NofiPlayroomStatus {
} }
func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood { func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
Mood := make(map[int32]int32) mood := make(map[int32]int32)
for k, v := range p.MoodInfo { for k, v := range p.MoodInfo {
Mood[int32(k)] = int32(v.Num) mood[int32(k)] = int32(v.Num)
} }
var resAdItems []*msg.AdItem var resAdItems []*msg.AdItem
for k, v := range p.ADItem { for k, v := range p.ADItem {
@ -781,24 +782,24 @@ func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
} }
return &msg.NotifyPlayroomMood{ return &msg.NotifyPlayroomMood{
AllMood: int32(p.AllMood), AllMood: int32(p.AllMood),
Mood: Mood, Mood: mood,
Physiology: GoUtil.MapIntToInt32(p.GetPhysiologyList()), Physiology: GoUtil.MapIntToInt32(p.GetPhysiologyList()),
AdItem: resAdItems, AdItem: resAdItems,
} }
} }
func (p *PlayroomMod) Fire(ChargeId int) []*item.Item { func (p *PlayroomMod) Fire(chargeId int) []*item.Item {
WorkChargeId := playroomCfg.GetWorkChargeId() workChargeId := playroomCfg.GetWorkChargeId()
if ChargeId == WorkChargeId { if chargeId == workChargeId {
ItemId := playroomCfg.GetWorkItem() itemId := playroomCfg.GetWorkItem()
return []*item.Item{item.NewItem(ItemId, 1)} return []*item.Item{item.NewItem(itemId, 1)}
} }
return nil 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) len1 := len(p.ChipList)
len2 := len(Uids) len2 := len(uids)
if len1 == 0 { if len1 == 0 {
return nil, 0, fmt.Errorf("RemoveChip Uids is 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 p.ChipList = nil
} else { } else {
uidCount := make(map[int64]int) uidCount := make(map[int64]int)
for _, uid := range Uids { for _, uid := range uids {
uidCount[uid]++ 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 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 { if p.Status != STATUS_VISIT {
return 0, fmt.Errorf("FlipCard Status is not 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_COPPER: 35,
FLIP_TYPE_SILVER: 45, FLIP_TYPE_SILVER: 45,
FLIP_TYPE_GOLD: 20, 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 Prob = FLIP_TYPE_GOLD
} }
} }
p.Flip[Pos] = Prob p.Flip[pos] = Prob
return Prob, nil return Prob, nil
} }
func (p *PlayroomMod) GetFlipReward() ([]*item.Item, int, int, error) { func (p *PlayroomMod) GetFlipReward() ([]*item.Item, int, int, error) {
check := make(map[int]int) check := make(map[int]int)
var Items []*item.Item var items []*item.Item
T := p.Target result := FLIP_TYPE_COPPER
Result := FLIP_TYPE_COPPER
for _, v := range p.Flip { for _, v := range p.Flip {
check[v]++ check[v]++
if check[v] == 3 { if check[v] == 3 {
switch v { switch v {
case FLIP_TYPE_COPPER: case FLIP_TYPE_COPPER:
p.NoFlip++ p.NoFlip++
Items = append(Items, p.GameReward[FLIP_TYPE_COPPER]) items = append(items, p.GameReward[FLIP_TYPE_COPPER])
case FLIP_TYPE_SILVER: case FLIP_TYPE_SILVER:
p.NoFlip++ p.NoFlip++
Result = FLIP_TYPE_SILVER result = FLIP_TYPE_SILVER
Items = append(Items, p.GameReward[FLIP_TYPE_SILVER]) items = append(items, p.GameReward[FLIP_TYPE_SILVER])
case FLIP_TYPE_GOLD: case FLIP_TYPE_GOLD:
p.NoFlip = 0 p.NoFlip = 0
p.TodayFlip = true p.TodayFlip = true
Result = FLIP_TYPE_GOLD result = FLIP_TYPE_GOLD
Items = append(Items, p.GameReward[FLIP_TYPE_GOLD]) items = append(items, p.GameReward[FLIP_TYPE_GOLD])
} }
p.LastFlip = v p.LastFlip = v
p.Flip = make(map[int]int) p.Flip = make(map[int]int)
p.ResetGame() 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) { func (p *PlayroomMod) BuyItem(id int) ([]*item.Item, []*item.Item) {
return playroomCfg.GetBuyItem(Id) return playroomCfg.GetBuyItem(id)
} }
func (p *PlayroomMod) UnLock(Lv int) bool { func (p *PlayroomMod) UnLock(lv int) bool {
UnlockLv := playroomCfg.GetUnLockLv() UnlockLv := playroomCfg.GetUnLockLv()
if Lv < UnlockLv || len(p.Physiology) != 0 { if lv < UnlockLv || len(p.Physiology) != 0 {
return false return false
} }
Now := GoUtil.Now() now := GoUtil.Now()
p.Physiology = make(map[int]*Physiology) p.Physiology = make(map[int]*Physiology)
TypeList := playroomCfg.GetPhysiologyTypeList() typeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range TypeList { for _, v := range typeList {
Max := playroomCfg.GetPhysiologyMax(v) max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now} p.Physiology[v] = &Physiology{Id: v, Num: max, Time: now}
} }
if len(p.MoodInfo) == 0 { if len(p.MoodInfo) == 0 {
p.MoodInfo = make(map[int]*Mood) p.MoodInfo = make(map[int]*Mood)
@ -913,17 +913,17 @@ func (p *PlayroomMod) UnLock(Lv int) bool {
return true return true
} }
func (p *PlayroomMod) FixUnLock(Lv int) bool { func (p *PlayroomMod) FixUnLock(lv int) bool {
UnlockLv := playroomCfg.GetUnLockLv() unlockLv := playroomCfg.GetUnLockLv()
if Lv < UnlockLv || len(p.Physiology) != 0 { if lv < unlockLv || len(p.Physiology) != 0 {
return false return false
} }
Now := GoUtil.Now() now := GoUtil.Now()
p.Physiology = make(map[int]*Physiology) p.Physiology = make(map[int]*Physiology)
TypeList := playroomCfg.GetPhysiologyTypeList() typeList := playroomCfg.GetPhysiologyTypeList()
for _, v := range TypeList { for _, v := range typeList {
Max := playroomCfg.GetPhysiologyMax(v) max := playroomCfg.GetPhysiologyMax(v)
p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now} p.Physiology[v] = &Physiology{Id: v, Num: max, Time: now}
} }
if len(p.MoodInfo) == 0 { if len(p.MoodInfo) == 0 {
p.MoodInfo = make(map[int]*Mood) p.MoodInfo = make(map[int]*Mood)
@ -935,27 +935,30 @@ func (p *PlayroomMod) FixUnLock(Lv int) bool {
} }
// shop // shop
func (p *PlayroomMod) ShopBuy(Id, Num int, WeeklyDiscount bool) ([]*item.Item, []*item.Item, error) { func (p *PlayroomMod) ShopBuy(id, num int, weeklyDiscount bool) ([]*item.Item, []*item.Item, error) {
AddItemId, CostItem, Discount, Limit := playroomCfg.GetShopItem(Id) addItemId, costItem, discount, limit := playroomCfg.GetShopItem(id)
if AddItemId == 0 { if addItemId == 0 {
return nil, nil, fmt.Errorf("ShopBuy AddItemId is 0") return nil, nil, fmt.Errorf("ShopBuy AddItemId is 0")
} }
NewCostItem := CostItem[0].Num * Num if costItem == nil || len(costItem) == 0 {
if WeeklyDiscount { return nil, nil, fmt.Errorf("ShopBuy CostItem is nil or length is 0")
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 newCostItem := costItem[0].Num * num
return []*item.Item{item.NewItem(AddItemId, Num)}, CostItem, nil 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 { func (p *PlayroomMod) UnlockDress(dType, id int) error {
p.NewDress[Id] = &DressInfo{ p.NewDress[id] = &DressInfo{
Id: Id, Id: id,
Part: Type, Part: dType,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Num: 1, Num: 1,
} }
@ -966,42 +969,42 @@ func (p *PlayroomMod) RandGameType() int {
return GoUtil.RandMap(map[int]int{1: 50, 3: 50}) return GoUtil.RandMap(map[int]int{1: 50, 3: 50})
} }
func (p *PlayroomMod) UnlockPetAir(Id int) { func (p *PlayroomMod) UnlockPetAir(id int) {
p.NewPetAir[Id] = &PetAirInfo{ p.NewPetAir[id] = &PetAirInfo{
Id: Id, Id: id,
AddTime: GoUtil.Now(), AddTime: GoUtil.Now(),
Num: 1, 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 var Part []int
Diff := GoUtil.DiffMap(DressSet, p.DressSet) diff := GoUtil.DiffMap(dressSet, p.DressSet)
for Type, Id := range DressSet { for dType, id := range dressSet {
if Id == 0 { if id == 0 {
continue continue
} }
dressInfo, ok := p.NewDress[Id] dressInfo, ok := p.NewDress[id]
if !ok { if !ok {
return nil, nil, fmt.Errorf("dress Id not found") return nil, nil, fmt.Errorf("dress Id not found")
} }
if dressInfo.EndTime < GoUtil.Now() && dressInfo.EndTime != 0 { if dressInfo.EndTime < GoUtil.Now() && dressInfo.EndTime != 0 {
return nil, nil, fmt.Errorf("dress timeout") return nil, nil, fmt.Errorf("dress timeout")
} }
if p.DressSet[Type] != Id && Id != 0 { if p.DressSet[dType] != id && id != 0 {
Part = append(Part, Type) Part = append(Part, dType)
} }
} }
p.DressSet = DressSet p.DressSet = dressSet
return Part, Diff, nil return Part, diff, nil
} }
func (p *PlayroomMod) GiveUpvote(Uid int) ([]*item.Item, error) { func (p *PlayroomMod) GiveUpvote(uid int) ([]*item.Item, error) {
if GoUtil.InArray(Uid, p.UpvoteList) { if GoUtil.InArray(uid, p.UpvoteList) {
return nil, fmt.Errorf("upvote already") 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 return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, 5)}, nil
} }
@ -1009,29 +1012,29 @@ func (p *PlayroomMod) AddUpvote() {
p.Upvote++ p.Upvote++
} }
func (p *PlayroomMod) PlayroomPetAirSet(Id int) error { func (p *PlayroomMod) PlayroomPetAirSet(id int) error {
if _, ok := p.NewPetAir[Id]; !ok { if _, ok := p.NewPetAir[id]; !ok {
return fmt.Errorf("PlayroomPetAirSet Id is not ok") return fmt.Errorf("PlayroomPetAirSet Id is not ok")
} }
p.PetAirSet = Id p.PetAirSet = id
return nil return nil
} }
func (p *PlayroomMod) Unlock(Id int) error { func (p *PlayroomMod) Unlock(id int) error {
Need := playroomCfg.GetUnlockNeed(Id) need := playroomCfg.GetUnlockNeed(id)
if Need == 0 || Need > p.RoomPoint { if need == 0 || need > p.RoomPoint {
return fmt.Errorf("unlock need is 0 or need > RoomPoint") return fmt.Errorf("unlock need is 0 or need > RoomPoint")
} }
p.UnlockList[Id] = GoUtil.Now() p.UnlockList[id] = GoUtil.Now()
return nil return nil
} }
func (p *PlayroomMod) GetUnlockIds() []int32 { func (p *PlayroomMod) GetUnlockIds() []int32 {
UnlockIds := make([]int32, 0, len(p.UnlockList)) unlockIds := make([]int32, 0, len(p.UnlockList))
for k := range 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 { func (p *PlayroomMod) GetDressSet() map[int]int {
@ -1051,9 +1054,9 @@ func (p *PlayroomMod) GetPetAir() map[int]*PetAirInfo {
} }
func (p *PlayroomMod) BackDataTask() []*msg.DailyTask { 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 { for k, v := range p.DailyTask {
DailyTask = append(DailyTask, &msg.DailyTask{ dailyTask = append(dailyTask, &msg.DailyTask{
Status: int32(v.Status), Status: int32(v.Status),
UnLock: v.UnLock, UnLock: v.UnLock,
Progress: quest.QuestProgressToMsg(&v.Quest), Progress: quest.QuestProgressToMsg(&v.Quest),
@ -1062,10 +1065,10 @@ func (p *PlayroomMod) BackDataTask() []*msg.DailyTask {
Id: int32(k), Id: int32(k),
}) })
} }
sort.Slice(DailyTask, func(i, j int) bool { sort.Slice(dailyTask, func(i, j int) bool {
return DailyTask[i].Index < DailyTask[j].Index return dailyTask[i].Index < dailyTask[j].Index
}) })
return DailyTask return dailyTask
} }
func (p *PlayroomMod) Guide(Type int) error { 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 }, nil
} }
func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool { func TriggerQuestProgress(q *QuestProgress, tr *Trigger) bool {
if q.Label != Tr.Label { if q.Label != tr.Label {
return false return false
} }
if q.Status { if q.Status {
@ -81,23 +81,23 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
TRIGGER_LABEL_STAR, TRIGGER_LABEL_STAR,
TRIGGER_LABEL_DIAMOND, TRIGGER_LABEL_DIAMOND,
TRIGGER_LABEL_DECORATE: // 消耗x能量 TRIGGER_LABEL_DECORATE: // 消耗x能量
AddNum := GoUtil.Int(Tr.A[0]) AddNum := GoUtil.Int(tr.A[0])
q.Num += AddNum q.Num += AddNum
case TRIGGER_LABEL_MERGELVTIME: // 合成x级棋子y次 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)) TargetLv, _ := strconv.Atoi(q.A[0].(string))
if TargetLv == Lv { if TargetLv == Lv {
q.Num++ q.Num++
} }
case TRIGGER_LABEL_GUIDE_LOGIN: // 引导任务登录 case TRIGGER_LABEL_GUIDE_LOGIN: // 引导任务登录
LoginDay := GoUtil.Int(Tr.A[0]) LoginDay := GoUtil.Int(tr.A[0])
q.Num = LoginDay q.Num = LoginDay
case TRIGGER_LABEL_MERGETIME, // 合成x次 case TRIGGER_LABEL_MERGETIME, // 合成x次
TRIGGER_LABEL_FINISHORDER, TRIGGER_LABEL_FINISHORDER,
TRIGGER_LABEL_BUBBLE: // 完成x次订单 TRIGGER_LABEL_BUBBLE: // 完成x次订单
q.Num++ q.Num++
case TRIGGER_LABEL_INTERACT: // 互动x类型y次 case TRIGGER_LABEL_INTERACT: // 互动x类型y次
InteractId := GoUtil.Int(Tr.A[0]) InteractId := GoUtil.Int(tr.A[0])
Ids := GoUtil.IntSliceInterface(q.A) Ids := GoUtil.IntSliceInterface(q.A)
if GoUtil.InArray(InteractId, Ids) { if GoUtil.InArray(InteractId, Ids) {
q.Num++ q.Num++
@ -106,11 +106,11 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
if len(q.A) == 0 { if len(q.A) == 0 {
return false return false
} }
if len(Tr.A) == 0 { if len(tr.A) == 0 {
return false return false
} }
Ids := GoUtil.IntSliceInterface(q.A) Ids := GoUtil.IntSliceInterface(q.A)
arg := GoUtil.IntSlice(Tr.A[0]) arg := GoUtil.IntSlice(tr.A[0])
for _, t := range arg { for _, t := range arg {
if GoUtil.InArray(t, Ids) { if GoUtil.InArray(t, Ids) {
q.Num++ q.Num++
@ -127,15 +127,15 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
} }
func QuestProgressToMsg(quest *QuestProgress) *msg.QuestProgress { func QuestProgressToMsg(quest *QuestProgress) *msg.QuestProgress {
Param := 0 param := 0
if len(quest.A) > 0 { if len(quest.A) > 0 {
Param = GoUtil.Int(quest.A[0]) param = GoUtil.Int(quest.A[0])
} }
return &msg.QuestProgress{ return &msg.QuestProgress{
Label: quest.Label, Label: quest.Label,
Num: int32(quest.Num), Num: int32(quest.Num),
Target: int32(quest.Target), Target: int32(quest.Target),
Status: quest.Status, 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 Progress int
} }
func (r *RaceMod) Login(Id int) int { func (r *RaceMod) Login(id int) int {
OldId := r.Id oldId := r.Id
if Id == 0 { if id == 0 {
r.Id = 0 r.Id = 0
return OldId return oldId
} }
if r.Id == Id { if r.Id == id {
return 0 return 0
} }
r.Id = Id r.Id = id
r.Pass = 1 r.Pass = 1
r.StartTime = 0 r.StartTime = 0
r.EndTime = 0 r.EndTime = 0
r.Progress = 0 r.Progress = 0
r.Rank = 0 r.Rank = 0
r.Opponent = nil r.Opponent = nil
return OldId return oldId
} }
// TODO 剩余AI逻辑未开发 // TODO 剩余AI逻辑未开发
func (r *RaceMod) ZeroUpdate(Id int) { func (r *RaceMod) ZeroUpdate(id int) {
r.Login(Id) r.Login(id)
} }
func (r *RaceMod) StartGame() error { func (r *RaceMod) StartGame() error {
@ -56,66 +56,66 @@ func (r *RaceMod) StartGame() error {
return fmt.Errorf("the game has started") return fmt.Errorf("the game has started")
} }
r.StartTime = GoUtil.Now() r.StartTime = GoUtil.Now()
OpponentNum := raceCfg.GetRaceNum(r.Pass) opponentNum := raceCfg.GetRaceNum(r.Pass)
r.EndTime = r.StartTime + int64(raceCfg.GetCD(r.Id)) r.EndTime = r.StartTime + int64(raceCfg.GetCD(r.Id))
r.Opponent = randOpponents(OpponentNum) r.Opponent = randOpponents(opponentNum)
r.Rank = 1 r.Rank = 1
return nil return nil
} }
func (r *RaceMod) AddCoin(Num int) { func (r *RaceMod) AddCoin(num int) {
if r.StartTime == 0 { if r.StartTime == 0 {
return return
} }
r.Progress += Num r.Progress += num
} }
func (r *RaceMod) GetReward() ([]*item.Item, error) { func (r *RaceMod) GetReward() ([]*item.Item, error) {
if r.EndTime == 0 { if r.EndTime == 0 {
return nil, fmt.Errorf("the game is not over") return nil, fmt.Errorf("the game is not over")
} }
Need := raceCfg.GetRaceNeed(r.Pass) need := raceCfg.GetRaceNeed(r.Pass)
if r.Progress < Need { if r.Progress < need {
return nil, fmt.Errorf("not enough progress") return nil, fmt.Errorf("not enough progress")
} }
if r.Rank != 1 { if r.Rank != 1 {
return nil, fmt.Errorf("you are not the first") return nil, fmt.Errorf("you are not the first")
} }
var Items []*item.Item var items []*item.Item
Items = append(Items, raceCfg.GetReward(r.Pass)...) items = append(items, raceCfg.GetReward(r.Pass)...)
Now := GoUtil.Now() now := GoUtil.Now()
if Now <= r.EndTime { if now <= r.EndTime {
Items = append(Items, raceCfg.GetExtraReward(r.Pass)...) items = append(items, raceCfg.GetExtraReward(r.Pass)...)
} }
r.Pass++ r.Pass++
r.Progress -= Need r.Progress -= need
MaxPass := raceCfg.GetMaxPass(r.Id) maxPass := raceCfg.GetMaxPass(r.Id)
if r.Pass > MaxPass { if r.Pass > maxPass {
r.Pass = 1 r.Pass = 1
r.StartTime = 0 r.StartTime = 0
r.EndTime = 0 r.EndTime = 0
r.Opponent = nil r.Opponent = nil
r.Progress = 0 r.Progress = 0
} else { } else {
r.StartTime = Now r.StartTime = now
r.EndTime = Now + int64(raceCfg.GetCD(r.Id)) r.EndTime = now + int64(raceCfg.GetCD(r.Id))
r.Opponent = randOpponents(raceCfg.GetRaceNum(r.Pass)) r.Opponent = randOpponents(raceCfg.GetRaceNum(r.Pass))
} }
return Items, nil return items, nil
} }
func randOpponents(OpponentNum int) []*Opponent { func randOpponents(opponentNum int) []*Opponent {
opponents := make([]*Opponent, 0, OpponentNum-1) opponents := make([]*Opponent, 0, opponentNum-1)
names := randnameCfg.GetRandNames(OpponentNum) names := randnameCfg.GetRandNames(opponentNum)
for i := 1; i < OpponentNum; i++ { for i := 1; i < opponentNum; i++ {
opponents = append(opponents, randOpponent(i, names[i])) opponents = append(opponents, randOpponent(i, names[i]))
} }
return opponents return opponents
} }
func randOpponent(Id int, name string) *Opponent { func randOpponent(id int, name string) *Opponent {
return &Opponent{ return &Opponent{
Id: Id, Id: id,
Name: name, Name: name,
Face: rand.Intn(10), Face: rand.Intn(10),
Avatar: 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) { func (s *SevenLoginMod) ZeroUpdate(add, lastLoginTime, factor, level int) {
WeekZeroTimestamp := GoUtil.WeekZeroTimestamp() weekZeroTimestamp := GoUtil.WeekZeroTimestamp()
Now := GoUtil.Now() now := GoUtil.Now()
if WeekZeroTimestamp > s.WeekResetTime { if weekZeroTimestamp > s.WeekResetTime {
RewardType := GoUtil.IfTrue(Now-int64(LastLoginTime) > GoUtil.SEVENDAYS && LastLoginTime > 0, BACK_REWARD, DEFAULT_REWARD).(int) rewardType := GoUtil.IfTrue(now-int64(lastLoginTime) > GoUtil.SEVENDAYS && lastLoginTime > 0, BACK_REWARD, DEFAULT_REWARD).(int)
s.IsBack = RewardType == BACK_REWARD s.IsBack = rewardType == BACK_REWARD
s.LoginReward = randWeekReward(Add, RewardType, level) s.LoginReward = randWeekReward(add, rewardType, level)
s.LoginReward = formatSevenReward(s.LoginReward, factor) s.LoginReward = formatSevenReward(s.LoginReward, factor)
s.WeekResetTime = WeekZeroTimestamp s.WeekResetTime = weekZeroTimestamp
s.DayR = 0 s.DayR = 0
} }
monthZeroTimestamp := GoUtil.MonthZeroTimestamp() monthZeroTimestamp := GoUtil.MonthZeroTimestamp()
@ -51,53 +51,53 @@ func (s *SevenLoginMod) ZeroUpdate(Add, LastLoginTime, factor, level int) {
s.DayR++ s.DayR++
} }
func (s *SevenLoginMod) GetReward(Id int) ([]*item.Item, error) { func (s *SevenLoginMod) GetReward(id int) ([]*item.Item, error) {
if Id > s.DayR { if id > s.DayR {
return nil, fmt.Errorf("id greater than login days") return nil, fmt.Errorf("id greater than login days")
} }
Reward := s.LoginReward[Id] reward := s.LoginReward[id]
if Reward.Status { if reward.Status {
return nil, fmt.Errorf("reward already received") return nil, fmt.Errorf("reward already received")
} }
Reward.Status = true reward.Status = true
s.LoginReward[Id] = Reward s.LoginReward[id] = reward
s.Active++ s.Active++
item := make([]*item.Item, 0) item := make([]*item.Item, 0)
item = append(item, Reward.Item1...) item = append(item, reward.Item1...)
item = append(item, Reward.Item2...) item = append(item, reward.Item2...)
item = append(item, Reward.Item3...) item = append(item, reward.Item3...)
return item, nil return item, nil
} }
func (s *SevenLoginMod) GetMonthReward(Id int) ([]*item.Item, error) { func (s *SevenLoginMod) GetMonthReward(id int) ([]*item.Item, error) {
NeedActive := sevenLoginCfg.GetMonthActive(Id) needActive := sevenLoginCfg.GetMonthActive(id)
if NeedActive > s.Active { if needActive > s.Active {
return nil, fmt.Errorf("id greater than active") return nil, fmt.Errorf("id greater than active")
} }
Reward := s.MonthReward[Id] reward := s.MonthReward[id]
if Reward.Status { if reward.Status {
return nil, fmt.Errorf("reward already received") return nil, fmt.Errorf("reward already received")
} }
Reward.Status = true reward.Status = true
s.MonthReward[Id] = Reward s.MonthReward[id] = reward
item := make([]*item.Item, 0) item := make([]*item.Item, 0)
item = append(item, Reward.Item1...) item = append(item, reward.Item1...)
item = append(item, Reward.Item2...) item = append(item, reward.Item2...)
item = append(item, Reward.Item3...) item = append(item, reward.Item3...)
return item, nil return item, nil
} }
func (s *SevenLoginMod) BackData() *msg.ResSevenLogin { func (s *SevenLoginMod) BackData() *msg.ResSevenLogin {
WeekReward := make([]*msg.SevenLoginReward, 0) weekReward := make([]*msg.SevenLoginReward, 0)
MonthReward := make([]*msg.SevenLoginReward, 0) monthReward := make([]*msg.SevenLoginReward, 0)
for k, v := range s.LoginReward { for k, v := range s.LoginReward {
Status := GoUtil.IfTrue(!v.Status && s.DayR >= k, 1, 0).(int) status := GoUtil.IfTrue(!v.Status && s.DayR >= k, 1, 0).(int)
Status = GoUtil.IfTrue(v.Status, 2, Status).(int) status = GoUtil.IfTrue(v.Status, 2, status).(int)
WeekReward = append(WeekReward, &msg.SevenLoginReward{ weekReward = append(weekReward, &msg.SevenLoginReward{
Item1: item.ItemToMsg(v.Item1), Item1: item.ItemToMsg(v.Item1),
Item2: item.ItemToMsg(v.Item2), Item2: item.ItemToMsg(v.Item2),
Item3: item.ItemToMsg(v.Item3), Item3: item.ItemToMsg(v.Item3),
Status: int32(Status), Status: int32(status),
Id: int32(k), Id: int32(k),
}) })
} }
@ -106,22 +106,22 @@ func (s *SevenLoginMod) BackData() *msg.ResSevenLogin {
if k < 0 { if k < 0 {
continue continue
} }
Active := sevenLoginCfg.GetMonthActive(k) active := sevenLoginCfg.GetMonthActive(k)
Status := GoUtil.IfTrue(!v.Status && s.Active >= Active, 1, 0).(int) status := GoUtil.IfTrue(!v.Status && s.Active >= active, 1, 0).(int)
Status = GoUtil.IfTrue(v.Status, 2, Status).(int) status = GoUtil.IfTrue(v.Status, 2, status).(int)
MonthReward = append(MonthReward, &msg.SevenLoginReward{ monthReward = append(monthReward, &msg.SevenLoginReward{
Item1: item.ItemToMsg(v.Item1), Item1: item.ItemToMsg(v.Item1),
Item2: item.ItemToMsg(v.Item2), Item2: item.ItemToMsg(v.Item2),
Item3: item.ItemToMsg(v.Item3), Item3: item.ItemToMsg(v.Item3),
Status: int32(Status), Status: int32(status),
Id: int32(k), Id: int32(k),
NeedActive: int32(Active), NeedActive: int32(active),
}) })
} }
return &msg.ResSevenLogin{ return &msg.ResSevenLogin{
WeekReward: WeekReward, WeekReward: weekReward,
MonthReward: MonthReward, MonthReward: monthReward,
Active: int32(s.Active), Active: int32(s.Active),
IsBack: s.IsBack, 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.Status = int32(PlayroomMod.Status)
r.Items = item.ItemToMsg(PlayroomMod.Reward) 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())) FriendList := make([]*proto.FriendRoom, 0, len(FriendMod.GetFriendList()))
if PlayroomMod.Target == 0 { if PlayroomMod.Target == 0 {
PlayroomMod.SetTarget(p.GetVisitorPlayer()) PlayroomMod.SetTarget(p.GetVisitorPlayer())
} }
TargerRoom := &proto.FriendRoom{} targetRoom := &proto.FriendRoom{}
if PlayroomMod.Target != 0 { if PlayroomMod.Target != 0 {
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(PlayroomMod.Target) playerData := G_GameLogicPtr.GetSimplePlayerByUid(PlayroomMod.Target)
if PlayerData != nil { if playerData != nil {
TargerRoom.Uid = int64(PlayerData.Uid) targetRoom.Uid = int64(playerData.Uid)
TargerRoom.Name = PlayerData.Name targetRoom.Name = playerData.Name
TargerRoom.Face = int32(PlayerData.Face) targetRoom.Face = int32(playerData.Face)
TargerRoom.Avatar = int32(PlayerData.Avatar) targetRoom.Avatar = int32(playerData.Avatar)
} else { } else {
PlayroomMod.Target = 0 PlayroomMod.Target = 0
} }
@ -48,7 +48,7 @@ func (p *Player) PlayroomBackData() {
continue continue
} }
if !FriendMod.CheckFriend(k) { if !FriendMod.CheckFriend(k) {
Opponent = append(Opponent, &proto.RoomOpponent{ opponent = append(opponent, &proto.RoomOpponent{
Uid: int64(k), Uid: int64(k),
Name: ps.Name, Name: ps.Name,
Face: int32(ps.Face), Face: int32(ps.Face),
@ -57,8 +57,8 @@ func (p *Player) PlayroomBackData() {
}) })
} }
} }
Friend := FriendMod.GetFriendList() friend := FriendMod.GetFriendList()
for k := range Friend { for k := range friend {
ps := G_GameLogicPtr.GetSimplePlayerByUid(k) ps := G_GameLogicPtr.GetSimplePlayerByUid(k)
if ps == nil { if ps == nil {
continue continue
@ -72,24 +72,24 @@ func (p *Player) PlayroomBackData() {
Times: int32(Times), Times: int32(Times),
}) })
} }
r.Opponent = Opponent r.Opponent = opponent
r.Friend = FriendList r.Friend = FriendList
r.Target = TargerRoom r.Target = targetRoom
collectList := PlayroomMod.GetCollect() collectList := PlayroomMod.GetCollect()
Collect := make([]*proto.PlayroomCollectInfo, 0, len(collectList)) collect := make([]*proto.PlayroomCollectInfo, 0, len(collectList))
for _, v := range collectList { for _, v := range collectList {
Collect = append(Collect, &proto.PlayroomCollectInfo{ collect = append(collect, &proto.PlayroomCollectInfo{
Id: int32(v.Id), Id: int32(v.Id),
AddTime: v.AddTime, AddTime: v.AddTime,
EndTime: v.EndTime, EndTime: v.EndTime,
Label: v.Label, Label: v.Label,
}) })
} }
r.Collect = Collect r.Collect = collect
Dress := make(map[int32]*proto.PlayroomDress) dress := make(map[int32]*proto.PlayroomDress)
for _, v := range PlayroomMod.GetDress() { for _, v := range PlayroomMod.GetDress() {
PlayroomDress, ok := Dress[int32(v.Part)] PlayroomDress, ok := dress[int32(v.Part)]
if !ok { if !ok {
PlayroomDress = &proto.PlayroomDress{} PlayroomDress = &proto.PlayroomDress{}
} }
@ -99,25 +99,25 @@ func (p *Player) PlayroomBackData() {
EndTime: int64(v.EndTime), EndTime: int64(v.EndTime),
Label: v.Label, 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 { for _, v := range PlayroomMod.ChipList {
ChipMessage = append(ChipMessage, &proto.ChipInfo{ chipMessage = append(chipMessage, &proto.ChipInfo{
Uid: int64(v.Uid), Uid: int64(v.Uid),
EmojiId: int32(v.Emoji), 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 { for k, v := range PlayroomMod.ADItem {
AdWatch = append(AdWatch, &proto.AdItem{ adWatch = append(adWatch, &proto.AdItem{
Watch: int32(v.Watch), Watch: int32(v.Watch),
LastWatch: int32(v.LastTime), LastWatch: int32(v.LastTime),
ItemId: int32(k), ItemId: int32(k),
}) })
} }
r.Dress = Dress r.Dress = dress
r.DressSet = GoUtil.MapIntToInt32(PlayroomMod.GetDressSet()) r.DressSet = GoUtil.MapIntToInt32(PlayroomMod.GetDressSet())
petAirList := PlayroomMod.GetPetAir() petAirList := PlayroomMod.GetPetAir()
PetAir := make([]*proto.PlayroomAirInfo, 0, len(petAirList)) PetAir := make([]*proto.PlayroomAirInfo, 0, len(petAirList))
@ -146,7 +146,7 @@ func (p *Player) PlayroomBackData() {
r.WeeklyDiscount = weeklyDiscount r.WeeklyDiscount = weeklyDiscount
r.PetAir = PetAir r.PetAir = PetAir
r.PetAirSet = int32(PlayroomMod.GetPetAirSet()) r.PetAirSet = int32(PlayroomMod.GetPetAirSet())
r.Chip = ChipMessage r.Chip = chipMessage
r.StartTime = int32(PlayroomMod.Starttime) r.StartTime = int32(PlayroomMod.Starttime)
r.WorkStatus = int32(PlayroomMod.WorkStatus) r.WorkStatus = int32(PlayroomMod.WorkStatus)
r.Playroom = GoUtil.MapIntToInt32(PlayroomMod.GetRoom()) r.Playroom = GoUtil.MapIntToInt32(PlayroomMod.GetRoom())
@ -162,34 +162,34 @@ func (p *Player) PlayroomBackData() {
r.Kiss = int32(p.GetPlayroomKiss(int(p.M_DwUin))) r.Kiss = int32(p.GetPlayroomKiss(int(p.M_DwUin)))
r.Revenge = PlayroomMod.RevengeUid r.Revenge = PlayroomMod.RevengeUid
r.InteractNum = int32(PlayroomMod.InteractNum) r.InteractNum = int32(PlayroomMod.InteractNum)
r.AdItem = AdWatch r.AdItem = adWatch
p.PushClientRes(r) p.PushClientRes(r)
} }
func (p *Player) PlayroomVisit(Uid int) { func (p *Player) PlayroomVisit(uid int) {
if Uid == 0 { if uid == 0 {
p.PushClientRes(&proto.ResPlayroomInfo{}) p.PushClientRes(&proto.ResPlayroomInfo{})
return return
} }
PlayroomMod := p.PlayMod.getPlayroomMod() PlayroomMod := p.PlayMod.getPlayroomMod()
r := &proto.ResPlayroomInfo{} r := &proto.ResPlayroomInfo{}
PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Uid) PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(uid)
if PlayerData == nil { if PlayerData == nil {
p.PushClientRes(&proto.ResPlayroomInfo{}) p.PushClientRes(&proto.ResPlayroomInfo{})
return return
} }
Now := GoUtil.Now() now := GoUtil.Now()
Work := false work := false
if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > Now { if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > now {
Work = true work = true
} }
r.Uid = int64(Uid) r.Uid = int64(uid)
r.Name = PlayerData.Name r.Name = PlayerData.Name
r.Face = int32(PlayerData.Face) r.Face = int32(PlayerData.Face)
r.Avatar = int32(PlayerData.Avatar) r.Avatar = int32(PlayerData.Avatar)
r.Playroom = GoUtil.MapIntToInt32(PlayerData.Playroom) r.Playroom = GoUtil.MapIntToInt32(PlayerData.Playroom)
r.GameId = int32(PlayroomMod.GameId) r.GameId = int32(PlayroomMod.GameId)
r.Defense = Work r.Defense = work
r.Emoji = GoUtil.MapIntToInt32(PlayerData.Emoji) r.Emoji = GoUtil.MapIntToInt32(PlayerData.Emoji)
r.PetName = PlayerData.PetName r.PetName = PlayerData.PetName
Items := make(map[int32]*proto.ItemInfo) Items := make(map[int32]*proto.ItemInfo)
@ -199,12 +199,12 @@ func (p *Player) PlayroomVisit(Uid int) {
Num: int32(v.Num), Num: int32(v.Num),
} }
} }
r.Upvote = GoUtil.InArray(Uid, PlayroomMod.UpvoteList) r.Upvote = GoUtil.InArray(uid, PlayroomMod.UpvoteList)
r.Items = Items r.Items = Items
r.Status = int32(PlayroomMod.GameStatus) r.Status = int32(PlayroomMod.GameStatus)
r.UpvoteCount = int32(p.GetPlayroomUpvote(Uid)) r.UpvoteCount = int32(p.GetPlayroomUpvote(uid))
r.Chip = int32(p.GetPlayroomChip(Uid)) r.Chip = int32(p.GetPlayroomChip(uid))
r.Kiss = int32(p.GetPlayroomKiss(Uid)) r.Kiss = int32(p.GetPlayroomKiss(uid))
r.DressSet = GoUtil.MapIntToInt32(PlayerData.DressSet) r.DressSet = GoUtil.MapIntToInt32(PlayerData.DressSet)
r.Fur = int32(PlayerData.PetFur) r.Fur = int32(PlayerData.PetFur)
p.PushClientRes(r) p.PushClientRes(r)
@ -242,17 +242,17 @@ func (p *Player) BackUserInfo() {
func (p *Player) ChargeBackData() { func (p *Player) ChargeBackData() {
c := p.PlayMod.getChargeMod() c := p.PlayMod.getChargeMod()
LimitedEventMod := p.PlayMod.getLimitedTimeEventMod() LimitedEventMod := p.PlayMod.getLimitedTimeEventMod()
SpecialShop := make(map[int32]*proto.ResSpecialShop) specialShop := make(map[int32]*proto.ResSpecialShop)
ChessShop := make(map[int32]*proto.ResChessShop) chessShop := make(map[int32]*proto.ResChessShop)
for k, v := range c.SpecialShop { for k, v := range c.SpecialShop {
SpecialShop[int32(k)] = &proto.ResSpecialShop{ specialShop[int32(k)] = &proto.ResSpecialShop{
Grade: int32(v.Grade), Grade: int32(v.Grade),
Count: int32(v.Count), Count: int32(v.Count),
} }
} }
for k, v := range c.ChessShop { for k, v := range c.ChessShop {
ChessShop[int32(k)] = &proto.ResChessShop{ chessShop[int32(k)] = &proto.ResChessShop{
Diamond: int32(v.Diamond), Diamond: int32(v.Diamond),
Count: int32(v.Count), Count: int32(v.Count),
ChessId: int32(v.Id), ChessId: int32(v.Id),
@ -266,20 +266,20 @@ func (p *Player) ChargeBackData() {
Uid: c.WishList.SendList, Uid: c.WishList.SendList,
} }
} }
WeeklyDiscount := make(map[int32]*proto.WeeklyDiscountInfo) weeklyDiscount := make(map[int32]*proto.WeeklyDiscountInfo)
WeeklyDiscountInfo := chargeCfg.GetWeeklyInfoAll() weeklyDiscountInfo := chargeCfg.GetWeeklyInfoAll()
// 优惠日开启或者猫咪闪促开启 // 优惠日开启或者猫咪闪促开启
if c.IsWeeklyDiscountDay() || LimitedEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_DAY_SALE) { 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] LimitNum := c.WeeklyDiscount[k]
WeeklyDiscount[int32(k)] = &proto.WeeklyDiscountInfo{ weeklyDiscount[int32(k)] = &proto.WeeklyDiscountInfo{
Discount: int32(v.Discount), Discount: int32(v.Discount),
Count: int32(v.WeeklyLimit - LimitNum), Count: int32(v.WeeklyLimit - LimitNum),
Id: int32(k), Id: int32(k),
} }
} }
} }
CatDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime() catDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime()
var specialChargeWeek int32 var specialChargeWeek int32
if c.LastSpecialCharge != 0 { if c.LastSpecialCharge != 0 {
specialChargeWeek = int32(GoUtil.FullWeeksSince(c.LastSpecialCharge)) specialChargeWeek = int32(GoUtil.FullWeeksSince(c.LastSpecialCharge))
@ -288,9 +288,9 @@ func (p *Player) ChargeBackData() {
Charge: float32(c.Charge), Charge: float32(c.Charge),
Total: int32(c.Total), Total: int32(c.Total),
First: GoUtil.MapIntToSlice(c.EnergyShop), First: GoUtil.MapIntToSlice(c.EnergyShop),
SpecialShop: SpecialShop, SpecialShop: specialShop,
FreeShop: int32(c.FreeShop), FreeShop: int32(c.FreeShop),
ChessShop: ChessShop, ChessShop: chessShop,
Gift: GoUtil.MapIntToInt32(c.Gift), Gift: GoUtil.MapIntToInt32(c.Gift),
Ad: c.Ad, Ad: c.Ad,
SpecialCharge: float32(c.SpecialCharge), SpecialCharge: float32(c.SpecialCharge),
@ -299,9 +299,9 @@ func (p *Player) ChargeBackData() {
MonthCharge: float32(c.MonthCharge), MonthCharge: float32(c.MonthCharge),
Wish: resWish, Wish: resWish,
AdEndTime: c.AdEndTime, AdEndTime: c.AdEndTime,
WeeklyDiscount: WeeklyDiscount, WeeklyDiscount: weeklyDiscount,
PetWorkRemainTime: c.PetWorkTime, PetWorkRemainTime: c.PetWorkTime,
WeeklyEndTime: max(c.WeeklyEndTime, CatDaySaleEndTime), WeeklyEndTime: max(c.WeeklyEndTime, catDaySaleEndTime),
}) })
} }
@ -335,16 +335,16 @@ func (p *Player) FriendListBackData() {
} }
} }
now := GoUtil.Now() now := GoUtil.Now()
ReqFriendList := make([]int64, 0, len(FriendMod.SendApply)) reqFriendList := make([]int64, 0, len(FriendMod.SendApply))
for k, v := range FriendMod.SendApply { for k, v := range FriendMod.SendApply {
if now-v > oneday { if now-v > oneday {
continue continue
} }
ReqFriendList = append(ReqFriendList, int64(k)) reqFriendList = append(reqFriendList, int64(k))
} }
p.PushClientRes(&proto.ResFriendList{ p.PushClientRes(&proto.ResFriendList{
FriendList: fl, FriendList: fl,
ReqApplyList: ReqFriendList, ReqApplyList: reqFriendList,
Npc: GoUtil.IntToInt32(FriendMod.GetNpc()), Npc: GoUtil.IntToInt32(FriendMod.GetNpc()),
Sponsor: int32(FriendMod.GetSponsor()), 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 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 = ?" sqlStr := "SELECT * FROM t_player_baseinfo WHERE user_name = ?"
sqlStruck := db.ResPlayerBaseInfo{} 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) log.Debug("PlayerBaseData get data failed, err:%v\n", err)
return false return false
} }
@ -118,10 +118,10 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
return true return true
} }
func (p *PlayerBaseData) LoadDataFromDBByUid(Uid int) bool { func (p *PlayerBaseData) LoadDataFromDBByUid(uid int) bool {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE DwUin = ?" sqlStr := "SELECT * FROM t_player_baseinfo WHERE DwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{} 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) log.Debug("PlayerBaseData get data failed, err:%v\n", err)
return false return false
} }
@ -151,7 +151,7 @@ func (p *PlayerBaseData) LoadDataFromDBByUid(Uid int) bool {
return true return true
} }
func (p *PlayerBaseData) SaveDataFromDB(Key interface{}) bool { func (p *PlayerBaseData) SaveDataFromDB(key interface{}) bool {
BaseMod := p.p.PlayMod.getBaseMod() BaseMod := p.p.PlayMod.getBaseMod()
sqlStruck := db.ResPlayerBaseInfo{} sqlStruck := db.ResPlayerBaseInfo{}
sqlStruck.Diamond = int32(BaseMod.Diamond) sqlStruck.Diamond = int32(BaseMod.Diamond)
@ -178,17 +178,16 @@ func (p *PlayerBaseData) SaveDataFromDB(Key interface{}) bool {
sqlStruck.FaceBookId = p.Data.FaceBookId sqlStruck.FaceBookId = p.Data.FaceBookId
sqlStruck.NickName = BaseMod.NickName sqlStruck.NickName = BaseMod.NickName
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin") db.FormatAllMemUpdateDb(&sqlStruck, "t_player_baseinfo", "dwUin")
return true return true
} }
func (p *PlayerBaseData) GetMaxEnergyMul(player *Player) int { func (p *PlayerBaseData) GetMaxEnergyMul(player *Player) int {
BaseMod := player.PlayMod.getBaseMod() 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) { if player.PlayMod.getLimitedTimeEventMod().CheckExist(limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER) {
MaxEnergyMul = 11 maxEnergyMul = 11
} }
return MaxEnergyMul return maxEnergyMul
} }
func (p *PlayerBaseData) GetMaxEnergy() int { func (p *PlayerBaseData) GetMaxEnergy() int {
@ -276,7 +275,6 @@ func (p *PlayerBaseData) ReqUnBindFacebook(player *Player, buf []byte) {
if err != nil { if err != nil {
return return
} }
res.ResultCode = 0 res.ResultCode = 0
res.BindAccountId = req.BindAccountId res.BindAccountId = req.BindAccountId
p.Data.FaceBookId = "" p.Data.FaceBookId = ""
@ -298,7 +296,6 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(player *Player, buf []byte) {
if err != nil { if err != nil {
return return
} }
sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?" sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?"
sqlStruck := db.ResPlayerBaseInfo{} sqlStruck := db.ResPlayerBaseInfo{}
isHaveOther := false isHaveOther := false
@ -313,7 +310,6 @@ func (p *PlayerBaseData) ReqOnlyBindFacebook(player *Player, buf []byte) {
res.ResultCode = MergeConst.Protocol_FaceBook_Binded res.ResultCode = MergeConst.Protocol_FaceBook_Binded
} else { } else {
sqlStruck.FaceBookId = "" sqlStruck.FaceBookId = ""
// 修改双方的faceBookId // 修改双方的faceBookId
ctx := context.Background() ctx := context.Background()
txOptions := &sql.TxOptions{} txOptions := &sql.TxOptions{}
@ -365,11 +361,9 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
if err != nil { if err != nil {
return return
} }
sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?" sqlStr := "SELECT * FROM t_player_baseinfo WHERE FaceBookId = ?"
sqlStruck := db.ResPlayerBaseInfo{} sqlStruck := db.ResPlayerBaseInfo{}
isHaveOther := false isHaveOther := false
if err := db.SqlDb.Get(&sqlStruck, sqlStr, req.NewFBId); err != nil { if err := db.SqlDb.Get(&sqlStruck, sqlStr, req.NewFBId); err != nil {
isHaveOther = false isHaveOther = false
} else { } else {
@ -378,16 +372,16 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
if sqlStruck.DwUin == player.M_DwUin { if sqlStruck.DwUin == player.M_DwUin {
return return
} }
OldPlayer := G_GameLogicPtr.GetPlayer(sqlStruck.DwUin) oldPlayer := G_GameLogicPtr.GetPlayer(sqlStruck.DwUin)
if OldPlayer != nil { if oldPlayer != nil {
agent := OldPlayer.GetAgentByPlayer() agent := oldPlayer.GetAgentByPlayer()
// notify := &msg.ForceKickOut{} // notify := &msg.ForceKickOut{}
notify := &msg.ResSynGameData{} notify := &msg.ResSynGameData{}
data, _ := proto.Marshal(notify) data, _ := proto.Marshal(notify)
if agent != nil { if agent != nil {
G_getGameLogic().PackResInfo(agent, "ResSynGameData", data) G_getGameLogic().PackResInfo(agent, "ResSynGameData", data)
} }
OldPlayer.ClearData() oldPlayer.ClearData()
G_GameLogicPtr.M_Players.Delete(sqlStruck.DwUin) 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 { if sqlStruck.DwUin == p.Data.DwUin {
res.ResultCode = MergeConst.Protocol_FaceBook_Binded res.ResultCode = MergeConst.Protocol_FaceBook_Binded
} else { } else {
ReplaceName := sqlStruck.UserName replaceName := sqlStruck.UserName
UserName := p.Data.UserName userName := p.Data.UserName
res.ResultCode = 0 res.ResultCode = 0
// 修改双方的账号 // 修改双方的账号
ctx := context.Background() ctx := context.Background()
@ -404,7 +398,7 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
tx, _ := db.SqlDb.BeginTx(ctx, txOptions) tx, _ := db.SqlDb.BeginTx(ctx, txOptions)
sqlStr1 := "SELECT * FROM t_account WHERE user_name = ?" sqlStr1 := "SELECT * FROM t_account WHERE user_name = ?"
sqlAccStruck1 := db.Db_Account{} sqlAccStruck1 := db.Db_Account{}
err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, UserName) err2 := db.SqlDb.Get(&sqlAccStruck1, sqlStr1, userName)
if err2 == nil { if err2 == nil {
sqlAccStruck1.UserName = "" sqlAccStruck1.UserName = ""
_, err := db.SqlDb.Exec("update t_account set user_name = ? where auto_id = ?", sqlAccStruck1.UserName, sqlAccStruck1.AutoId) _, 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.FaceBookId = req.NewFBId
sqlStruck.UserName = UserName sqlStruck.UserName = userName
_, err = db.SqlDb.Exec("update t_player_baseinfo set user_name = ?, FaceBookId = ? where dwUin = ?", UserName, req.NewFBId, sqlStruck.DwUin) _, err = db.SqlDb.Exec("update t_player_baseinfo set user_name = ?, FaceBookId = ? where dwUin = ?", userName, req.NewFBId, sqlStruck.DwUin)
if err != nil { if err != nil {
tx.Rollback() tx.Rollback()
return return
@ -430,9 +424,9 @@ func (p *PlayerBaseData) ReqSynGameData(player *Player, buf []byte) {
sqlStr := "SELECT * FROM t_account WHERE user_name = ?" sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
sqlAccStruck := db.Db_Account{} sqlAccStruck := db.Db_Account{}
err2 = db.SqlDb.Get(&sqlAccStruck, sqlStr, ReplaceName) err2 = db.SqlDb.Get(&sqlAccStruck, sqlStr, replaceName)
if err2 == nil { 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) _, err := db.SqlDb.Exec("update t_account set user_name = ? where auto_id = ?", sqlAccStruck.UserName, sqlAccStruck.AutoId)
if err != nil { if err != nil {
tx.Rollback() tx.Rollback()
@ -468,16 +462,16 @@ func (p *PlayerBaseData) GetRegisterTime() int64 {
// 增加减少体力 // 增加减少体力
func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error { func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod() BaseMod := p.p.PlayMod.getBaseMod()
NewEnergy := BaseMod.Energy + cnt newEnergy := BaseMod.Energy + cnt
if NewEnergy < 0 { if newEnergy < 0 {
return errors.New("能量不足") return errors.New("能量不足")
} }
if cnt < 0 { if cnt < 0 {
player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_ENERGY, A: []interface{}{-cnt}}) player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_ENERGY, A: []interface{}{-cnt}})
// BaseMod.FormatEnergyMul(NewEnergy) // BaseMod.FormatEnergyMul(newEnergy)
p.p.PushClientRes(BaseMod.BackData()) 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)) Recover := userCfg.GetRecover(int(BaseMod.Level))
player.CallEvent(time.Duration(Recover)*time.Second, func() { player.CallEvent(time.Duration(Recover)*time.Second, func() {
player.lock.Lock() player.lock.Lock()
@ -486,21 +480,21 @@ func (p *PlayerBaseData) AddEnergy(player *Player, cnt int) error {
}, "AddEnergy") }, "AddEnergy")
BaseMod.RecoverTime = time.Now().Unix() BaseMod.RecoverTime = time.Now().Unix()
} }
BaseMod.Energy = NewEnergy BaseMod.Energy = newEnergy
return nil return nil
} }
// 增加减少星星 // 增加减少星星
func (p *PlayerBaseData) AddStar(player *Player, cnt int) error { func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod() BaseMod := p.p.PlayMod.getBaseMod()
NewStar := BaseMod.Star + cnt newStar := BaseMod.Star + cnt
if NewStar < 0 { if newStar < 0 {
return errors.New("星星不足") return errors.New("星星不足")
} }
if cnt > 0 { if cnt > 0 {
player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STAR, A: []interface{}{cnt}}) player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STAR, A: []interface{}{cnt}})
} }
BaseMod.Star = NewStar BaseMod.Star = newStar
player.UpdateUserInfo() player.UpdateUserInfo()
return nil return nil
} }
@ -508,11 +502,11 @@ func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
// 增加减少钻石 // 增加减少钻石
func (p *PlayerBaseData) AddDiamond(cnt int) error { func (p *PlayerBaseData) AddDiamond(cnt int) error {
BaseMod := p.p.PlayMod.getBaseMod() BaseMod := p.p.PlayMod.getBaseMod()
NewDiamond := BaseMod.Diamond + cnt newDiamond := BaseMod.Diamond + cnt
if NewDiamond < 0 { if newDiamond < 0 {
return errors.New("钻石不足") return errors.New("钻石不足")
} }
BaseMod.Diamond = NewDiamond BaseMod.Diamond = newDiamond
return nil return nil
} }
@ -523,13 +517,13 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
BaseMod.PExp += pexp BaseMod.PExp += pexp
upLv := 0 upLv := 0
upExp, upPExp := userCfg.GetLevUpExp(BaseMod.Level) upExp, upPExp := userCfg.GetLevUpExp(BaseMod.Level)
Num := 0 num := 0
UpLevelItem := make([]*item.Item, 0) upLevelItem := make([]*item.Item, 0)
for BaseMod.Exp >= upExp && BaseMod.PExp >= upPExp { for BaseMod.Exp >= upExp && BaseMod.PExp >= upPExp {
if Num > 100 { if num > 100 {
break break
} }
Num++ num++
BaseMod.Level++ BaseMod.Level++
BaseMod.Exp -= upExp BaseMod.Exp -= upExp
BaseMod.PExp -= upPExp BaseMod.PExp -= upPExp
@ -541,8 +535,8 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
player.PushClientRes(DailyTaskMod.BackData()) player.PushClientRes(DailyTaskMod.BackData())
} }
upLv = BaseMod.Level upLv = BaseMod.Level
Items := userCfg.GetLevUpReward(upLv) items := userCfg.GetLevUpReward(upLv)
UpLevelItem = item.Merge(UpLevelItem, Items) upLevelItem = item.Merge(upLevelItem, items)
// 棋盘背包解锁 // 棋盘背包解锁
player.PushClientRes(p.BackAsset()) player.PushClientRes(p.BackAsset())
ChessMod := player.PlayMod.getChessMod() ChessMod := player.PlayMod.getChessMod()
@ -577,8 +571,8 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
}) })
player.HandleInUserRank() player.HandleInUserRank()
} }
if len(UpLevelItem) > 0 { if len(upLevelItem) > 0 {
err := player.HandleItem(UpLevelItem, msg.ITEM_POP_LABEL_LevUpReward.String()) err := player.HandleItem(upLevelItem, msg.ITEM_POP_LABEL_LevUpReward.String())
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -658,10 +652,10 @@ func (p *PlayerBaseData) GetLoginTime() int64 {
return int64(BaseMod.LoginTime) 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 = ?" sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{} 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) // log.Debug("get data failed, err:%v\n", err)
return false 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 { func (p *PlayerChessData) LoadDataFromDB(dwUin interface{}) bool {
return true return true
} }
func (p *PlayerChessData) Reconnect(b bool) { func (p *PlayerChessData) Reconnect(b bool) {}
}
func (p *PlayerChessData) SaveDataFromDB(Key interface{}) bool {
func (p *PlayerChessData) SaveDataFromDB(key interface{}) bool {
return true return true
} }
func (p *PlayerChessData) ResPlayerChessData(player *Player) { func (p *PlayerChessData) ResPlayerChessData(player *Player) {
agent := player.GetAgentByPlayer() agent := player.GetAgentByPlayer()
Msg := &p.Data res := &p.Data
ChessMod := player.PlayMod.getChessMod() ChessMod := player.PlayMod.getChessMod()
Msg.ChessList = ChessMod.BackData().ChessList res.ChessList = ChessMod.BackData().ChessList
Msg.MChessData = ChessMod.ChessMap res.MChessData = ChessMod.ChessMap
data, _ := proto.Marshal(Msg) data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResPlayerChessData", data) 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 { func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) error {
update := &msg.UpdatePlayerChessData{} update := &msg.UpdatePlayerChessData{}
proto.Unmarshal(buf, update) proto.Unmarshal(buf, update)
LastMap := player.PlayMod.getChessMod().ChessMap lastMap := player.PlayMod.getChessMod().ChessMap
AddChessList, AddNewEmit, err := p.HandleChess(player, update.MChessHandle) addChessList, addNewEmit, err := p.HandleChess(player, update.MChessHandle)
if err != nil { if err != nil {
res := &msg.ResUpdatePlayerChessData{ res := &msg.ResUpdatePlayerChessData{
Code: msg.RES_CODE_FAIL, Code: msg.RES_CODE_FAIL,
Msg: err.Error(), Msg: err.Error(),
} }
HandleStr := "" handleStr := ""
sort.Slice(update.MChessHandle, func(i, j int) bool { sort.Slice(update.MChessHandle, func(i, j int) bool {
return update.MChessHandle[i].Id < update.MChessHandle[j].Id return update.MChessHandle[i].Id < update.MChessHandle[j].Id
}) })
for _, v := range update.MChessHandle { 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.SendErrClienRes(res)
return err return err
} }
@ -85,14 +80,14 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
Code: msg.RES_CODE_FAIL, Code: msg.RES_CODE_FAIL,
Msg: "棋子数据不一致", Msg: "棋子数据不一致",
} }
HandleStr := "" handleStr := ""
sort.Slice(update.MChessHandle, func(i, j int) bool { sort.Slice(update.MChessHandle, func(i, j int) bool {
return update.MChessHandle[i].Id < update.MChessHandle[j].Id return update.MChessHandle[i].Id < update.MChessHandle[j].Id
}) })
for _, v := range update.MChessHandle { 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.SendErrClienRes(res)
player.TeLog("outsync_event", map[string]interface{}{ player.TeLog("outsync_event", map[string]interface{}{
"outsync_event": "UpdatePlayerChessDataFunc", "outsync_event": "UpdatePlayerChessDataFunc",
@ -103,7 +98,7 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
BaseMod := player.PlayMod.getBaseMod() BaseMod := player.PlayMod.getBaseMod()
OrderMod := player.PlayMod.getOrderMod() OrderMod := player.PlayMod.getOrderMod()
ChessMod.ChessMap = update.MChessData 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 { if Update {
player.InitOrderItem() player.InitOrderItem()
player.PushClientRes(OrderMod.BackData()) player.PushClientRes(OrderMod.BackData())
@ -111,8 +106,8 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
return nil return nil
} }
func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]int32) error { func (p *PlayerChessData) UpdateChessData(player *Player, mChessData map[string]int32) error {
p.Data.MChessData = MChessData p.Data.MChessData = mChessData
if !p.checkChessEqual(player) { if !p.checkChessEqual(player) {
res := &msg.ResUpdatePlayerChessData{ res := &msg.ResUpdatePlayerChessData{
Code: msg.RES_CODE_FAIL, Code: msg.RES_CODE_FAIL,
@ -125,7 +120,7 @@ func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]
}) })
return fmt.Errorf("棋子数据不一致") return fmt.Errorf("棋子数据不一致")
} }
player.PlayMod.getChessMod().ChessMap = MChessData player.PlayMod.getChessMod().ChessMap = mChessData
return nil 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" { if len(p.Data.MChessData) == 0 && conf.Server.GameName == "Merge_Pet_Local" {
return true return true
} }
ChessList := player.PlayMod.getChessMod().GetChessList() chessList := player.PlayMod.getChessMod().GetChessList()
if len(ChessList) != len(p.Data.MChessData) { if len(chessList) != len(p.Data.MChessData) {
return false return false
} }
aCopy := make([]int, 0, len(ChessList)) aCopy := make([]int, 0, len(chessList))
bCopy := make([]int, 0, len(p.Data.MChessData)) bCopy := make([]int, 0, len(p.Data.MChessData))
for _, v := range ChessList { for _, v := range chessList {
aCopy = append(aCopy, int(v)) aCopy = append(aCopy, int(v))
} }
for _, v := range p.Data.MChessData { for _, v := range p.Data.MChessData {
bCopy = append(bCopy, int(v)) bCopy = append(bCopy, int(v))
} }
isEqual := SlicesEqual(aCopy, bCopy) if SlicesEqual(aCopy, bCopy) {
if isEqual {
return true return true
} }
// 找出aCopy多的元素和少的元素 // 找出aCopy多的元素和少的元素
@ -199,75 +192,75 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
HandbookMod := player.PlayMod.getHandbookMod() HandbookMod := player.PlayMod.getHandbookMod()
var addChessCostEnergy int var addChessCostEnergy int
var buyChess int var buyChess int
LimitPush := false // 限时事件推送 limitPush := false // 限时事件推送
var TriggerList []*quest.Trigger var TriggerList []*quest.Trigger
var itemList []*item.Item var itemList []*item.Item
var AddChessList []int var addChessList []int
var AddNewEmit []int var addNewEmit []int
EmitList := ChessMod.GetEmitList() emitList := ChessMod.GetEmitList()
for _, v := range handle_list { for _, v := range handle_list {
ChessId := int(v.ChessId) chessId := int(v.ChessId)
EmitId := int(v.Emit) emitId := int(v.Emit)
switch v.Type { switch v.Type {
case msg.HANDLE_TYPE_ADD: //增加棋子 case msg.HANDLE_TYPE_ADD: //增加棋子
err := ChessMod.AddChess(ChessId) err := ChessMod.AddChess(chessId)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
Type := mergeDataCfg.GetTypeById(ChessId) chessType := mergeDataCfg.GetTypeById(chessId)
AddChessList = append(AddChessList, ChessId) addChessList = append(addChessList, chessId)
if !GoUtil.InArray(EmitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706, 0}) && Type != "Resource" { // 宝箱生成的棋子不扣体力 if !GoUtil.InArray(emitId, []int{561, 562, 563, 564, 701, 702, 703, 704, 705, 706, 0}) && chessType != "Resource" { // 宝箱生成的棋子不扣体力
addChessCostEnergy++ addChessCostEnergy++
} }
b := HandbookMod.SetHandbook(ChessId) // 添加图鉴 b := HandbookMod.SetHandbook(chessId) // 添加图鉴
if b { if b {
player.TeLog("collection_add", map[string]interface{}{ player.TeLog("collection_add", map[string]interface{}{
"item_id": ChessId, "item_id": chessId,
"item_name": mergeDataCfg.GetNameById(ChessId), "item_name": mergeDataCfg.GetNameById(chessId),
}) })
AddNewEmit = append(AddNewEmit, ChessId) addNewEmit = append(addNewEmit, chessId)
} }
player.PushClientRes(HandbookMod.BackData()) player.PushClientRes(HandbookMod.BackData())
case msg.HANDLE_TYPE_COMPOSE: //合成棋子 case msg.HANDLE_TYPE_COMPOSE: //合成棋子
NewChessId, err := ChessMod.ComposeChess(ChessId) newChessId, err := ChessMod.ComposeChess(chessId)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
b := HandbookMod.SetHandbook(NewChessId) // 添加图鉴 b := HandbookMod.SetHandbook(newChessId) // 添加图鉴
if b { if b {
AddNewEmit = append(AddNewEmit, NewChessId) addNewEmit = append(addNewEmit, newChessId)
} }
AddChessList = append(AddChessList, NewChessId) addChessList = append(addChessList, newChessId)
NewChessIdLv := mergeDataCfg.GetLvById(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_MERGELVTIME, A: []interface{}{newChessIdLv}})
TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGETIME}) TriggerList = append(TriggerList, &quest.Trigger{Label: quest.TRIGGER_LABEL_MERGETIME})
player.PushClientRes(HandbookMod.BackData()) 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)) ActItem := player.GetActivityItem(GoUtil.Int32ToInt(v.ActType))
itemList = item.Merge(itemList, ActItem) itemList = item.Merge(itemList, ActItem)
case msg.HANDLE_TYPE_BUY: //购买棋子 case msg.HANDLE_TYPE_BUY: //购买棋子
loseGold, err := ChessMod.BuyChess(ChessId) loseGold, err := ChessMod.BuyChess(chessId)
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
AddChessList = append(AddChessList, ChessId) addChessList = append(addChessList, chessId)
buyChess += loseGold buyChess += loseGold
itemList = append(itemList, &item.Item{Id: item.ITEM_STAR_ID, Num: int(-loseGold)}) itemList = append(itemList, &item.Item{Id: item.ITEM_STAR_ID, Num: int(-loseGold)})
case msg.HANDLE_TYPE_SELL: //出售棋子 case msg.HANDLE_TYPE_SELL: //出售棋子
items, err := ChessMod.SellChess(ChessId) items, err := ChessMod.SellChess(chessId)
if checkChess(ChessId, BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) { // 在订单中无法生成的棋子 出售获得原价宠物币 if checkChess(chessId, BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) { // 在订单中无法生成的棋子 出售获得原价宠物币
items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(ChessId)}} items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: mergeDataCfg.GetStarById(chessId)}}
} }
LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod() LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
ChessType := mergeDataCfg.GetTypeById(ChessId) chessType := mergeDataCfg.GetTypeById(chessId)
if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) && ChessType == "Product" { // 限时活动 返利日 if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) && chessType == "Product" { // 限时活动 返利日
err = LimitedTimeEventMod.SubPaybackDay() err = LimitedTimeEventMod.SubPaybackDay()
if err == nil { 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 { if err != nil {
return nil, nil, err return nil, nil, err
@ -277,8 +270,8 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
get_star_num = items[0].Num get_star_num = items[0].Num
} }
player.TeLog("sell_item", map[string]interface{}{ player.TeLog("sell_item", map[string]interface{}{
"merge_item_id": ChessId, "merge_item_id": chessId,
"product_name": mergeDataCfg.GetNameById(ChessId), "product_name": mergeDataCfg.GetNameById(chessId),
"get_star_num": get_star_num, "get_star_num": get_star_num,
}) })
itemList = item.Merge(itemList, items) 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)) ActItem := player.GetActivityItem(GoUtil.Int32ToInt(v.ActType))
itemList = item.Merge(itemList, ActItem) itemList = item.Merge(itemList, ActItem)
case msg.HANDLE_TYPE_REMOVE: //移除棋子 case msg.HANDLE_TYPE_REMOVE: //移除棋子
ChessMod.RemoveChess(ChessId) ChessMod.RemoveChess(chessId)
} }
} }
//扣除体力 //扣除体力
EnergyPow := BaseMod.GetEnergyMul() energyPow := BaseMod.GetEnergyMul()
ReduceEneny := 0 reduceEneny := 0
if addChessCostEnergy > 0 { if addChessCostEnergy > 0 {
ReduceEneny = int(math.Pow(2, float64(EnergyPow))) * addChessCostEnergy reduceEneny = int(math.Pow(2, float64(energyPow))) * addChessCostEnergy
itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: -ReduceEneny}) itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: -reduceEneny})
} }
err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandleChess.String()) err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandleChess.String())
if err != nil { if err != nil {
return nil, nil, err return nil, nil, err
} }
NewEmitList := ChessMod.GetEmitList() newEmitList := ChessMod.GetEmitList()
var EmitProductList []string var emitProductList []string
for _, v := range EmitList { for _, v := range emitList {
ColorList := mergeDataCfg.GetEmitProduceType(v) ColorList := mergeDataCfg.GetEmitProduceType(v)
EmitProductList = append(EmitProductList, ColorList...) emitProductList = append(emitProductList, ColorList...)
} }
var NewEmitProductList []string var newEmitProductList []string
for _, v := range NewEmitList { for _, v := range newEmitList {
ColorList := mergeDataCfg.GetEmitProduceType(v) ColorList := mergeDataCfg.GetEmitProduceType(v)
NewEmitProductList = append(NewEmitProductList, ColorList...) newEmitProductList = append(newEmitProductList, ColorList...)
} }
OrderMod := player.PlayMod.getOrderMod() OrderMod := player.PlayMod.getOrderMod()
if !GoUtil.SlicesEqualString(EmitProductList, NewEmitProductList) { if !GoUtil.SlicesEqualString(emitProductList, newEmitProductList) {
// 发射器系列变化，重新洗牌 // 发射器系列变化，重新洗牌
OrderMod.ResetChessPool() OrderMod.ResetChessPool()
} }
@ -321,10 +314,10 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
// 限时事件 小猫戏法 // 限时事件 小猫戏法
LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod() LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) { if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
LimitedTimeEventMod.AddCatTrickEnergy(ReduceEneny) LimitedTimeEventMod.AddCatTrickEnergy(reduceEneny)
LimitPush = true limitPush = true
} }
if LimitPush { if limitPush {
player.PushClientRes(LimitedTimeEventMod.BackData()) player.PushClientRes(LimitedTimeEventMod.BackData())
} }
player.QuestTriggerList(TriggerList) player.QuestTriggerList(TriggerList)
@ -332,80 +325,80 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
player.InitOrderItem() player.InitOrderItem()
player.PushClientRes(ChessMod.BackData()) player.PushClientRes(ChessMod.BackData())
player.PlayMod.save() player.PlayMod.save()
return AddChessList, AddNewEmit, nil return addChessList, addNewEmit, nil
} }
func (p *PlayerChessData) ClearData() bool { func (p *PlayerChessData) ClearData() bool {
return true return true
} }
func checkChess(ChessId, EnergyMul int, Emit []int) bool { func checkChess(chessId, energyMul int, emit []int) bool {
if len(Emit) == 0 { if len(emit) == 0 {
return false return false
} }
ChessIdLv := mergeDataCfg.GetLvById(ChessId) chessIdLv := mergeDataCfg.GetLvById(chessId)
ChessIdType := mergeDataCfg.GetTypeById(ChessId) chessIdType := mergeDataCfg.GetTypeById(chessId)
if ChessIdType != "Product" { if chessIdType != "Product" {
return false return false
} }
ChessIdColor := mergeDataCfg.GetColorById(ChessId) chessIdColor := mergeDataCfg.GetColorById(chessId)
if ChessIdColor == "Star" || ChessIdColor == "Energy" || ChessIdColor == "Diamond" { if chessIdColor == "Star" || chessIdColor == "Energy" || chessIdColor == "Diamond" {
return false return false
} }
EmitId := 0 emitId := 0
for _, v := range Emit { for _, v := range emit {
ProduceColor := mergeDataCfg.GetEmitProduceType(v) ProduceColor := mergeDataCfg.GetEmitProduceType(v)
if GoUtil.InStringArray(ChessIdColor, ProduceColor) { if GoUtil.InStringArray(chessIdColor, ProduceColor) {
EmitId = v emitId = v
break break
} }
} }
_, Max := getChesslvRange(EmitId, EnergyMul, false) _, max := getChesslvRange(emitId, energyMul, false)
Adjust := mergeDataCfg.GetAdjust(EmitId, ChessIdColor, EnergyMul) adjust := mergeDataCfg.GetAdjust(emitId, chessIdColor, energyMul)
return ChessIdLv > Max-Adjust return chessIdLv > max-adjust
} }
func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) { func getChesslvRange(emit int, energyMul int, isCharge bool) (int, int) {
RandEmitLv := mergeDataCfg.GetLvById(Emit) randEmitLv := mergeDataCfg.GetLvById(emit)
EmitId := mergeDataCfg.GetEmitId(Emit) emitId := mergeDataCfg.GetEmitId(emit)
RandMaxLv := mergeDataCfg.GetMaxLvById(Emit) randMaxLv := mergeDataCfg.GetMaxLvById(emit)
RandEmitMinLv := mergeDataCfg.GetEmitMinLvById(EmitId) randEmitMinLv := mergeDataCfg.GetEmitMinLvById(emitId)
Ratio := mergeDataCfg.GetEmitRatio(EmitId) ratio := mergeDataCfg.GetEmitRatio(emitId)
m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) / Ratio * 100) m := int(float64(1+randEmitLv-randEmitMinLv) / float64(1+randMaxLv-randEmitMinLv) / ratio * 100)
if IsCharge { if isCharge {
m += 10 m += 10
} }
m = max(1, m) m = max(1, m)
m = min(100, m) m = min(100, m)
ChessMinLev := orderCfg.GetLvMin(EnergyMul) ChessMinLev := orderCfg.GetLvMin(energyMul)
ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m) ChessMaxLev := orderCfg.GetLvMax(energyMul, m)
return ChessMinLev, ChessMaxLev 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() OrderMod := player.PlayMod.getOrderMod()
if OrderMod.Step < 12 { if OrderMod.Step < 12 {
return return
} }
if !checkChess(ChessId, EnergyMul, Emit) { if !checkChess(chessId, energyMul, emit) {
return return
} }
ChessMod := player.PlayMod.getChessMod() ChessMod := player.PlayMod.getChessMod()
ChessList := ChessMod.GetUnlockChessList() ChessList := ChessMod.GetUnlockChessList()
ChessNum := 0 chessNum := 0
for _, v := range ChessList { for _, v := range ChessList {
if v == ChessId { if v == chessId {
ChessNum++ chessNum++
} }
} }
OrderNum := 0 orderNum := 0
for _, v := range OrderMod.GetOrderList() { for _, v := range OrderMod.GetOrderList() {
if v.Type == order.Clean_Order_type && v.MergeId[0] == ChessId { if v.Type == order.Clean_Order_type && v.MergeId[0] == chessId {
OrderNum++ orderNum++
} }
} }
if OrderNum >= ChessNum { if orderNum >= chessNum {
return return
} }
OrderMod.CreateCleanOrder2([]int{ChessId}) OrderMod.CreateCleanOrder2([]int{chessId})
player.PushClientRes(OrderMod.BackData()) player.PushClientRes(OrderMod.BackData())
} }

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

@ -7,7 +7,6 @@ import (
"errors" "errors"
"math" "math"
"server/conf" "server/conf"
activityCfg "server/conf/activity"
cardCfg "server/conf/card" cardCfg "server/conf/card"
chargeCfg "server/conf/charge" chargeCfg "server/conf/charge"
fur_cfg "server/conf/fur" fur_cfg "server/conf/fur"
@ -70,6 +69,7 @@ type Player struct {
stopOnce sync.Once stopOnce sync.Once
msgChanOnce sync.Once msgChanOnce sync.Once
func_time int func_time int
config_list map[string]interface{}
} }
type PlayerBackUp struct { type PlayerBackUp struct {
@ -82,6 +82,22 @@ type PlayerMsg struct {
B []byte 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() { func (p *Player) Stop() {
p.wg.Wait() p.wg.Wait()
p.signalDispatcherStop() p.signalDispatcherStop()
@ -201,10 +217,10 @@ func (p *Player) ProcessTrigger() {
// 接口请求之前备份数据 // 接口请求之前备份数据
func (p *Player) BackUp() *PlayerBackUp { func (p *Player) BackUp() *PlayerBackUp {
BackUp := PlayerBackUp{} BackUp := playerDataPool.Get().(*PlayerBackUp)
p.PlayMod.BackUp(&BackUp) p.PlayMod.BackUp(BackUp)
BackUp.Data = p.GetPlayerBaseMod().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() { func (p *Player) InitActivity() {
p.activity = make(map[int]*ActivityInfo) p.activity = make(map[int]*ActivityInfo)
ActivityList := activityCfg.GetActivityList() ActivityList := G_GameLogicPtr.ActivityMgr.GetActivityList()
Level := p.GetPlayerBaseMod().GetLevel() Level := p.GetPlayerBaseMod().GetLevel()
ActivityMod := p.PlayMod.getActivityMod()
now := GoUtil.Now() now := GoUtil.Now()
var startduration int64 var startduration int64
var minduration int64 var minduration int64
@ -1220,24 +1235,21 @@ func (p *Player) InitActivity() {
if v.Level > Level { if v.Level > Level {
continue continue
} }
Status := ActivityMod.GetActivityStatus(v) Status := 1
if Status == 0 { startduration = v.Startime - now
continue endduration = v.Endtime - now + 1
}
startduration = v.StartTime - now
endduration = v.EndTime - now + 1
if startduration > 0 && (minduration == 0 || minduration > startduration) { if startduration > 0 && (minduration == 0 || minduration > startduration) {
minduration = startduration minduration = startduration
} }
if endduration > 0 && (minduration == 0 || minduration > endduration) { if endduration > 0 && (minduration == 0 || minduration > endduration) {
minduration = endduration minduration = endduration
} }
if v.StartTime > now || v.EndTime < now { if v.Startime > now || v.Endtime < now {
continue continue
} }
p.activity[v.Id] = &ActivityInfo{ p.activity[v.Id] = &ActivityInfo{
StartT: v.StartTime, StartT: v.Startime,
EndT: v.EndTime, EndT: v.Endtime,
Id: v.Id, Id: v.Id,
Type: v.Type, Type: v.Type,
Status: Status, Status: Status,
@ -1247,7 +1259,7 @@ func (p *Player) InitActivity() {
if minduration > 0 { if minduration > 0 {
p.CallEvent(time.Duration(minduration)*time.Second, p.TickActivity, "init_activity") 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 { if ActivityMod.AddEnd > now && !ActivityMod.AddReward {
p.CallEvent(time.Duration(ActivityMod.AddEnd-now)*time.Second, p.TickActivityAddGift, "init_activity_add_gift") 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), From: int(player.M_DwUin),
To: int(ReplyInfo.Uid), To: int(ReplyInfo.Uid),
Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE, Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
Extra: CatnipMsg{ Extra: map[string]interface{}{
ActivityId: ActivityId, "ActivityId": ActivityId,
GameId: int(GameId), "GameId": int(GameId),
}, },
SendT: now, SendT: now,
End: now + sevendays, End: now + sevendays,
@ -465,9 +465,9 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
From: int(player.M_DwUin), From: int(player.M_DwUin),
To: int(v), To: int(v),
Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE, Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
Extra: CatnipMsg{ Extra: map[string]interface{}{
ActivityId: ActivityId, "ActivityId": ActivityId,
GameId: int(GameId), "GameId": int(GameId),
}, },
SendT: now, SendT: now,
End: now + sevendays, End: now + sevendays,

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

@ -183,15 +183,6 @@ func UnitLimitProgress(p *Player) error {
return nil 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 { func UnitCard(p *Player) error {
CardMod := p.PlayMod.getCardMod() CardMod := p.PlayMod.getCardMod()
for i := 0; i < 10000; i++ { for i := 0; i < 10000; i++ {

5
src/server/main.go
View File

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

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

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

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

@ -141,7 +141,7 @@ CREATE TABLE IF NOT EXISTS `system_mail_info` (
) ENGINE = InnoDB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4 COMMENT = '系统邮件'; ) 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 ( CREATE TABLE IF NOT EXISTS t_server_mod (
`id` int NOT NULL AUTO_INCREMENT primary key, `id` int NOT NULL AUTO_INCREMENT primary key,
@ -149,3 +149,21 @@ CREATE TABLE IF NOT EXISTS t_server_mod (
`mData` mediumblob DEFAULT NULL COMMENT '数据', `mData` mediumblob DEFAULT NULL COMMENT '数据',
`updateTime` int unsigned NOT NULL DEFAULT '0' 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() p1.InitOrderItem()
fmt.Printf("%v\n", EM) 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", "LogLevel": "debug",
"LogPath": "./log", "LogPath": "./log",
"TCPAddr": ":3601", "TCPAddr": ":3601",
"RPCAddr": ":50051",
"WSAddr": ":3566", "WSAddr": ":3566",
"MySqlAddr": "127.0.0.1", "MySqlAddr": "127.0.0.1",
"MySqlPort": "3306", "MySqlPort": "3306",

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

@ -2,7 +2,9 @@ package test
import ( import (
"fmt" "fmt"
friendTreasureCfg "server/conf/friend_treasure"
"server/game" "server/game"
GoUtil "server/game_util"
"server/msg" "server/msg"
"testing" "testing"
@ -54,3 +56,10 @@ func TestFriendBackData(t *testing.T) {
p1.FriendLogBackData() p1.FriendLogBackData()
p1.FriendCardBackData() 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 ( import (
"fmt" "fmt"
limitedTimeEventCfg "server/conf/limited_time_event"
"server/game" "server/game"
"server/game/mod/item"
limitedTimeEvent "server/game/mod/limited_time_event" limitedTimeEvent "server/game/mod/limited_time_event"
"testing" "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) { func TestFast(t *testing.T) {
p := new(game.Player) p := new(game.Player)
p.InitPlayer("3625212") p.InitPlayer("3625212")
@ -54,3 +46,18 @@ func TestProgressReward(t *testing.T) {
fmt.Printf("Current progress reward list: %v\n", res) 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) { func TestInitOrderItem(t *testing.T) {
p1 := new(game.Player) p1 := new(game.Player)
p1.InitPlayer("3625212") p1.InitPlayer("3625212")
@ -66,3 +57,50 @@ func TestHighOrder(t *testing.T) {
p1.InitOrderItem() p1.InitOrderItem()
fmt.Printf("order item:%v", OrderMod.OrderList[1].Items) 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())
}
}