872 lines
28 KiB
Go
872 lines
28 KiB
Go
package game
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"server/GoUtil"
|
|
"server/MergeConst"
|
|
"server/conf"
|
|
"strconv"
|
|
"sync"
|
|
|
|
l "log"
|
|
"server/db"
|
|
"server/game/internal"
|
|
MsgMod "server/game/mod/msg" // Ensure this package exists and is correctly referenced
|
|
"server/msg"
|
|
"time"
|
|
|
|
"github.com/robfig/cron/v3"
|
|
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
"server/pkg/github.com/name5566/leaf/gate"
|
|
"server/pkg/github.com/name5566/leaf/log"
|
|
"server/pkg/github.com/name5566/leaf/timer"
|
|
)
|
|
|
|
var (
|
|
G_GameLogicPtr *GameLogic
|
|
)
|
|
|
|
var isInitGameLogic = false
|
|
var RegisterNetWorkFunc = make(map[string]interface{})
|
|
|
|
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 RunNetProcessByKey(key string, param []interface{}) error {
|
|
fun, ok := RegisterNetWorkFunc[key]
|
|
if ok {
|
|
err := fun.(func([]interface{}) error)(param)
|
|
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
|
|
Mlogger *log.Logger
|
|
MloggerErr error
|
|
Version int32
|
|
M_SvrGlobal db.SqlSvrGlobalStruct
|
|
MHttpManager *HttpManager
|
|
SeverInfo *ServerInfo
|
|
|
|
MLogManager *LogMgr // 日志管理器
|
|
FriendMgr *FriendMgr // 好友管理器
|
|
RankMgr *RankMgr // 排行榜管理器
|
|
MailMgr *MailMgr // 邮件管理器
|
|
ChampshipMgr *ChampshipMgr // 锦标赛管理器
|
|
VarMgr *VarMgr // 变量管理器
|
|
StartTime int64 // 服务器启动时间
|
|
}
|
|
|
|
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.RankMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新排行榜
|
|
gl.ChampshipMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新锦标赛
|
|
gl.VarMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新变量
|
|
gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
|
|
gl.CreateDailyLogFile()
|
|
log.Debug("Server ZeroFlush")
|
|
}
|
|
|
|
// 中午更新
|
|
func (gl *GameLogic) NoonFlush() {
|
|
gl.Mdispatr.AfterFunc(time.Second*86400, func() {
|
|
gl.NoonFlush()
|
|
})
|
|
var a1 = []interface{}{gl.DailyTaskTimestamp}
|
|
gl.NotifyAll(MsgMod.MSG_NOON_UPDATE)
|
|
GoUtil.CallEvent(MergeConst.Notify_Midday_Renew, a1)
|
|
}
|
|
|
|
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(conf.Server.ServerID*100000) + int64(conf.Server.AppID*100000000)
|
|
playerInfo := &db.ResPlayerBaseInfo{}
|
|
playerInfo.DwUin = int64(insertId)
|
|
playerInfo.Energy = 100
|
|
playerInfo.Star = 0
|
|
playerInfo.RecoverTime = int32(time.Now().Unix())
|
|
playerInfo.Diamond = 0
|
|
playerInfo.Level = 1
|
|
playerInfo.Exp = 0
|
|
playerInfo.StartOrderId = "1"
|
|
playerInfo.MusicCode = 1
|
|
playerInfo.Guild = 1
|
|
playerInfo.PackUnlockCount = 5
|
|
playerInfo.EnergyBuyCount = 0
|
|
playerInfo.UserName = ad.Db_AccountInfo.UserName
|
|
playerInfo.LoginTime = 0
|
|
playerInfo.LogoutTime = 0
|
|
playerInfo.Todayolinetime = 0
|
|
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")
|
|
G_GameLogicPtr.AddLog(&Log{
|
|
Uid: insertId,
|
|
EventName: "register",
|
|
})
|
|
return true
|
|
}
|
|
|
|
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 := 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)
|
|
}
|
|
|
|
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) FriendMgrSend(m *MsgMod.Msg) {
|
|
ad.FriendMgr.Send(m)
|
|
}
|
|
|
|
func (ad *GameLogic) FriendMgrCall(m *MsgMod.Msg) interface{} {
|
|
result, err := ad.FriendMgr.Call(m)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return result
|
|
}
|
|
|
|
// 排行榜管理器
|
|
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) 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),
|
|
}
|
|
}
|
|
|
|
// 初始化服务器协程
|
|
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.LoadSvrGlobalData() // 加载服务器全局数据
|
|
G_GameLogicPtr.OpenTimestampTick() // 开启时间戳计时器
|
|
G_GameLogicPtr.RegisterEvent() // 注册事件
|
|
G_GameLogicPtr.RegisterNetWorkFunc() // 注册客户端接口
|
|
G_GameLogicPtr.InitActivity() // 初始化活动
|
|
G_GameLogicPtr.GetVersion() // 获取版本号
|
|
G_GameLogicPtr.CreateLogManager() //加载日志管理器
|
|
G_GameLogicPtr.CreateFriendMgr() //创建好友管理器
|
|
G_GameLogicPtr.CreateRankMgr() //创建排行榜管理器
|
|
G_GameLogicPtr.CreateMailMgr() //创建邮件管理器
|
|
G_GameLogicPtr.CreateChampshipMgr() // 创建竞标赛管理器
|
|
G_GameLogicPtr.CreateVarMgr() // 创建变量管理器
|
|
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) GetVersion() {
|
|
sqlStr := "SELECT * FROM t_gameserver WHERE id = ?"
|
|
sqlStruck := db.SqlVersionStruct{}
|
|
IsHaveDataDb := false
|
|
sqlStruck.Id = 1
|
|
G_GameLogicPtr.Version = 0
|
|
if err := db.SqlDb.Get(&sqlStruck, sqlStr, 1); err != nil {
|
|
G_GameLogicPtr.Version = 1
|
|
IsHaveDataDb = false
|
|
} else {
|
|
G_GameLogicPtr.Version = sqlStruck.IsClose + 1
|
|
IsHaveDataDb = true
|
|
}
|
|
sqlStruck.IsClose = G_GameLogicPtr.Version
|
|
|
|
if IsHaveDataDb {
|
|
db.FormatAllMemUpdateDb(&sqlStruck, "t_gameserver", "id")
|
|
} else {
|
|
db.FormatAllMemInsertDb(&sqlStruck, "t_gameserver")
|
|
}
|
|
}
|
|
|
|
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
|
|
log.Debug("player %d 断开连接", player.M_DwUin)
|
|
player.CallEvent(300*time.Second, func() {
|
|
player.lock.Lock()
|
|
defer player.lock.Unlock()
|
|
if player.agent == nil {
|
|
player.ClearData()
|
|
log.Debug("player %d 延迟300s关闭", player.M_DwUin)
|
|
}
|
|
}, "LateClose")
|
|
}
|
|
}
|
|
|
|
func (ad *GameLogic) LoadSvrGlobalData() {
|
|
sqlStr := "SELECT * FROM t_server_global_data WHERE Id = ?"
|
|
|
|
ad.M_SvrGlobal = db.SqlSvrGlobalStruct{}
|
|
|
|
if err := db.SqlDb.Get(&ad.M_SvrGlobal, sqlStr, 1); err != nil {
|
|
log.Debug("get data failed, err:%v\n", err)
|
|
timeStamp := time.Now().Unix()
|
|
t := time.Unix(timeStamp, 0).Local()
|
|
zero := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second())
|
|
ad.M_SvrGlobal.StartMileStoneSvrTime = int32(zero)
|
|
ad.M_SvrGlobal.Id = 1
|
|
db.FormatAllMemInsertDb(&ad.M_SvrGlobal, "t_server_global_data")
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
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)
|
|
player.PushClientRes(&msg.ResLogin{
|
|
ResultCode: 0,
|
|
DwUin: player.M_DwUin,
|
|
})
|
|
// 取消延迟关闭
|
|
Timer, ok := player.timerList["LateClose"]
|
|
if ok {
|
|
Timer.Stop()
|
|
}
|
|
player.LoginBackData()
|
|
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()
|
|
|
|
filename := fmt.Sprintf("%d%02d%02d.log",
|
|
now.Year(),
|
|
now.Month(),
|
|
now.Day(),
|
|
)
|
|
|
|
filepathname := conf.Server.LogPath + "/" + filename
|
|
if !ad.FileExist(filepathname) {
|
|
if ad.Mlogger != nil {
|
|
ad.Mlogger.Close()
|
|
}
|
|
ad.Mlogger, ad.MloggerErr = log.NewDailyLog(now, "Debug", "log", l.LstdFlags)
|
|
if ad.MloggerErr != nil {
|
|
return
|
|
}
|
|
log.Export(ad.Mlogger)
|
|
} else {
|
|
ad.Mlogger, ad.MloggerErr = log.BindLoggerToFile("Debug", filepathname, l.LstdFlags)
|
|
log.Export(ad.Mlogger)
|
|
}
|
|
ad.Mlogger.Debug("CreateDailyLogFile")
|
|
}
|
|
|
|
func (ad *GameLogic) RegisterNetWorkFunc() {
|
|
|
|
RegisterMsgProcessFunc("ReqRemoveAd", ReqRemoveAdFunc)
|
|
RegisterMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileDataFunc)
|
|
RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)
|
|
RegisterMsgProcessFunc("ReqPlayerAsset", ReqPlayerAsset)
|
|
// 玩家
|
|
RegisterMsgProcessFunc("ReqUserInfo", ReqUserInfo)
|
|
RegisterMsgProcessFunc("ReqSetName", ReqSetName) // 设置名字
|
|
RegisterMsgProcessFunc("ReqSetPetName", ReqSetPetName) // 设置宠物名字
|
|
RegisterMsgProcessFunc("ReqSetFacebookUrl", ReqSetFacebookUrl) // 设置facebook地址
|
|
RegisterMsgProcessFunc("ReqPlayerBaseInfo", ReqPlayerBaseInfofunction) // 请求玩家基本信息
|
|
RegisterMsgProcessFunc("UpdateBaseItemInfo", UpdateBaseItemInfofunction) // 保存引导
|
|
RegisterMsgProcessFunc("ReqKv", ReqKv) // 保存客户端数据
|
|
RegisterMsgProcessFunc("ReqGetEnergyByAD", ReqGetEnergyByAD) // 看广告获取能量
|
|
|
|
// #region 棋盘
|
|
RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
|
|
RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
|
|
RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc) //设置能量倍数
|
|
RegisterMsgProcessFunc("ReqChessEx", ReqChessEx) // 转换棋子
|
|
RegisterMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff) // 从buff中获取棋子
|
|
RegisterMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag) // 把棋子放入背包
|
|
RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag) // 从背包中取出棋子
|
|
RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid) // 解锁背包格子
|
|
RegisterMsgProcessFunc("ReqSourceChest", ReqSourceChest) // 开宝箱
|
|
RegisterMsgProcessFunc("ReqSeparateChess", ReqSeparateChess) // 分解棋子
|
|
|
|
RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy) //购买能量
|
|
|
|
//领取图鉴奖励
|
|
RegisterMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励
|
|
|
|
//领取订单奖励
|
|
RegisterMsgProcessFunc("ReqRewardOrder", ReqRewardOrder) // 领取订单奖励
|
|
|
|
//装饰
|
|
RegisterMsgProcessFunc("ReqDecorate", ReqDecorate) // 装饰
|
|
RegisterMsgProcessFunc("ReqDecorateAll", ReqDecorateAll) // 装饰全部
|
|
//Gm命令
|
|
RegisterMsgProcessFunc("ReqGmCommand", ReqGmCommand) // Gm命令
|
|
|
|
// #region 卡牌
|
|
RegisterMsgProcessFunc("ReqCardInfo", ReqCardInfo) // 请求卡牌信息
|
|
RegisterMsgProcessFunc("ReqCardCollectReward", ReqCardCollectReward) //领取卡牌系列收集奖励
|
|
RegisterMsgProcessFunc("ReqExStarReward", ReqExStarReward) // 兑换收集星星奖励
|
|
RegisterMsgProcessFunc("ReqAllCollectReward", ReqAllCollectReward) // 领取全收集奖励
|
|
RegisterMsgProcessFunc("ReqCardGive", ReqCardGive) // 请求赠送卡牌
|
|
RegisterMsgProcessFunc("ReqAgreeCardGive", ReqAgreeCardGive) // 同意赠送卡牌
|
|
RegisterMsgProcessFunc("ReqRefuseCardGive", ReqRefuseCardGive) // 拒绝赠送卡牌
|
|
|
|
RegisterMsgProcessFunc("ReqCardExchange", ReqCardExchange) // 请求交换卡牌
|
|
RegisterMsgProcessFunc("ReqSelectCardExchange", ReqSelectCardExchange) // 选择交换的卡牌
|
|
RegisterMsgProcessFunc("ReqAgreeCardExchange", ReqAgreeCardExchange) // 完成交换卡牌
|
|
RegisterMsgProcessFunc("ReqRefuseCardSelect", ReqRefuseCardSelect) // 拒绝选择卡牌进行交换
|
|
RegisterMsgProcessFunc("ReqRefuseCardExchange", ReqRefuseCardExchange) // 拒绝卡牌交换
|
|
RegisterMsgProcessFunc("ReqCardSend", ReqCardSend) // 直接赠送卡牌
|
|
RegisterMsgProcessFunc("ReqGetFriendCard", ReqGetFriendCard) // 领取好友赠送的卡牌
|
|
RegisterMsgProcessFunc("ReqMasterCard", ReqMasterCard) // 万能卡兑换
|
|
RegisterMsgProcessFunc("ReqCardHandbookReward", ReqCardHandbookReward) // 卡牌图鉴
|
|
|
|
// 日常任务
|
|
RegisterMsgProcessFunc("ReqGetDailyTaskReward", ReqGetDailyTaskReward) // 领取日常任务奖励
|
|
RegisterMsgProcessFunc("ReqGetDailyWeekReward", ReqGetDailyWeekReward) // 领取周活跃奖励
|
|
RegisterMsgProcessFunc("ReqDailyUnlock", ReqDailyUnlock) // 日常任务解锁
|
|
|
|
// 引导奖励
|
|
RegisterMsgProcessFunc("ReqGuideReward", ReqGuideReward) // 领取引导奖励
|
|
// 头像
|
|
RegisterMsgProcessFunc("ReqSetFace", ReqSetFace) // 设置头像
|
|
// 头像框
|
|
RegisterMsgProcessFunc("ReqSetAvatar", ReqSetAvatar) // 设置头像框
|
|
|
|
// 七日签到
|
|
RegisterMsgProcessFunc("ReqGetSevenLoginReward", ReqGetSevenLoginReward) // 领取七日签到奖励
|
|
RegisterMsgProcessFunc("ReqGetMonthLoginReward", ReqGetMonthLoginReward) // 领取月签到奖励
|
|
|
|
// 限时事件
|
|
RegisterMsgProcessFunc("ReqLimitEvent", ReqLimitEvent) // 请求限时事件数据
|
|
RegisterMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward) // 连击快手奖励
|
|
RegisterMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward) // 获取场景转盘奖励
|
|
RegisterMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent) //领取限时事件进度奖励
|
|
RegisterMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard) //请求金卡交换信息
|
|
|
|
// #region 好友
|
|
RegisterMsgProcessFunc("ReqFriendList", ReqFriendList) // 请求好友列表
|
|
RegisterMsgProcessFunc("ReqFriendApply", ReqFriendApply) // 请求申请好友列表
|
|
RegisterMsgProcessFunc("ReqFriendCardMsg", ReqFriendCardMsg) // 请求好友卡牌申请列表
|
|
RegisterMsgProcessFunc("ReqFriendTimeLine", ReqFriendTimeLine) // 请求好友时间线
|
|
RegisterMsgProcessFunc("ReqFriendRecommend", ReqFriendRecommend) // 获取推荐好友
|
|
|
|
RegisterMsgProcessFunc("ReqSearchPlayer", ReqSearchPlayer) // 搜索好友
|
|
RegisterMsgProcessFunc("ReqApplyFriend", ReqApplyFriend) // 申请好友
|
|
RegisterMsgProcessFunc("ReqAgreeFriend", ReqAgreeFriend) // 同意申请
|
|
RegisterMsgProcessFunc("ReqRefuseFriend", ReqRefuseFriend) // 拒绝申请
|
|
RegisterMsgProcessFunc("ReqDelFriend", ReqDelFriend) // 删除好友
|
|
|
|
// Facebook邀请好友
|
|
RegisterMsgProcessFunc("ReqInviteFriendData", ReqInviteFriendData) // 请求邀请好友数据
|
|
RegisterMsgProcessFunc("ReqSelfInvited", ReqSelfInvited) // 请求自己邀请的好友
|
|
RegisterMsgProcessFunc("ReqGetInviteReward", ReqGetInviteReward) // 领取邀请奖励
|
|
RegisterMsgProcessFunc("ReqAutoAddInviteFriend", ReqAutoAddInviteFriend) // 自动添加邀请好友
|
|
RegisterMsgProcessFunc("ReqBindFacebookAccount", ReqBindFacebookAccount) // 绑定facebook账号
|
|
RegisterMsgProcessFunc("ReqOnlyBindFacebook", ReqOnlyBindFacebook) // 绑定唯一facebook
|
|
RegisterMsgProcessFunc("ReqUnBindFacebook", ReqUnBindFacebook) // 解绑facebook
|
|
RegisterMsgProcessFunc("ReqSynGameData", ReqSynGameData) // 同步账号数据
|
|
|
|
// 榜单
|
|
RegisterMsgProcessFunc("ReqRank", ReqRank) // 请求榜单数据
|
|
|
|
// 邮件
|
|
RegisterMsgProcessFunc("ReqMailList", ReqMailList) // 请求邮件数据
|
|
RegisterMsgProcessFunc("ReqReadMail", ReqReadMail) // 读取邮件
|
|
RegisterMsgProcessFunc("ReqGetMailReward", ReqGetMailReward) // 领取邮件奖励
|
|
RegisterMsgProcessFunc("ReqDeleteMail", ReqDeleteMail) // 删除邮件
|
|
|
|
// 商店
|
|
RegisterMsgProcessFunc("ReqFreeShop", ReqFreeShop) // 领取商店免费奖励
|
|
RegisterMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop) // 购买商店棋子
|
|
RegisterMsgProcessFunc("ReqBuyChessShop2", ReqBuyChessShop2) // 购买商店棋子直接加入棋盘
|
|
RegisterMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店
|
|
|
|
// 无尽礼包
|
|
RegisterMsgProcessFunc("ReqEndless", ReqEndless) // 请求无尽礼包数据
|
|
RegisterMsgProcessFunc("ReqEndlessReward", ReqEndlessReward) // 领取无尽礼包免费奖励
|
|
|
|
// 小猪存钱罐
|
|
RegisterMsgProcessFunc("ReqPiggyBankReward", ReqPiggyBankReward) // 小猪存钱罐领取奖励
|
|
|
|
// 锦标赛
|
|
RegisterMsgProcessFunc("ReqChampshipReward", ReqChampshipReward) // 领取锦标赛奖励
|
|
RegisterMsgProcessFunc("ReqChampshipRankReward", ReqChampshipRankReward) // 领取锦标赛排行榜奖励
|
|
RegisterMsgProcessFunc("ReqChampshipRank", ReqChampshipRank) // 请求锦标赛排行榜
|
|
RegisterMsgProcessFunc("ReqChampshipPreRank", ReqChampshipPreRank) // 请求锦标赛昨日排行榜
|
|
|
|
// #region 活动
|
|
// 挖矿
|
|
RegisterMsgProcessFunc("ReqMining", ReqMining) // 请求挖矿数据
|
|
RegisterMsgProcessFunc("ReqMiningReward", ReqMiningReward) // 领取挖矿奖励
|
|
RegisterMsgProcessFunc("ReqMiningTake", ReqMiningTake) // 挖矿
|
|
// 猜颜色
|
|
RegisterMsgProcessFunc("ReqGuessColor", ReqGuessColor) // 请求猜颜色数据
|
|
RegisterMsgProcessFunc("ReqGuessColorReward", ReqGuessColorReward) // 领取猜颜色奖励
|
|
RegisterMsgProcessFunc("ReqGuessColorTake", ReqGuessColorTake) // 猜颜色
|
|
// 三段竞赛
|
|
RegisterMsgProcessFunc("ReqRace", ReqRace)
|
|
RegisterMsgProcessFunc("ReqRaceReward", ReqRaceReward)
|
|
RegisterMsgProcessFunc("ReqRaceStart", ReqRaceStart)
|
|
|
|
// #region playroom
|
|
RegisterMsgProcessFunc("ReqPlayroom", ReqPlayroom) // 请求playroom数据
|
|
RegisterMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo) // 请求playroom拜访信息
|
|
RegisterMsgProcessFunc("ReqPlayroomGame", ReqPlayroomGame) // 游戏结果
|
|
RegisterMsgProcessFunc("ReqPlayroomInteract", ReqPlayroomInteract) // 宠物交互
|
|
RegisterMsgProcessFunc("ReqPlayroomSetRoom", ReqPlayroomSetRoom) // playroom装饰
|
|
RegisterMsgProcessFunc("ReqPlayroomSelectReward", ReqPlayroomSelectReward) // playroom选择奖励
|
|
RegisterMsgProcessFunc("ReqPlayroomLose", ReqPlayroomLose) // 处理偷取的棋子
|
|
RegisterMsgProcessFunc("ReqPlayroomWork", ReqPlayroomWork) // 宠物工作
|
|
RegisterMsgProcessFunc("ReqPlayroomRest", ReqPlayroomRest) // 宠物休息
|
|
RegisterMsgProcessFunc("ReqPlayroomDraw", ReqPlayroomDraw) // 转盘
|
|
RegisterMsgProcessFunc("ReqPlayroomFlip", ReqPlayroomFlip) // 翻牌
|
|
RegisterMsgProcessFunc("ReqPlayroomFlipReward", ReqPlayroomFlipReward) // 翻牌奖励
|
|
RegisterMsgProcessFunc("ReqPlayroomChip", ReqPlayroomChip) // 消除碎片
|
|
RegisterMsgProcessFunc("ReqPlayroomOutline", ReqPlayroomOutline) // 打工离线
|
|
RegisterMsgProcessFunc("ReqPlayroomWrokOutline", ReqPlayroomWrokOutline) // 打工离线完成
|
|
|
|
// 宠物宝藏
|
|
RegisterMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure) // 请求好友宝藏数据
|
|
RegisterMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始游戏
|
|
RegisterMsgProcessFunc("ReqFriendTreasureFilp", ReqFriendTreasureFilp) // 翻牌
|
|
RegisterMsgProcessFunc("ReqFriendTreasureEnd", ReqFriendTreasureEnd) // 结束游戏
|
|
RegisterMsgProcessFunc("ReqPlayroomBuyItem", ReqPlayroomBuyItem) // 购买playroom物品
|
|
|
|
RegisterMsgProcessFunc("ReqKafkaLog", ReqKafkaLog) // 客户端日志
|
|
RegisterMsgProcessFunc("ReqCreateOrderSn", ReqCreateOrderSn) // 创建订单号
|
|
RegisterMsgProcessFunc("ReqShippingOrder", ReqShippingOrder) // 获取订单号
|
|
}
|
|
|
|
func (ad *GameLogic) CreateHttpManager() {
|
|
|
|
go func() {
|
|
ad.MHttpManager = new(HttpManager)
|
|
ad.MHttpManager.InitRounter()
|
|
}()
|
|
|
|
}
|
|
|
|
func (ad *GameLogic) CreateLogManager() {
|
|
ad.MLogManager = new(LogMgr)
|
|
ad.MLogManager.InitManager()
|
|
}
|
|
|
|
func (ad *GameLogic) InitActivity() {
|
|
ad.m_CronEntryIDs = make(map[int]*LimitActPeriod)
|
|
}
|
|
|
|
func (ad *GameLogic) AddLog(Log *Log) {
|
|
Log.TimeStamp = time.Now().Unix()
|
|
go func() {
|
|
ad.MLogManager.AddLog(Log)
|
|
}()
|
|
}
|
|
|
|
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) {
|
|
p := G_GameLogicPtr.GetPlayer(int64(Uid))
|
|
if p == nil || p.stop {
|
|
return
|
|
}
|
|
p.Send(m)
|
|
}
|
|
|
|
func setRedisLock(key, value string, Duration time.Duration) bool {
|
|
return db.RedisLock(key, "", Duration)
|
|
}
|
|
|
|
func getRedisLock(key string) error {
|
|
_, err := db.RedisGetKey(key)
|
|
return err
|
|
}
|
|
|
|
func unsetRedisLock(key string) {
|
|
db.RedisUnlock(key, "")
|
|
}
|
|
|
|
func Destroy() {
|
|
log.Debug("服务器下线")
|
|
if G_GameLogicPtr != nil {
|
|
G_GameLogicPtr.M_Players.Range(func(k, v interface{}) bool {
|
|
v.(*Player).ClearData()
|
|
log.Debug("palyer %d 断开连接 写入数据", k)
|
|
return true
|
|
})
|
|
G_GameLogicPtr.FriendMgr.SaveData()
|
|
G_GameLogicPtr.RankMgr.SaveData()
|
|
G_GameLogicPtr.ChampshipMgr.SaveData()
|
|
G_GameLogicPtr.MailMgr.SaveData()
|
|
G_GameLogicPtr.VarMgr.SaveData()
|
|
G_GameLogicPtr.MLogManager.Close()
|
|
}
|
|
}
|