1048 lines
38 KiB
Go
1048 lines
38 KiB
Go
package game
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"reflect"
|
|
"server/MergeConst"
|
|
"server/conf"
|
|
userCfg "server/conf/user"
|
|
GoUtil "server/game_util"
|
|
"strconv"
|
|
"sync"
|
|
|
|
l "log"
|
|
"server/db"
|
|
"server/game/internal"
|
|
|
|
MsgMod "server/game/mod/msg"
|
|
"server/msg"
|
|
"time"
|
|
|
|
"github.com/robfig/cron/v3"
|
|
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
"gitea.bywaystudios.com/pet_home/leaf/gate"
|
|
"gitea.bywaystudios.com/pet_home/leaf/timer"
|
|
|
|
"gitea.bywaystudios.com/pet_home/leaf/log"
|
|
)
|
|
|
|
var (
|
|
G_GameLogicPtr *GameLogic
|
|
)
|
|
|
|
var isInitGameLogic = false
|
|
var RegisterNetWorkFunc = make(map[string]interface{})
|
|
var NewRegisterNetWorkFunc = make(map[string]func(*Player, *proto.Message) error)
|
|
|
|
const (
|
|
SERVER_STATUS_OPEN = 1 // 服务器状态 开放
|
|
SERVER_STATUS_CLOSE = 2 // 服务器状态 关闭
|
|
SERVER_STATUS_MAINTAIN = 3 // 服务器状态 维护
|
|
SERVER_STATUS_FULL = 4 // 服务器状态 爆满
|
|
)
|
|
|
|
func RegisterMsgProcessFunc(key string, value1 interface{}) {
|
|
RegisterNetWorkFunc[key] = value1
|
|
}
|
|
|
|
func RegisterNewMsgProcessFunc(key string, value interface{}) {
|
|
handler, err := buildNewMsgHandlerAdapter(value)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("RegisterNewMsgProcessFunc[%s] invalid handler: %v", key, err))
|
|
}
|
|
NewRegisterNetWorkFunc[key] = handler
|
|
}
|
|
|
|
func buildNewMsgHandlerAdapter(value interface{}) (func(*Player, *proto.Message) error, error) {
|
|
if fn, ok := value.(func(*Player, *proto.Message) error); ok {
|
|
return fn, nil
|
|
}
|
|
|
|
if value == nil {
|
|
return nil, fmt.Errorf("handler is nil")
|
|
}
|
|
|
|
rv := reflect.ValueOf(value)
|
|
rt := rv.Type()
|
|
if rt.Kind() != reflect.Func {
|
|
return nil, fmt.Errorf("handler must be function, got %s", rt.Kind())
|
|
}
|
|
if rt.NumIn() != 2 || rt.NumOut() != 1 {
|
|
return nil, fmt.Errorf("handler signature must be func(*Player, *T) error")
|
|
}
|
|
if rt.In(0) != reflect.TypeOf(&Player{}) {
|
|
return nil, fmt.Errorf("first arg must be *Player")
|
|
}
|
|
errorType := reflect.TypeOf((*error)(nil)).Elem()
|
|
if !rt.Out(0).Implements(errorType) {
|
|
return nil, fmt.Errorf("return type must be error")
|
|
}
|
|
|
|
msgIfaceType := reflect.TypeOf((*proto.Message)(nil)).Elem()
|
|
msgArgType := rt.In(1)
|
|
if msgArgType == reflect.TypeOf((*proto.Message)(nil)) {
|
|
return func(player *Player, msg *proto.Message) error {
|
|
results := rv.Call([]reflect.Value{reflect.ValueOf(player), reflect.ValueOf(msg)})
|
|
if results[0].IsNil() {
|
|
return nil
|
|
}
|
|
return results[0].Interface().(error)
|
|
}, nil
|
|
}
|
|
if msgArgType.Kind() != reflect.Ptr || !msgArgType.Implements(msgIfaceType) {
|
|
return nil, fmt.Errorf("second arg must be *proto.Message or pointer type implementing proto.Message")
|
|
}
|
|
|
|
return func(player *Player, msg *proto.Message) error {
|
|
if msg == nil || *msg == nil {
|
|
return fmt.Errorf("nil proto message")
|
|
}
|
|
|
|
raw := *msg
|
|
rawType := reflect.TypeOf(raw)
|
|
if !rawType.AssignableTo(msgArgType) {
|
|
return fmt.Errorf("message type mismatch, expect %s got %s", msgArgType, rawType)
|
|
}
|
|
|
|
results := rv.Call([]reflect.Value{reflect.ValueOf(player), reflect.ValueOf(raw)})
|
|
if results[0].IsNil() {
|
|
return nil
|
|
}
|
|
return results[0].Interface().(error)
|
|
}, nil
|
|
}
|
|
|
|
func RunNewNetProcessByKey(key string, player *Player, msg *proto.Message) error {
|
|
fun, ok := NewRegisterNetWorkFunc[key]
|
|
if ok {
|
|
err := fun(player, msg)
|
|
return err
|
|
}
|
|
return fmt.Errorf("cant find network func %s", key)
|
|
}
|
|
|
|
func RunNetProcessByKey(key string, param []interface{}) error {
|
|
fun, ok := RegisterNetWorkFunc[key]
|
|
if ok {
|
|
_, player, buf := ParseArgs(param)
|
|
err := fun.(func(*Player, []byte) error)(player, buf)
|
|
return err
|
|
}
|
|
return fmt.Errorf("cant find network func %s", key)
|
|
}
|
|
|
|
type LimitActPeriod struct {
|
|
StartCronID cron.EntryID
|
|
EndTimer *timer.Timer
|
|
StartTime int32
|
|
EndTime int32
|
|
}
|
|
|
|
type GameLogic struct {
|
|
Db_AccountInfo db.Db_Account
|
|
DailyTaskTimestamp int64
|
|
M_Players sync.Map
|
|
m_CronEntryIDs map[int]*LimitActPeriod
|
|
Mdispatr *timer.Dispatcher
|
|
M_LimitActiveList []int
|
|
NotInitPlayer *Player
|
|
Version int32
|
|
M_SvrGlobal db.SqlSvrGlobalStruct
|
|
SeverInfo *ServerInfo
|
|
|
|
FriendMgr *FriendMgr // 好友管理器
|
|
RankMgr *RankMgr // 排行榜管理器
|
|
MailMgr *MailMgr // 邮件管理器
|
|
ChampshipMgr *ChampshipMgr // 锦标赛管理器
|
|
VarMgr *VarMgr // 变量管理器
|
|
StartTime int64 // 服务器启动时间
|
|
MessageMgr *MessageMgr // 消息管理器
|
|
ActivityMgr *ActivityMgr // 活动管理器
|
|
}
|
|
|
|
type ServerInfo struct {
|
|
ServerID int // 服务器ID
|
|
CenterID int // 中心ID
|
|
GroupID int // 组ID
|
|
OpenTime int64 // 开服时间
|
|
Name string // 服务器名字
|
|
Status int // 服务器状态
|
|
}
|
|
|
|
// 零点更新
|
|
func (gl *GameLogic) ZeroFlush() {
|
|
gl.Mdispatr.AfterFunc(time.Second*86400, func() {
|
|
gl.ZeroFlush()
|
|
})
|
|
var a1 = []interface{}{gl.DailyTaskTimestamp}
|
|
GoUtil.CallEvent(MergeConst.Notify_Daily_Renew, a1)
|
|
gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
|
|
gl.CreateDailyLogFile()
|
|
log.Debug("Server ZeroFlush")
|
|
}
|
|
|
|
// 中午更新
|
|
func (gl *GameLogic) NoonFlush() {
|
|
log.Debug("Server NoonFlush")
|
|
gl.Mdispatr.AfterFunc(time.Second*86400, func() {
|
|
gl.NoonFlush()
|
|
})
|
|
gl.NotifyAll(MsgMod.MSG_NOON_UPDATE)
|
|
}
|
|
|
|
func (gl *GameLogic) SetPlayer(player *Player) {
|
|
gl.M_Players.Store(player.M_DwUin, player)
|
|
}
|
|
|
|
func (gl *GameLogic) DelPlayer(player *Player) {
|
|
gl.M_Players.Delete(player.M_DwUin)
|
|
}
|
|
|
|
func (gl *GameLogic) GetPlayer(DwUin int64) *Player {
|
|
if v, ok := gl.M_Players.Load(DwUin); ok {
|
|
return v.(*Player)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (gl *GameLogic) OpenTimestampTick() {
|
|
gl.DailyTaskTimestamp = 0
|
|
gl.Mdispatr = timer.NewDispatcher(0)
|
|
gl.Mdispatr.AfterFunc(time.Second*time.Duration(GoUtil.NextZeroTimestampDuration()), func() {
|
|
gl.ZeroFlush()
|
|
})
|
|
gl.Mdispatr.AfterFunc(time.Second*time.Duration(GoUtil.NextNoonTimestampDuration()), func() {
|
|
gl.NoonFlush()
|
|
})
|
|
//gl.CreateDailyLogFile()
|
|
go func() {
|
|
for k := range gl.Mdispatr.ChanTimer {
|
|
k.Cb()
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (ad *GameLogic) IsExsitAccount(UserName string) bool {
|
|
return ad.LoadDataFromDB(UserName)
|
|
}
|
|
|
|
func (ad *GameLogic) LoadDataFromDB(UserName string) bool {
|
|
sqlStr := "SELECT * FROM t_account WHERE user_name = ?"
|
|
if err := db.SqlDb.Get(&ad.Db_AccountInfo, sqlStr, UserName); err != nil {
|
|
// log.Debug("get data failed, err:%v\n", err)
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (ad *GameLogic) NewAccountInsertDataToDB() bool {
|
|
sqlStr := "INSERT INTO t_account(user_name, user_password) VALUES(:user_name, :user_password)"
|
|
result, err := db.SqlDb.NamedExec(sqlStr, map[string]interface{}{
|
|
"user_name": ad.Db_AccountInfo.UserName,
|
|
"user_password": ad.Db_AccountInfo.UserPassword,
|
|
})
|
|
if err != nil {
|
|
log.Debug("named exec failed, err:%v\n", err)
|
|
return false
|
|
}
|
|
insertId, err := result.LastInsertId()
|
|
if err != nil {
|
|
log.Debug("get last insert id failed, err:%v\n", err)
|
|
return false
|
|
}
|
|
|
|
insertId = insertId + int64(100000) + int64(conf.Server.AppID*100000000)
|
|
playerInfo := &db.ResPlayerBaseInfo{}
|
|
playerInfo.DwUin = int64(insertId)
|
|
playerInfo.Energy = int32(userCfg.GetInitEnergy())
|
|
playerInfo.Star = int32(userCfg.GetInitStar())
|
|
playerInfo.RecoverTime = int32(time.Now().Unix())
|
|
playerInfo.Diamond = int32(userCfg.GetInitDiamond())
|
|
playerInfo.Level = 1
|
|
playerInfo.Exp = 0
|
|
playerInfo.StartOrderId = "1"
|
|
playerInfo.MusicCode = 1
|
|
playerInfo.Guild = 1
|
|
playerInfo.PackUnlockCount = 5
|
|
playerInfo.UserName = ad.Db_AccountInfo.UserName
|
|
playerInfo.LoginTime = (int32)(time.Now().Unix())
|
|
playerInfo.LogoutTime = 0
|
|
playerInfo.Node = int32(conf.Server.ServerID)
|
|
playerInfo.Rolecreatetime = (int32)(time.Now().Unix())
|
|
playerInfo.FaceBookId = ""
|
|
db.FormatAllMemInsertDb(playerInfo, "t_player_baseinfo")
|
|
|
|
var buf bytes.Buffer
|
|
encode := gob.NewEncoder(&buf)
|
|
encode.Encode(&PlayerModList{})
|
|
playerMod := &db.SqlModStruct{
|
|
DwUin: int64(insertId),
|
|
ModData: buf.Bytes(),
|
|
UpdataTime: int32(time.Now().Unix()),
|
|
}
|
|
db.FormatAllMemInsertDb(playerMod, "t_player_mod")
|
|
// 创建玩家日志
|
|
player := new(Player)
|
|
BaseMod := player.PlayMod.getBaseMod()
|
|
BaseMod.Account = ad.Db_AccountInfo.UserName
|
|
BaseMod.RegisterTime = time.Now().Unix()
|
|
player.TeLog("register", nil)
|
|
|
|
return true
|
|
}
|
|
|
|
func (ad *GameLogic) PackLoginResInfo(a gate.Agent, ResLogin *msg.ResLogin) {
|
|
resBuff, _ := proto.Marshal(ResLogin)
|
|
ad.PackResInfo(a, "ResLogin", resBuff)
|
|
}
|
|
|
|
func (ad *GameLogic) PackResInfo(a gate.Agent, Func string, data []byte) {
|
|
if a == nil {
|
|
return
|
|
}
|
|
response := &msg.ClientRes{}
|
|
response.Func = Func
|
|
response.Cid = "cid"
|
|
response.Info = data
|
|
a.WriteMsg(response)
|
|
}
|
|
|
|
// 创建新玩家，初始化数据
|
|
func (ad *GameLogic) CreateNewPlayer(a gate.Agent, UserName string) *Player {
|
|
player := new(Player)
|
|
internal.AsignPlayerToAgents(a, player) //绑定player和网络连接代理
|
|
player.agent = a
|
|
err := player.InitPlayer(UserName)
|
|
if err != nil {
|
|
data, _ := proto.Marshal(&msg.ResLogin{ResultCode: MergeConst.Protocol_Error_Account_Fail})
|
|
G_GameLogicPtr.PackResInfo(a, "ResLogin", data)
|
|
panic(err)
|
|
}
|
|
ad.SetPlayer(player)
|
|
return player
|
|
}
|
|
|
|
func (ad *GameLogic) GetPlayerByAgent(gate gate.Agent) *Player {
|
|
p, ok := internal.Agents.Load(gate)
|
|
if ok {
|
|
return p.(*Player)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 好友管理器
|
|
func (ad *GameLogic) CreateFriendMgr() {
|
|
ad.FriendMgr = &FriendMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.FriendMgr.Init()
|
|
}
|
|
|
|
// 排行榜管理器
|
|
func (ad *GameLogic) CreateRankMgr() {
|
|
ad.RankMgr = &RankMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.RankMgr.Init()
|
|
}
|
|
|
|
func (ad *GameLogic) RankMgrSend(m *MsgMod.Msg) {
|
|
ad.RankMgr.Send(m)
|
|
}
|
|
|
|
func (ad *GameLogic) RankMgrCall(m *MsgMod.Msg) interface{} {
|
|
result, err := ad.RankMgr.Call(m)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
// 邮件管理器
|
|
func (ad *GameLogic) CreateMailMgr() {
|
|
ad.MailMgr = &MailMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.MailMgr.Init()
|
|
}
|
|
|
|
// 活动管理器
|
|
func (ad *GameLogic) CreateActivityMgr() {
|
|
ad.ActivityMgr = &ActivityMgr{}
|
|
ad.ActivityMgr.Init()
|
|
}
|
|
|
|
func (ad *GameLogic) CreateMessageMgr() {
|
|
ad.MessageMgr = &MessageMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.MessageMgr.MessageMgrInit()
|
|
}
|
|
|
|
func (ad *GameLogic) MailMgrSend(m *MsgMod.Msg) {
|
|
ad.MailMgr.Send(m)
|
|
}
|
|
|
|
func (ad *GameLogic) MailMgrCall(m *MsgMod.Msg) interface{} {
|
|
result, err := ad.MailMgr.Call(m)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
// 锦标赛管理器
|
|
func (ad *GameLogic) CreateChampshipMgr() {
|
|
ad.ChampshipMgr = &ChampshipMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.ChampshipMgr.Init()
|
|
}
|
|
|
|
func (ad *GameLogic) ChampshipMgrSend(m *MsgMod.Msg) {
|
|
ad.ChampshipMgr.Send(m)
|
|
}
|
|
|
|
func (ad *GameLogic) ChampshipMgrCall(m *MsgMod.Msg) interface{} {
|
|
result, err := ad.ChampshipMgr.Call(m)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
// 变量管理器
|
|
func (ad *GameLogic) CreateVarMgr() {
|
|
ad.VarMgr = &VarMgr{
|
|
ServerMod: new(ServerMod),
|
|
}
|
|
ad.VarMgr.Init()
|
|
}
|
|
|
|
func (ad *GameLogic) VarMgrSend(m *MsgMod.Msg) {
|
|
ad.VarMgr.Send(m)
|
|
}
|
|
|
|
func (ad *GameLogic) VarMgrCall(m *MsgMod.Msg) interface{} {
|
|
result, err := ad.VarMgr.Call(m)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (ad *GameLogic) GetSimplePlayerByUid(Id int) *PlayerSimpleData {
|
|
if Id == 0 {
|
|
return nil
|
|
}
|
|
Idstr := strconv.Itoa(Id)
|
|
Value, _ := db.RedisGetKey(Idstr)
|
|
player := &PlayerSimpleData{}
|
|
player.Playroom = make(map[int]int)
|
|
player.Uid = Id
|
|
if Value == "" {
|
|
p := new(Player)
|
|
err := p.GetSimpleData(Id, player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
value, _ := json.Marshal(player)
|
|
db.RedisSetKey(Idstr, string(value), time.Duration(300)*time.Second)
|
|
} else {
|
|
err := json.Unmarshal([]byte(Value), player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
}
|
|
return player
|
|
}
|
|
|
|
func (ad *GameLogic) GetResSimplePlayerByUid(Id int) *msg.ResPlayerSimple {
|
|
Idstr := strconv.Itoa(Id)
|
|
Value, _ := db.RedisGetKey(Idstr)
|
|
player := &PlayerSimpleData{}
|
|
player.Uid = Id
|
|
if Value == "" {
|
|
p := new(Player)
|
|
err := p.GetSimpleData(Id, player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
value, _ := json.Marshal(player)
|
|
db.RedisSetKey(Idstr, string(value), 0)
|
|
} else {
|
|
err := json.Unmarshal([]byte(Value), player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
return &msg.ResPlayerSimple{
|
|
Uid: int64(player.Uid),
|
|
Name: player.Name,
|
|
Level: int32(player.Level),
|
|
Avatar: int32(player.Avatar),
|
|
Face: int32(player.Face),
|
|
Decorate: int32(player.Decorate),
|
|
Login: int32(player.Login),
|
|
Loginout: int32(player.Loginout),
|
|
Emoji: GoUtil.MapIntToInt32(player.Emoji),
|
|
}
|
|
}
|
|
|
|
func (ad *GameLogic) GetResFriendPlayerByUid(Id int) *msg.ResFriendPlayerSimple {
|
|
Idstr := strconv.Itoa(Id)
|
|
Value, _ := db.RedisGetKey(Idstr)
|
|
player := &PlayerSimpleData{}
|
|
player.Uid = Id
|
|
if Value == "" {
|
|
p := new(Player)
|
|
err := p.GetSimpleData(Id, player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
value, _ := json.Marshal(player)
|
|
db.RedisSetKey(Idstr, string(value), 0)
|
|
} else {
|
|
err := json.Unmarshal([]byte(Value), player)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
}
|
|
last := &msg.ActLog{}
|
|
if player.ActLog != nil {
|
|
last = &msg.ActLog{
|
|
Type: int32(player.ActLog.Type),
|
|
Time: player.ActLog.Time,
|
|
Param: player.ActLog.Param,
|
|
}
|
|
}
|
|
return &msg.ResFriendPlayerSimple{
|
|
Uid: int64(player.Uid),
|
|
Name: player.Name,
|
|
Level: int32(player.Level),
|
|
Avatar: int32(player.Avatar),
|
|
Face: int32(player.Face),
|
|
Decorate: int32(player.Decorate),
|
|
Login: int32(player.Login),
|
|
Loginout: int32(player.Loginout),
|
|
Emoji: GoUtil.MapIntToInt32(player.Emoji),
|
|
Facebook: player.FaceBook,
|
|
Playroom: GoUtil.MapIntToInt32(player.Playroom),
|
|
DressSet: GoUtil.MapIntToInt32(player.DressSet),
|
|
Friend: GoUtil.IntToInt32(player.Friend),
|
|
Physiology: GoUtil.MapIntToInt32(player.Physiology),
|
|
Last: last,
|
|
PetName: player.PetName,
|
|
PetFur: int32(player.PetFur),
|
|
}
|
|
}
|
|
|
|
// 初始化服务器协程
|
|
func G_getGameLogic() *GameLogic {
|
|
if !isInitGameLogic {
|
|
G_GameLogicPtr = new(GameLogic)
|
|
isInitGameLogic = true
|
|
G_GameLogicPtr.Mdispatr = timer.NewDispatcher(10)
|
|
G_GameLogicPtr.InitServerInfo()
|
|
G_GameLogicPtr.M_Players = sync.Map{}
|
|
G_GameLogicPtr.NotInitPlayer = new(Player)
|
|
G_GameLogicPtr.M_LimitActiveList = []int{}
|
|
G_GameLogicPtr.CreateMessageMgr() // 创建消息管理器
|
|
G_GameLogicPtr.OpenTimestampTick() // 开启时间戳计时器
|
|
G_GameLogicPtr.RegisterEvent() // 注册事件
|
|
G_GameLogicPtr.RegisterNetWorkFunc() // 注册客户端接口
|
|
G_GameLogicPtr.InitActivity() // 初始化活动
|
|
if conf.Server.ServerType == "center" {
|
|
// G_GameLogicPtr.CreateFriendMgr() //创建好友管理器
|
|
G_GameLogicPtr.CreateChampshipMgr() // 创建竞标赛管理器
|
|
G_GameLogicPtr.CreateVarMgr() // 创建变量管理器
|
|
} else {
|
|
G_GameLogicPtr.CreateActivityMgr() //创建活动管理器
|
|
}
|
|
G_GameLogicPtr.CreateRankMgr() //创建排行榜管理器
|
|
G_GameLogicPtr.CreateMailMgr() //创建邮件管理器
|
|
ClusterMgrInit() //初始化集群
|
|
G_GameLogicPtr.StartTime = time.Now().Unix()
|
|
// G_GameLogicPtr.CreateHttpManager()
|
|
}
|
|
return G_GameLogicPtr
|
|
}
|
|
|
|
func (ad *GameLogic) InitServerInfo() {
|
|
Now := time.Now().Unix()
|
|
ServerInfo := &ServerInfo{}
|
|
ServerInfo.ServerID = conf.Server.ServerID
|
|
ServerInfo.OpenTime = GoUtil.ParseTime(conf.Server.ServerOpenTime)
|
|
ServerInfo.Name = conf.Server.ServerName
|
|
if Now < ServerInfo.OpenTime {
|
|
ServerInfo.Status = SERVER_STATUS_CLOSE
|
|
} else {
|
|
ServerInfo.Status = SERVER_STATUS_OPEN
|
|
}
|
|
ad.SeverInfo = ServerInfo
|
|
}
|
|
|
|
func (ad *GameLogic) SendServerVersion(a gate.Agent) {
|
|
res := &msg.ResServerVersion{}
|
|
res.Version = G_GameLogicPtr.Version
|
|
data, _ := proto.Marshal(res)
|
|
G_getGameLogic().PackResInfo(a, "ResServerVersion", data)
|
|
}
|
|
|
|
func (ad *GameLogic) ClearData(args []interface{}) {
|
|
player := args[0].(*Player)
|
|
if player != nil && player.M_DwUin != 0 {
|
|
player.agent = nil
|
|
player.AutoSaveData()
|
|
log.Debug("player %d 断开连接", player.M_DwUin)
|
|
player.CallEvent(120*time.Second, func() {
|
|
player.lock.Lock()
|
|
defer player.lock.Unlock()
|
|
if player.agent == nil {
|
|
player.ClearData()
|
|
log.Debug("player %d 延迟120s关闭", player.M_DwUin)
|
|
}
|
|
}, "LateClose")
|
|
}
|
|
}
|
|
|
|
func (ad *GameLogic) RegisterEvent() {
|
|
|
|
GoUtil.RegisterEvent(MergeConst.Notify_Socket_Closed, ad.ClearData, nil)
|
|
GoUtil.RegisterEvent(MergeConst.Notify_Socket_Connect, ad.NewPlayerConnect, nil)
|
|
}
|
|
|
|
func (ad *GameLogic) NewPlayerConnect(args []interface{}) {
|
|
a := args[0].(gate.Agent)
|
|
internal.AsignPlayerToAgents(a, ad.NotInitPlayer)
|
|
}
|
|
|
|
func (ad *GameLogic) ReplaceExistPlayerAndAgent(a gate.Agent, player *Player) error {
|
|
if player == nil {
|
|
return fmt.Errorf("player is nil")
|
|
}
|
|
player.lock.Lock()
|
|
defer player.lock.Unlock()
|
|
storePlayer := ad.GetPlayer(player.M_DwUin)
|
|
if storePlayer == nil {
|
|
return fmt.Errorf("player is delete")
|
|
}
|
|
if player.stop {
|
|
return fmt.Errorf("player is stop")
|
|
}
|
|
agent := player.GetAgentByPlayer()
|
|
notify := &msg.ForceKickOut{}
|
|
data, _ := proto.Marshal(notify)
|
|
if agent != nil && a != agent {
|
|
G_getGameLogic().PackResInfo(agent, "ForceKickOut", data)
|
|
internal.AsignPlayerToAgents(agent, ad.NotInitPlayer)
|
|
}
|
|
internal.AsignPlayerToAgents(a, player)
|
|
player.SetAgent(a)
|
|
// 取消延迟关闭
|
|
Timer, ok := player.timerList["LateClose"]
|
|
if ok {
|
|
Timer.Stop()
|
|
}
|
|
log.Debug("player %d 重连", player.M_DwUin)
|
|
return nil
|
|
}
|
|
|
|
func (ad *GameLogic) SendMassage(dwUin int64, Func string, data []byte) bool {
|
|
player := ad.GetPlayer(dwUin)
|
|
if player != nil {
|
|
agent := player.GetAgentByPlayer()
|
|
if agent != nil {
|
|
G_getGameLogic().PackResInfo(agent, Func, data)
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ad *GameLogic) FileExist(path string) bool {
|
|
_, err := os.Lstat(path)
|
|
return !os.IsNotExist(err)
|
|
}
|
|
|
|
func (ad *GameLogic) CreateDailyLogFile() {
|
|
zero := GoUtil.ZeroTimestamp()
|
|
now := time.Unix(zero, 0).Local()
|
|
err := log.NewDailyLog(now, log.DEBUG_LEVEL, conf.Server.LogPath, l.LstdFlags)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
log.Debug("CreateDailyLogFile")
|
|
ad.RemoveOldLogs(MergeConst.Go_log_delete_days)
|
|
}
|
|
|
|
func (ad *GameLogic) RemoveOldLogs(days int) {
|
|
dir := conf.Server.LogPath
|
|
files, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
log.Debug("Failed to read log directory: %v", err)
|
|
return
|
|
}
|
|
|
|
cutoff := time.Now().AddDate(0, 0, -days)
|
|
for _, file := range files {
|
|
if file.IsDir() {
|
|
continue
|
|
}
|
|
fileInfo, err := file.Info()
|
|
if err != nil {
|
|
log.Debug("Failed to get file info: %v", err)
|
|
continue
|
|
}
|
|
if fileInfo.ModTime().Before(cutoff) {
|
|
err := os.Remove(dir + "/" + file.Name())
|
|
if err != nil {
|
|
log.Debug("Failed to remove old log file: %v", err)
|
|
} else {
|
|
log.Debug("Removed old log file: %s", file.Name())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ad *GameLogic) RegisterNetWorkFunc() {
|
|
|
|
RegisterNewMsgProcessFunc("ReqRemoveAd", ReqRemoveAd)
|
|
RegisterNewMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileData)
|
|
RegisterNewMsgProcessFunc("ReqFriendPlayerSimple", ReqFriendPlayerSimple)
|
|
// RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)
|
|
RegisterNewMsgProcessFunc("ReqPlayerAsset", ReqPlayerAsset)
|
|
RegisterNewMsgProcessFunc("ReqId2Verify", ReqId2Verify) // 身份证验证
|
|
// 玩家
|
|
RegisterNewMsgProcessFunc("ReqUserInfo", ReqUserInfo)
|
|
RegisterNewMsgProcessFunc("ReqSetName", ReqSetName) // 设置名字
|
|
RegisterNewMsgProcessFunc("ReqLang", ReqLang) // 设置语言
|
|
RegisterNewMsgProcessFunc("ReqSetPetName", ReqSetPetName) // 设置宠物名字
|
|
RegisterNewMsgProcessFunc("ReqSetFacebookUrl", ReqSetFacebookUrl) // 设置facebook地址
|
|
RegisterNewMsgProcessFunc("ReqPlayerBaseInfo", ReqPlayerBaseInfofunction) // 请求玩家基本信息
|
|
RegisterNewMsgProcessFunc("ReqKv", ReqKv) // 保存客户端数据
|
|
RegisterNewMsgProcessFunc("ReqGetEnergyByAD", ReqGetEnergyByAD) // 看广告获取能量
|
|
RegisterNewMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy) // 购买能量
|
|
RegisterNewMsgProcessFunc("ReqAdWatch", ReqAdWatch) // 观看广告
|
|
// #region 棋盘
|
|
RegisterNewMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessData)
|
|
RegisterNewMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessData) // 更新棋盘数据
|
|
RegisterNewMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc) //设置能量倍数
|
|
RegisterNewMsgProcessFunc("ReqChessEx", ReqChessEx) // 转换棋子
|
|
RegisterNewMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff) // 从buff中获取棋子
|
|
RegisterNewMsgProcessFunc("ReqPutPartInBag", ReqPutPartInBag) // 把零件放入背包
|
|
RegisterNewMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag) // 把棋子放入背包
|
|
RegisterNewMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag) // 从背包中取出棋子
|
|
RegisterNewMsgProcessFunc("ReqTakeChessOutBagToHonor", ReqTakeChessOutBagToHonor) // 从背包中取出棋子
|
|
RegisterNewMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid) // 解锁背包格子
|
|
RegisterNewMsgProcessFunc("ReqSourceChest", ReqSourceChest) // 开宝箱
|
|
RegisterNewMsgProcessFunc("ReqSeparateChess", ReqSeparateChess) // 分解棋子
|
|
RegisterNewMsgProcessFunc("ReqUpgradeChess", ReqUpgradeChess) // 升级棋子
|
|
RegisterNewMsgProcessFunc("ReqSellChessNum", ReqSellChessNum) //购买能量
|
|
RegisterNewMsgProcessFunc("ReqGetChessRetireReward", ReqGetChessRetireReward) //领取棋子退役奖励
|
|
|
|
//领取图鉴奖励
|
|
RegisterNewMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励
|
|
RegisterNewMsgProcessFunc("RegHandbookAllReward", RegHandbookAllReward) //领取图鉴收集奖励
|
|
//领取订单奖励
|
|
RegisterNewMsgProcessFunc("ReqRewardOrder", ReqRewardOrder) // 领取订单奖励
|
|
RegisterNewMsgProcessFunc("ReqDelOrder", ReqDelOrder) // 删除订单
|
|
RegisterNewMsgProcessFunc("ReqCreatePetOrder", ReqCreatePetOrder) // 生成消耗品订单
|
|
|
|
//装饰
|
|
RegisterNewMsgProcessFunc("ReqDecorate", ReqDecorate) // 装饰
|
|
RegisterNewMsgProcessFunc("ReqDecorateAll", ReqDecorateAll) // 装饰全部
|
|
RegisterNewMsgProcessFunc("ReqAreaReward", ReqAreaReward) // 章节奖励
|
|
//Gm命令
|
|
RegisterNewMsgProcessFunc("ReqGmCommand", ReqGmCommand) // Gm命令
|
|
|
|
// #region 卡牌
|
|
RegisterNewMsgProcessFunc("ReqCardInfo", ReqCardInfo) // 请求卡牌信息
|
|
RegisterNewMsgProcessFunc("ReqCardSeasonFirstReward", ReqCardSeasonFirstReward) // 领取赛季首次奖励
|
|
RegisterNewMsgProcessFunc("ReqCardCollectReward", ReqCardCollectReward) //领取卡牌系列收集奖励
|
|
RegisterNewMsgProcessFunc("ReqExStarReward", ReqExStarReward) // 兑换收集星星奖励
|
|
RegisterNewMsgProcessFunc("ReqAllCollectReward", ReqAllCollectReward) // 领取全收集奖励
|
|
RegisterNewMsgProcessFunc("ReqCardGive", ReqCardGive) // 请求赠送卡牌
|
|
RegisterNewMsgProcessFunc("ReqAgreeCardGive", ReqAgreeCardGive) // 同意赠送卡牌
|
|
RegisterNewMsgProcessFunc("ReqRefuseCardGive", ReqRefuseCardGive) // 拒绝赠送卡牌
|
|
|
|
RegisterNewMsgProcessFunc("ReqCardExchange", ReqCardExchange) // 请求交换卡牌
|
|
RegisterNewMsgProcessFunc("ReqSelectCardExchange", ReqSelectCardExchange) // 选择交换的卡牌
|
|
RegisterNewMsgProcessFunc("ReqAgreeCardExchange", ReqAgreeCardExchange) // 完成交换卡牌
|
|
RegisterNewMsgProcessFunc("ReqRefuseCardSelect", ReqRefuseCardSelect) // 拒绝选择卡牌进行交换
|
|
RegisterNewMsgProcessFunc("ReqRefuseCardExchange", ReqRefuseCardExchange) // 拒绝卡牌交换
|
|
RegisterNewMsgProcessFunc("ReqCardSend", ReqCardSend) // 直接赠送卡牌
|
|
RegisterNewMsgProcessFunc("ReqGetFriendCard", ReqGetFriendCard) // 领取好友赠送的卡牌
|
|
RegisterNewMsgProcessFunc("ReqMasterCard", ReqMasterCard) // 万能卡兑换
|
|
RegisterNewMsgProcessFunc("ReqCardHandbookReward", ReqCardHandbookReward) // 卡牌图鉴
|
|
|
|
// 日常任务
|
|
RegisterNewMsgProcessFunc("ReqGetDailyTaskReward", ReqGetDailyTaskReward) // 领取日常任务奖励
|
|
RegisterNewMsgProcessFunc("ReqGetDailyWeekReward", ReqGetDailyWeekReward) // 领取周活跃奖励
|
|
RegisterNewMsgProcessFunc("ReqDailyUnlock", ReqDailyUnlock) // 日常任务解锁
|
|
// 新手任务
|
|
RegisterNewMsgProcessFunc("ReqGetGuideTaskReward", ReqGetGuideTaskReward) // 领取日新手任务奖励
|
|
RegisterNewMsgProcessFunc("ReqGetGuideActiveReward", ReqGetGuideActiveReward) // 领取活跃奖励
|
|
|
|
// 引导奖励
|
|
RegisterNewMsgProcessFunc("ReqGuideReward", ReqGuideReward) // 领取引导奖励
|
|
RegisterNewMsgProcessFunc("ReqGuidePlayroom", ReqGuidePlayroom) // 领取playroom引导奖励
|
|
|
|
// 头像
|
|
RegisterNewMsgProcessFunc("ReqSetFace", ReqSetFace) // 设置头像
|
|
// 头像框
|
|
RegisterNewMsgProcessFunc("ReqSetAvatar", ReqSetAvatar) // 设置头像框
|
|
// 表情
|
|
RegisterNewMsgProcessFunc("ReqSetEmoji", ReqSetEmoji) // 设置表情
|
|
// 收藏室
|
|
RegisterNewMsgProcessFunc("ReqCollectInfo", ReqCollectInfo) // 请求收藏室数据
|
|
RegisterNewMsgProcessFunc("ReqCollect", ReqCollect) // 领取收藏室奖励
|
|
// 七日签到
|
|
RegisterNewMsgProcessFunc("ReqGetSevenLoginReward", ReqGetSevenLoginReward) // 领取七日签到奖励
|
|
RegisterNewMsgProcessFunc("ReqGetMonthLoginReward", ReqGetMonthLoginReward) // 领取月签到奖励
|
|
|
|
// 限时事件
|
|
RegisterNewMsgProcessFunc("ReqLimitEvent", ReqLimitEvent) // 请求限时事件数据
|
|
RegisterNewMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward) // 连击快手奖励
|
|
RegisterNewMsgProcessFunc("ReqFastProduceInfo", ReqFastProduceInfo) // 请求连击快手数据
|
|
RegisterNewMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward) // 获取场景转盘奖励
|
|
RegisterNewMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent) //领取Bouns限时事件进度奖励
|
|
RegisterNewMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard) //请求金卡交换信息
|
|
RegisterNewMsgProcessFunc("ReqLimitEventLuckyCat", ReqLimitEventLuckyCat) //幸运猫获取奖励
|
|
RegisterNewMsgProcessFunc("ReqCatTrickReward", ReqCatTrickReward) //小猫戏法获取奖励
|
|
|
|
// #region 好友
|
|
RegisterNewMsgProcessFunc("ReqFriendList", ReqFriendList) // 请求好友列表
|
|
RegisterNewMsgProcessFunc("ReqFriendApply", ReqFriendApply) // 请求申请好友列表
|
|
RegisterNewMsgProcessFunc("ReqFriendCardMsg", ReqFriendCardMsg) // 请求好友卡牌申请列表
|
|
RegisterNewMsgProcessFunc("ReqWishApplyList", ReqWishApplyList) // 请求好友心愿单申请列表
|
|
RegisterNewMsgProcessFunc("ReqFriendTimeLine", ReqFriendTimeLine) // 请求好友时间线
|
|
RegisterNewMsgProcessFunc("ReqFriendRecommend", ReqFriendRecommend) // 获取推荐好友
|
|
RegisterNewMsgProcessFunc("ReqFriendTLUpvote", ReqFriendTLUpvote) // 请求时间线点赞
|
|
RegisterNewMsgProcessFunc("ReqFriendTReward", ReqFriendTReward) // 获取时间线奖励
|
|
RegisterNewMsgProcessFunc("ReqAddNpc", ReqAddNpc) // 增加npc
|
|
RegisterNewMsgProcessFunc("ReqWishApply", ReqWishApply) // 同意好友心愿单请求
|
|
RegisterNewMsgProcessFunc("ReqFriendByCode", ReqFriendByCode) // 根据邀请码查询好友
|
|
RegisterNewMsgProcessFunc("ReqFriendReplyHandle", ReqFriendReplyHandle) // 回复好友信息
|
|
|
|
RegisterNewMsgProcessFunc("ReqSearchPlayer", ReqSearchPlayer) // 搜索好友
|
|
RegisterNewMsgProcessFunc("ReqApplyFriend", ReqApplyFriend) // 申请好友
|
|
RegisterNewMsgProcessFunc("ReqAgreeFriend", ReqAgreeFriend) // 同意申请
|
|
RegisterNewMsgProcessFunc("ReqRefuseFriend", ReqRefuseFriend) // 拒绝申请
|
|
RegisterNewMsgProcessFunc("ReqDelFriend", ReqDelFriend) // 删除好友
|
|
|
|
// Facebook邀请好友
|
|
RegisterNewMsgProcessFunc("ReqInviteFriendData", ReqInviteFriendData) // 请求邀请好友数据
|
|
RegisterNewMsgProcessFunc("ReqSelfInvited", ReqSelfInvited) // 请求自己邀请的好友
|
|
RegisterNewMsgProcessFunc("ReqGetInviteReward", ReqGetInviteReward) // 领取邀请奖励
|
|
RegisterNewMsgProcessFunc("ReqAutoAddInviteFriend", ReqAutoAddInviteFriend) // 自动添加邀请好友
|
|
RegisterNewMsgProcessFunc("ReqAutoAddInviteFriend2", ReqAutoAddInviteFriend2) // 自动添加邀请好友
|
|
RegisterNewMsgProcessFunc("ReqBindFacebookAccount", ReqBindFacebookAccount) // 绑定facebook账号
|
|
RegisterNewMsgProcessFunc("ReqOnlyBindFacebook", ReqOnlyBindFacebook) // 绑定唯一facebook
|
|
RegisterNewMsgProcessFunc("ReqUnBindFacebook", ReqUnBindFacebook) // 解绑facebook
|
|
RegisterNewMsgProcessFunc("ReqSynGameData", ReqSynGameData) // 同步账号数据
|
|
|
|
// 榜单
|
|
RegisterNewMsgProcessFunc("ReqRank", ReqRank) // 请求榜单数据
|
|
|
|
// 邮件
|
|
RegisterNewMsgProcessFunc("ReqMailList", ReqMailList) // 请求邮件数据
|
|
RegisterNewMsgProcessFunc("ReqReadMail", ReqReadMail) // 读取邮件
|
|
RegisterNewMsgProcessFunc("ReqGetMailReward", ReqGetMailReward) // 领取邮件奖励
|
|
RegisterNewMsgProcessFunc("ReqDeleteMail", ReqDeleteMail) // 删除邮件
|
|
|
|
// 商店
|
|
RegisterNewMsgProcessFunc("ReqFreeShop", ReqFreeShop) // 领取商店免费奖励
|
|
RegisterNewMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop) // 购买商店棋子
|
|
RegisterNewMsgProcessFunc("ReqBuyChessShop2", ReqBuyChessShop2) // 购买商店棋子直接加入棋盘
|
|
RegisterNewMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店
|
|
RegisterNewMsgProcessFunc("ReqAddWish", ReqAddWish) // 添加心愿单
|
|
RegisterNewMsgProcessFunc("ReqGetWish", ReqGetWish) // 领取心愿单奖励
|
|
RegisterNewMsgProcessFunc("ReqSendWishBeg", ReqSendWishBeg) // 发送心愿单请求
|
|
// 无尽礼包
|
|
RegisterNewMsgProcessFunc("ReqEndless", ReqEndless) // 请求无尽礼包数据
|
|
RegisterNewMsgProcessFunc("ReqEndlessReward", ReqEndlessReward) // 领取无尽礼包免费奖励
|
|
|
|
// 小猪存钱罐
|
|
RegisterNewMsgProcessFunc("ReqPiggyBankReward", ReqPiggyBankReward) // 小猪存钱罐领取奖励
|
|
|
|
// 锦标赛
|
|
RegisterNewMsgProcessFunc("ReqChampship", ReqChampship) // 请求锦标赛数据
|
|
RegisterNewMsgProcessFunc("ReqChampshipReward", ReqChampshipReward) // 领取锦标赛奖励
|
|
RegisterNewMsgProcessFunc("ReqChampshipRankReward", ReqChampshipRankReward) // 领取锦标赛排行榜奖励
|
|
RegisterNewMsgProcessFunc("ReqChampshipRank", ReqChampshipRank) // 请求锦标赛排行榜
|
|
RegisterNewMsgProcessFunc("ReqChampshipPreRank", ReqChampshipPreRank) // 请求锦标赛昨日排行榜
|
|
|
|
// #region 活动
|
|
RegisterNewMsgProcessFunc("ReqActivityReward", ReqActivityReward) // 领取活动奖励
|
|
RegisterNewMsgProcessFunc("ReqAddGiftReward", ReqAddGiftReward) // 领取加赠活动奖励
|
|
// 挖矿
|
|
RegisterNewMsgProcessFunc("ReqMining", ReqMining) // 请求挖矿数据
|
|
RegisterNewMsgProcessFunc("ReqMiningReward", ReqMiningReward) // 领取挖矿奖励
|
|
RegisterNewMsgProcessFunc("ReqMiningTake", ReqMiningTake) // 挖矿
|
|
// 猜颜色
|
|
RegisterNewMsgProcessFunc("ReqGuessColor", ReqGuessColor) // 请求猜颜色数据
|
|
RegisterNewMsgProcessFunc("ReqGuessColorReward", ReqGuessColorReward) // 领取猜颜色奖励
|
|
RegisterNewMsgProcessFunc("ReqGuessColorTake", ReqGuessColorTake) // 猜颜色
|
|
// 三段竞赛
|
|
RegisterNewMsgProcessFunc("ReqRace", ReqRace)
|
|
RegisterNewMsgProcessFunc("ReqRaceReward", ReqRaceReward)
|
|
RegisterNewMsgProcessFunc("ReqRaceStart", ReqRaceStart)
|
|
// 猫草大作战
|
|
RegisterNewMsgProcessFunc("ReqCatnip", ReqCatnip) // 请求猫草大作战数据
|
|
RegisterNewMsgProcessFunc("ReqCatnipInvite", ReqCatnipInvite) // 猫草大作战邀请好友
|
|
RegisterNewMsgProcessFunc("ReqCatnipAgree", ReqCatnipAgree) // 同意邀请
|
|
RegisterNewMsgProcessFunc("ReqCatnipRefuse", ReqCatnipRefuse) // 拒绝邀请
|
|
RegisterNewMsgProcessFunc("ReqCatnipMultiply", ReqCatnipMultiply) // 猫草大作战倍数
|
|
RegisterNewMsgProcessFunc("ReqCatnipPlay", ReqCatnipPlay) // 猫草大作战游戏转盘
|
|
RegisterNewMsgProcessFunc("ReqCatnipReward", ReqCatnipReward) // 猫草大作战领取奖励
|
|
RegisterNewMsgProcessFunc("ReqCatnipGrandReward", ReqCatnipGrandReward) // 猫草大作战领取大奖
|
|
RegisterNewMsgProcessFunc("ReqCatnipEmoji", ReqCatnipEmoji)
|
|
// 猫猫回礼
|
|
RegisterNewMsgProcessFunc("ReqCatReturnGift", ReqCatReturnGift) // 请求猫猫回礼数据
|
|
RegisterNewMsgProcessFunc("ReqCatReturnGiftReward", ReqCatReturnGiftReward) // 领取猫猫回礼奖励
|
|
RegisterNewMsgProcessFunc("ReqCatReturnGiftScore", ReqCatReturnGiftScore) // 领取猫猫回礼积分
|
|
// 活动通行证
|
|
RegisterNewMsgProcessFunc("ReqActPass", ReqActPass) // 请求活动通行证数据
|
|
RegisterNewMsgProcessFunc("ReqActPassReward", ReqActPassReward) // 领取活动通行证奖励
|
|
// #region playroom
|
|
RegisterNewMsgProcessFunc("ReqPlayroom", ReqPlayroom) // 请求playroom数据
|
|
RegisterNewMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo) // 请求playroom拜访信息
|
|
RegisterNewMsgProcessFunc("ReqPlayroomDressSet", ReqPlayroomDressSet) // 设置服装
|
|
RegisterNewMsgProcessFunc("ReqPlayroomPetAirSet", ReqPlayroomPetAirSet) // 获取宠物空气
|
|
RegisterNewMsgProcessFunc("ReqPlayroomGame", ReqPlayroomGame) // 游戏结果
|
|
RegisterNewMsgProcessFunc("ReqPlayroomInteract", ReqPlayroomInteract) // 宠物交互
|
|
RegisterNewMsgProcessFunc("ReqPlayroomSetRoom", ReqPlayroomSetRoom) // playroom装饰
|
|
RegisterNewMsgProcessFunc("ReqPlayroomSelectReward", ReqPlayroomSelectReward) // playroom选择奖励
|
|
RegisterNewMsgProcessFunc("ReqPlayroomLose", ReqPlayroomLose) // 处理偷取的棋子
|
|
RegisterNewMsgProcessFunc("ReqPlayroomWork", ReqPlayroomWork) // 宠物工作
|
|
RegisterNewMsgProcessFunc("ReqPlayroomRest", ReqPlayroomRest) // 宠物休息
|
|
RegisterNewMsgProcessFunc("ReqPlayroomDraw", ReqPlayroomDraw) // 转盘
|
|
RegisterNewMsgProcessFunc("ReqPlayroomFlip", ReqPlayroomFlip) // 翻牌
|
|
RegisterNewMsgProcessFunc("ReqPlayroomFlipReward", ReqPlayroomFlipReward) // 翻牌奖励
|
|
RegisterNewMsgProcessFunc("ReqPlayroomChip", ReqPlayroomChip) // 消除碎片
|
|
RegisterNewMsgProcessFunc("ReqPlayroomOutline", ReqPlayroomOutline) // 打工离线
|
|
RegisterNewMsgProcessFunc("ReqPlayroomWrokOutline", ReqPlayroomWrokOutline) // 打工离线完成
|
|
RegisterNewMsgProcessFunc("ReqPlayroomShop", ReqPlayroomShop) // playroom 商店
|
|
RegisterNewMsgProcessFunc("ReqPlayroomBuyItem", ReqPlayroomBuyItem) // 购买playroom物品
|
|
RegisterNewMsgProcessFunc("ReqPlayroomUpvote", ReqPlayroomUpvote) // 点赞别人的playroom
|
|
RegisterNewMsgProcessFunc("ReqPlayroomUnlock", ReqPlayroomUnlock) // 解锁房间
|
|
RegisterNewMsgProcessFunc("ReqPlayroomTask", ReqPlayroomTask) // playroom任务
|
|
RegisterNewMsgProcessFunc("ReqPlayroomTaskReward", ReqPlayroomTaskReward) // 领取任务奖励
|
|
RegisterNewMsgProcessFunc("ReqPlayroomGameShowReward", ReqPlayroomGameShowReward) // 展示游戏结果数据
|
|
RegisterNewMsgProcessFunc("ReqPlayroomGuide", ReqPlayroomGuide) // 展示游戏结果数据
|
|
RegisterNewMsgProcessFunc("ReqPetFur", ReqPetFur) // 宠物毛皮信息
|
|
RegisterNewMsgProcessFunc("ReqPetFurBuy", ReqPetFurBuy) // 宠物毛皮商店购买
|
|
RegisterNewMsgProcessFunc("ReqFurSet", ReqFurSet) // 宠物毛皮设置
|
|
// 宠物宝藏
|
|
RegisterNewMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure) // 请求好友宝藏数据
|
|
RegisterNewMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始游戏
|
|
RegisterNewMsgProcessFunc("ReqFriendTreasureFilp", ReqFriendTreasureFilp) // 翻牌
|
|
RegisterNewMsgProcessFunc("ReqFriendTreasureEnd", ReqFriendTreasureEnd) // 结束游戏
|
|
|
|
// #region 充值
|
|
RegisterNewMsgProcessFunc("ReqCreateOrderSn", ReqCreateOrderSn) // 创建订单号
|
|
RegisterNewMsgProcessFunc("ReqShippingOrder", ReqShippingOrder) // 获取订单号
|
|
RegisterNewMsgProcessFunc("ReqChargeReceive", ReqChargeReceive) // 礼包回复邮件
|
|
}
|
|
|
|
func (ad *GameLogic) InitActivity() {
|
|
ad.m_CronEntryIDs = make(map[int]*LimitActPeriod)
|
|
}
|
|
|
|
func (ad *GameLogic) NotifyAll(m *MsgMod.Msg) {
|
|
ad.M_Players.Range(func(k, v interface{}) bool {
|
|
v.(*Player).Send(m)
|
|
return true
|
|
})
|
|
}
|
|
|
|
func (ad *GameLogic) GetPlayerNum() int {
|
|
length := 0
|
|
ad.M_Players.Range(func(_, _ interface{}) bool {
|
|
length++
|
|
return true
|
|
})
|
|
return length
|
|
}
|
|
|
|
func (ad *GameLogic) GetStartTime() int64 {
|
|
return ad.StartTime
|
|
}
|
|
|
|
func NotifyPlayer(Uid int, m *MsgMod.Msg) {
|
|
clone := *m
|
|
clone.To = Uid
|
|
clone.HandleType = MsgMod.HANDLE_MOD_PLAYER_MSG
|
|
NotifyPlayerMsgAsync(&clone)
|
|
}
|
|
|
|
func Destroy() {
|
|
log.Debug("服务器下线")
|
|
if G_GameLogicPtr != nil {
|
|
G_GameLogicPtr.M_Players.Range(func(k, v interface{}) bool {
|
|
v.(*Player).PushAndSendClienRes(&msg.ForceKickOut{})
|
|
v.(*Player).ClearData()
|
|
log.Debug("palyer %d 断开连接 写入数据", k)
|
|
return true
|
|
})
|
|
if G_GameLogicPtr.FriendMgr != nil {
|
|
G_GameLogicPtr.FriendMgr.SaveData()
|
|
}
|
|
if G_GameLogicPtr.MessageMgr != nil {
|
|
G_GameLogicPtr.MessageMgr.SaveData()
|
|
}
|
|
if G_GameLogicPtr.VarMgr != nil {
|
|
G_GameLogicPtr.VarMgr.SaveData()
|
|
}
|
|
if G_GameLogicPtr.ChampshipMgr != nil {
|
|
G_GameLogicPtr.ChampshipMgr.SaveData()
|
|
}
|
|
if G_GameLogicPtr.MailMgr != nil {
|
|
G_GameLogicPtr.MailMgr.SaveData()
|
|
}
|
|
if G_GameLogicPtr.RankMgr != nil {
|
|
G_GameLogicPtr.RankMgr.SaveData()
|
|
}
|
|
}
|
|
log.Debug("服务器下线完成")
|
|
}
|
|
|
|
func GeneratedCode(Phone string) (string, error) {
|
|
Code := GoUtil.Rand6DigitNumber()
|
|
log.Debug("生成验证码: %s", Code)
|
|
key := "Code_" + Phone
|
|
value, _ := db.RedisGetKey(key)
|
|
if value != "" {
|
|
//return fmt.Errorf("验证码已发送，请稍后再试")
|
|
}
|
|
db.RedisSetKey(key, Code, 5*time.Minute)
|
|
err := GoUtil.SmsCode(Phone, Code)
|
|
if err != nil {
|
|
log.Error("发送验证码失败: %v", err)
|
|
}
|
|
// TODO 测试用
|
|
return Code, err
|
|
}
|
|
|
|
func VerifyCode(Phone, Code string) error {
|
|
key := "Code_" + Phone
|
|
value, err := db.RedisGetKey(key)
|
|
if err != nil {
|
|
return fmt.Errorf("验证码已失效")
|
|
}
|
|
if value == Code {
|
|
db.RedisDelKey(key)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("验证码错误")
|
|
}
|