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

代码整理

Browse Source
This commit is contained in:
hahwu 2024-11-29 17:10:47 +08:00
parent 83f33f24ec
commit 859433eee7
29 changed files with 78 additions and 12823 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/server/conf/mergeData/MergeDataCfg.go
View File

@ -135,6 +135,16 @@ func GetEmitProduceType(Id int) []string {
return strings.Split(gamedata.ParseString(data["Emit_Product"]), ",")
}
// 根据Id获取发射器产出类型
func GetEmitProduceChessType(Id int) []string {
data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
if err != nil {
log.Debug("GetTypeById GetOne Id:%v not found", Id)
return []string{}
}
return strings.Split(gamedata.ParseString(data["Product_Type"]), ",")
}
// 根据Id获取发射器Id
func GetEmitId(Id int) string {
data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)

783
src/server/game/ChampshipsManager.go
View File

@ -1,783 +0,0 @@
package game
import (
"fmt"
"math"
"math/rand"
"server/GoUtil"
"server/MergeConst"
"server/db"
"server/msg"
"sort"
"strconv"
"strings"
"time"
"github.com/robfig/cron/v3"
"google.golang.org/protobuf/proto"
)
type ChampshipsManager struct {
MStatus int32
MChampshipMap map[int32]*db.SqlChampshipsStruct
MChampshipPlayerMap map[int32][]*msg.ChampshipsPlayerInfo
IsSettle int32
IsLoadDB bool
MUpdateNotifyList []int32
McronSave *cron.Cron
McronSaveID cron.EntryID
RobotCronID cron.EntryID
RobotCronID10s cron.EntryID
MPlayerBaseInfoMap map[int32]*db.ResPlayerBaseInfo
}
func (p *ChampshipsManager) SaveDataFromDB(Key interface{}) bool {
return true
}
func (p *ChampshipsManager) AIGrow1() {
}
func (p *ChampshipsManager) DeleteOutLineChampship(CurChampshipsId int32) {
sqlStr := "DELETE FROM t_championships_data WHERE CurChampshipsId = ?"
for k, v := range p.MChampshipPlayerMap {
if v[0].CurChampshipsId == CurChampshipsId {
delete(p.MChampshipPlayerMap, k)
}
}
result, err := db.SqlDb.Exec(sqlStr, CurChampshipsId)
if err != nil {
fmt.Printf("exec failed, err:%v\n", err)
return
}
affectedRows, err := result.RowsAffected()
if err != nil {
fmt.Printf("get affected failed, err:%v\n", err)
return
} else {
fmt.Printf("delete t_championships_data affectedRows:%d\n", affectedRows)
}
}
func (p *ChampshipsManager) DeleteUneffectPlayer(deleteIds []int32) {
sqlStr := "DELETE FROM t_player_baseinfo WHERE dwUin = ?"
for i := 0; i < len(deleteIds); i++ {
_, err := db.SqlDb.Exec(sqlStr, deleteIds[i])
if err != nil {
fmt.Printf("exec failed, err:%v\n", err)
}
}
}
func (p *ChampshipsManager) GetFriendListId(id int32) []int32 {
sqlStr := "SELECT * FROM t_player_Friend_Data WHERE dwUin = ?"
sqlStruck := db.SqlFriendStruct{}
ret := []int32{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, id); err != nil {
} else {
if sqlStruck.FriendList != "" {
arr := strings.Split(sqlStruck.FriendList, "_")
for i := 0; i < len(arr); i++ {
id, _ := strconv.ParseInt(arr[i], 10, 32)
ret = append(ret, int32(id))
}
}
}
return ret
}
func (p *ChampshipsManager) NotifyOpenNewChampShip(args []interface{}) {
go func() {
G_GameLogicPtr.M_SvrGlobal.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId + 1
G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime = args[0].(int32)
}()
}
func (p *ChampshipsManager) OpenNewChampShip(args []interface{}) {
G_GameLogicPtr.M_SvrGlobal.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId + 1
G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime = args[0].(int32)
p.MUpdateNotifyList = []int32{}
sqlStr := "SELECT * FROM t_player_baseinfo"
sqlStrucks := []db.ResPlayerBaseInfo{}
if err := db.SqlDb.Select(&sqlStrucks, sqlStr); err != nil {
return
} else {
}
deleteIds := []int32{}
sqlStrucksList := []db.ResPlayerBaseInfo{}
for i := 0; i < len(sqlStrucks); i++ {
if sqlStrucks[i].UserName == "" {
deleteIds = append(deleteIds, sqlStrucks[i].DwUin)
} else {
sqlStrucksList = append(sqlStrucksList, sqlStrucks[i])
}
}
sqlStrucks = sqlStrucksList
p.DeleteUneffectPlayer(deleteIds)
sort.Slice(sqlStrucks, func(i, j int) bool {
if sqlStrucks[i].Level != sqlStrucks[j].Level {
return sqlStrucks[i].Level < sqlStrucks[j].Level
} else {
return sqlStrucks[i].Exp < sqlStrucks[j].Exp
}
})
var playerCnt int = 15
groups := int(math.Ceil((float64)(len(sqlStrucks)) / float64(playerCnt)))
StartRobotUin := 200000
p.MStatus = 1
rand.Seed(time.Now().Unix())
for i := 0; i < groups; i++ {
if i < groups-1 {
temp := db.SqlChampshipsStruct{}
temp.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo := []*msg.ChampshipsPlayerInfo{}
strr := []string{}
for j := 0; j < int(playerCnt); j++ {
dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
res := strconv.Itoa(int(dwUin)) + "_" + "1" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_0"
strr = append(strr, res)
playerinfo := &msg.ChampshipsPlayerInfo{}
playerinfo.DwUin = dwUin
playerinfo.IsGet = 0
playerinfo.IsPlayer = 1
playerinfo.Score = 0
playerinfo.Times = 1
playerinfo.AIEnum = 0
playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo = append(CSPlayerInfo, playerinfo)
}
for j := int(playerCnt); j < 30; j++ {
StartRobotUin = StartRobotUin + 1
dwUin := StartRobotUin
enum := rand.Intn(4) + 1
res := strconv.Itoa(int(dwUin)) + "_" + "0" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_" + strconv.Itoa(enum)
strr = append(strr, res)
playerinfo := &msg.ChampshipsPlayerInfo{}
playerinfo.DwUin = int32(dwUin)
playerinfo.IsGet = 0
playerinfo.IsPlayer = 0
playerinfo.Score = 0
playerinfo.Times = 1
playerinfo.AIEnum = int32(enum)
playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo = append(CSPlayerInfo, playerinfo)
}
temp.GroupRankData = strings.Join(strr, ";")
insertId, _ := db.FormatAllMemInsertDb(&temp, "t_championships_data")
p.MChampshipPlayerMap[int32(insertId)] = CSPlayerInfo
for j := 0; j < int(playerCnt); j++ {
dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
player, ok := G_GameLogicPtr.M_Players[dwUin]
if ok {
player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), true)
} else {
player = G_GameLogicPtr.FindOfflinePlayer(dwUin)
if player != nil {
player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), false)
} else {
sqlStrucks[i*int(playerCnt)+j].LastChampGroupID = sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID
sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID = int32(insertId)
db.FormatAllMemUpdateDb(&sqlStrucks[i*int(playerCnt)+j], "t_player_baseinfo", "dwUin")
}
}
}
} else {
remain := len(sqlStrucks) - (groups-1)*int(playerCnt)
cnt := 0
strr := []string{}
temp := db.SqlChampshipsStruct{}
temp.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo := []*msg.ChampshipsPlayerInfo{}
for j := 0; j < remain; j++ {
dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
res := strconv.Itoa(int(dwUin)) + "_" + "1" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_0"
strr = append(strr, res)
cnt = cnt + 1
playerinfo := &msg.ChampshipsPlayerInfo{}
playerinfo.DwUin = dwUin
playerinfo.IsGet = 0
playerinfo.IsPlayer = 1
playerinfo.Score = 0
playerinfo.Times = 1
playerinfo.AIEnum = 0
playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo = append(CSPlayerInfo, playerinfo)
}
for j := cnt; j < 30; j++ {
StartRobotUin = StartRobotUin + 1
dwUin := StartRobotUin
enum := rand.Intn(4) + 1
res := strconv.Itoa(int(dwUin)) + "_" + "0" + "_" + "0" + "_" + "0" + "_" + "1" + "_" + strconv.Itoa(int(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)) + "_" + strconv.Itoa(enum)
strr = append(strr, res)
playerinfo := &msg.ChampshipsPlayerInfo{}
playerinfo.DwUin = int32(dwUin)
playerinfo.IsGet = 0
playerinfo.IsPlayer = 0
playerinfo.Score = 0
playerinfo.Times = 1
playerinfo.AIEnum = int32(enum)
playerinfo.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
CSPlayerInfo = append(CSPlayerInfo, playerinfo)
}
temp.GroupRankData = strings.Join(strr, ";")
insertId, _ := db.FormatAllMemInsertDb(&temp, "t_championships_data")
p.MChampshipPlayerMap[int32(insertId)] = CSPlayerInfo
for j := 0; j < remain; j++ {
dwUin := sqlStrucks[i*int(playerCnt)+j].DwUin
player, ok := G_GameLogicPtr.M_Players[dwUin]
if ok {
player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), true)
} else {
player = G_GameLogicPtr.FindOfflinePlayer(dwUin)
if player != nil {
player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).SetChampshipID(int32(insertId), false)
} else {
sqlStrucks[i*int(playerCnt)+j].LastChampGroupID = sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID
sqlStrucks[i*int(playerCnt)+j].ChampshipsGroupID = int32(insertId)
db.FormatAllMemUpdateDb(&sqlStrucks[i*int(playerCnt)+j], "t_player_baseinfo", "dwUin")
}
}
}
}
}
p.IsLoadDB = true
p.AIScoreGrowth1h()
db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
}
func (p *ChampshipsManager) OpenChampShipTimes(args []interface{}) {
p.MStatus = 2
notify := &msg.NotifyChampshipTimesOpen{}
notify.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
data, _ := proto.Marshal(notify)
G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipTimesOpen", data)
}
func (p *ChampshipsManager) CloseChampShipTimes(args []interface{}) {
p.MStatus = 1
notify := &msg.NotifyChampshipTimesClose{}
notify.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
data, _ := proto.Marshal(notify)
G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipTimesClose", data)
}
func (p *ChampshipsManager) Notify_Clock_Tick_Sec(args []interface{}) {
timeStamp := args[0].(int64)
t := time.Unix(timeStamp, 0).Local()
zero := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second())
OpenTime := zero + MergeConst.G_Champion_Start_Offset
OpenTimesTime := zero + MergeConst.G_Champion_Start_Effect_Time
CloseTimesTime := zero + MergeConst.G_Champion_Start_Effect_Time + MergeConst.G_Champion_Start_Effect_Durtion
DeleteLastTimesTime := zero + MergeConst.G_Champion_settlement_Duration
if G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime < int32(OpenTime) { //今日没有开启
if timeStamp >= OpenTime { //开启
GoUtil.CallEvent(MergeConst.Notify_Champion_Renew, []interface{}{int32(OpenTime)})
} else {
//开启时间未到
if p.MStatus == 1 {
GoUtil.CallEvent(MergeConst.Notify_EndChampShip, []interface{}{int32(OpenTime)})
}
}
} else {
if p.MStatus == 0 {
p.MStatus = 1
}
if !p.IsLoadDB {
p.LoadDbDataByGroupId(G_GameLogicPtr.M_SvrGlobal.CurChampshipsId)
if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
p.LoadDbDataByGroupId(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
}
p.IsLoadDB = true
}
}
if p.MStatus == 1 {
if timeStamp >= OpenTimesTime && timeStamp <= CloseTimesTime {
GoUtil.CallEvent(MergeConst.Notify_OpenChampShipTimes, []interface{}{int32(OpenTime)})
}
}
if p.MStatus == 2 {
if timeStamp > CloseTimesTime {
GoUtil.CallEvent(MergeConst.Notify_CloseChampShipTimes, []interface{}{int32(OpenTime)})
}
}
if p.IsSettle == 0 {
if timeStamp <= DeleteLastTimesTime {
p.IsSettle = 1
} else {
if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
p.DeleteOutLineChampship(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = 0
db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
}
}
}
if p.IsSettle == 1 {
if timeStamp > DeleteLastTimesTime {
notify := &msg.NotifyChampshipSettleClose{}
notify.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.LastChampshipsId
data, _ := proto.Marshal(notify)
G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipSettleClose", data)
p.IsSettle = 0
if G_GameLogicPtr.M_SvrGlobal.LastChampshipsId > 0 {
p.DeleteOutLineChampship(G_GameLogicPtr.M_SvrGlobal.LastChampshipsId)
G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = 0
db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
}
}
}
}
func (p *ChampshipsManager) EndChampShip(args []interface{}) {
p.MStatus = 0
G_GameLogicPtr.M_SvrGlobal.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
db.FormatAllMemUpdateDb(&G_GameLogicPtr.M_SvrGlobal, "t_server_global_data", "Id")
notify := &msg.NotifyChampshipSettleOpen{}
notify.LastChampshipsId = G_GameLogicPtr.M_SvrGlobal.LastChampshipsId
data, _ := proto.Marshal(notify)
G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipSettleOpen", data)
notify1 := &msg.NotifyChampshipClose{}
notify1.CurChampshipsId = G_GameLogicPtr.M_SvrGlobal.CurChampshipsId
data1, _ := proto.Marshal(notify1)
G_GameLogicPtr.broadcastInfoAllPlayer("NotifyChampshipClose", data1)
p.NotifyRenewChampshipData()
}
func (p *ChampshipsManager) NotifyRenewChampshipData() {
for i := 0; i < len(p.MUpdateNotifyList); i++ {
groupid := p.MUpdateNotifyList[i]
playerlist, ok := p.MChampshipPlayerMap[groupid]
if ok {
for j := 0; j < len(playerlist); j++ {
if playerlist[j].IsPlayer == 1 {
dwUin := playerlist[j].DwUin
player, ok1 := G_GameLogicPtr.M_Players[dwUin]
if ok1 {
agent := player.GetAgentByPlayer()
notify := &msg.NotifyUpdateChampshipRank{}
notify.ChampshipsGroupID = groupid
notify.GroupRankDataList = playerlist
data, _ := proto.Marshal(notify)
G_getGameLogic().PackResInfo(agent, "NotifyUpdateChampshipRank", data)
} else {
}
}
}
}
}
p.MUpdateNotifyList = p.MUpdateNotifyList[0:0]
}
func (p *ChampshipsManager) ReqChampshipData(player *Player, buf []byte) {
req := &msg.ReqChampshipData{}
proto.Unmarshal(buf, req)
res := &msg.ResChampshipData{}
_, ok := p.MChampshipPlayerMap[req.ChampshipsGroupID]
if ok {
res.GroupRankDataList = p.MChampshipPlayerMap[req.ChampshipsGroupID]
}
res.ChampshipsGroupID = req.ChampshipsGroupID
res.Status = p.MStatus
res.IsSettle = p.IsSettle
res.EndTime = G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime + MergeConst.G_Champion_Duration
res.EndSettleTime = G_GameLogicPtr.M_SvrGlobal.StartChampshipsSvrTime - MergeConst.G_Champion_Start_Offset + MergeConst.G_Champion_Start_Effect_Time + MergeConst.G_Champion_Start_Effect_Durtion
agent := player.GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResChampshipData", data)
}
func (p *ChampshipsManager) InitManager() {
GoUtil.RegisterEvent(MergeConst.Notify_Champion_Renew, p.OpenNewChampShip, p)
GoUtil.RegisterEvent(MergeConst.Notify_OpenChampShipTimes, p.OpenChampShipTimes, p)
GoUtil.RegisterEvent(MergeConst.Notify_CloseChampShipTimes, p.CloseChampShipTimes, p)
GoUtil.RegisterEvent(MergeConst.Notify_EndChampShip, p.EndChampShip, p)
GoUtil.RegisterEvent(MergeConst.Notify_Clock_Tick_Sec, p.Notify_Clock_Tick_Sec, p)
p.MChampshipMap = make(map[int32]*db.SqlChampshipsStruct)
p.MChampshipPlayerMap = make(map[int32][]*msg.ChampshipsPlayerInfo)
p.MStatus = 0
p.IsSettle = 0
p.IsLoadDB = false
p.MUpdateNotifyList = []int32{}
p.McronSave = cron.New()
p.McronSaveID, _ = p.McronSave.AddFunc("@every 70s", func() {
p.NotifyRenewChampshipData()
})
p.RobotCronID, _ = p.McronSave.AddFunc("@every 1h", func() {
p.AIScoreGrowth1h()
})
p.RobotCronID10s, _ = p.McronSave.AddFunc("@every 15m", func() {
if p.MStatus == 2 {
p.RobotIntervalAddScore15m()
}
})
p.McronSave.Start()
}
func (p *ChampshipsManager) RobotIntervalAddScore() {
seed := time.Now().Unix()
rand.Seed(seed)
needToUpdateDb := []int32{}
for k, v := range p.MChampshipPlayerMap {
ishaveRobot := false
for i := 0; i < len(v); i++ {
if v[i].IsPlayer == 0 {
ishaveRobot = true
addScore := 3
ran := rand.Intn(100) + 1
if ran <= 25 {
addScore = addScore + 1
} else {
if ran <= 50 {
addScore = addScore + 2
}
}
v[i].Score = v[i].Score + int32(addScore)
}
}
if ishaveRobot {
sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
isAdd := false
for i := 0; i < len(p.MUpdateNotifyList); i++ {
if p.MUpdateNotifyList[i] == k {
isAdd = true
break
}
}
if !isAdd {
p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
}
needToUpdateDb = append(needToUpdateDb, k)
}
}
for i := 0; i < len(needToUpdateDb); i++ {
p.SaveDbDataByGroupId(needToUpdateDb[i])
}
}
func (p *ChampshipsManager) GetMinGroupId() int32 {
var Min int32 = 0
for k := range p.MChampshipPlayerMap {
if Min == 0 {
Min = k
continue
}
if k < Min {
Min = k
}
}
return Min
}
func (p *ChampshipsManager) AIScoreGrowth1h() {
seed := time.Now().Unix()
rand.Seed(seed)
needToUpdateDb := []int32{}
// MinGroupId := p.GetMinGroupId()
for k, v := range p.MChampshipPlayerMap {
ishaveRobot := false
groupId := 0 //k - MinGroupId + 1
for i := 0; i < len(v); i++ {
if v[i].IsPlayer == 0 {
ishaveRobot = true
addScore := 0
if v[i].AIEnum == 1 {
var num1 float64 = 0.5
var num2 float64 = 5.5
groupId = rand.Intn(7) + 1
addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
}
if v[i].AIEnum == 2 {
addScore = 16
ran := rand.Intn(100) + 1
if ran <= 25 {
addScore = addScore + 6
} else {
if ran <= 50 {
addScore = addScore + 10
}
}
}
if v[i].AIEnum == 3 {
addScore = 16
ran := rand.Intn(100) + 1
if ran <= 25 {
addScore = addScore + 10
} else {
if ran <= 75 {
addScore = addScore + 6
}
}
var num1 float64 = 0.5
var num2 float64 = 5.5
groupId = rand.Intn(7) + 1
addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
}
if v[i].AIEnum == 4 {
var num1 float64 = 0.5
var num2 float64 = 5.5
groupId = rand.Intn(7) + 1
addScore = addScore + int(math.Floor(float64(groupId-1)*num1*num2))
score := rand.Intn(23)
addScore = addScore + score
}
v[i].Score = v[i].Score + int32(addScore)
}
}
if ishaveRobot {
sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
isAdd := false
for i := 0; i < len(p.MUpdateNotifyList); i++ {
if p.MUpdateNotifyList[i] == k {
isAdd = true
break
}
}
if !isAdd {
p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
}
needToUpdateDb = append(needToUpdateDb, k)
}
}
for i := 0; i < len(needToUpdateDb); i++ {
p.SaveDbDataByGroupId(needToUpdateDb[i])
}
}
func (p *ChampshipsManager) RobotIntervalAddScore15m() {
seed := time.Now().Unix()
rand.Seed(seed)
needToUpdateDb := []int32{}
for k, v := range p.MChampshipPlayerMap {
ishaveRobot := false
for i := 0; i < len(v); i++ {
if v[i].IsPlayer == 0 {
addScore := 0
if v[i].AIEnum == 1 {
ran := rand.Intn(100) + 1
if ran <= 25 {
addScore = addScore + 10
} else {
if ran <= 75 {
addScore = addScore + 6
}
}
ran = rand.Intn(100) + 1
if ran <= 25 {
addScore = addScore + 5
} else {
if ran <= 50 {
addScore = addScore + 10
}
}
if addScore > 0 {
ishaveRobot = true
v[i].Score = v[i].Score + int32(addScore)
}
}
}
}
if ishaveRobot {
sort.Slice(v, func(i, j int) bool { return v[i].Score > v[j].Score })
isAdd := false
for i := 0; i < len(p.MUpdateNotifyList); i++ {
if p.MUpdateNotifyList[i] == k {
isAdd = true
break
}
}
if !isAdd {
p.MUpdateNotifyList = append(p.MUpdateNotifyList, k)
}
needToUpdateDb = append(needToUpdateDb, k)
}
}
for i := 0; i < len(needToUpdateDb); i++ {
p.SaveDbDataByGroupId(needToUpdateDb[i])
}
}
func (p *ChampshipsManager) SaveDbDataByGroupId(GroupId int32) {
_, ok := p.MChampshipPlayerMap[GroupId]
if ok {
List := p.MChampshipPlayerMap[GroupId]
strr := []string{}
for i := 0; i < len(List); i++ {
Item := List[i]
unit := strconv.Itoa(int(Item.DwUin)) + "_" + strconv.Itoa(int(Item.IsPlayer)) + "_" + strconv.Itoa(int(Item.Score)) + "_" + strconv.Itoa(int(Item.IsGet)) + "_" + strconv.Itoa(int(Item.Times)) + "_" + strconv.Itoa(int(Item.CurChampshipsId)) + "_" + strconv.Itoa(int(Item.AIEnum))
strr = append(strr, unit)
}
data := strings.Join(strr, ";")
sqlStruct := &db.SqlChampionshipsStruct{}
sqlStruct.ChampshipsGroupID = GroupId
sqlStruct.GroupRankData = data
sqlStruct.CurChampshipsId = List[0].CurChampshipsId
db.FormatAllMemUpdateDb(sqlStruct, "t_championships_data", "ChampshipsGroupID")
}
}
func (p *ChampshipsManager) LoadDbDataByGroupId(ChampshipsId int32) {
sqlStr := "SELECT * FROM t_championships_data WHERE CurChampshipsId = ?"
sqlStruck := []db.SqlChampionshipsStruct{}
if err := db.SqlDb.Select(&sqlStruck, sqlStr, ChampshipsId); err != nil {
} else {
for m := 0; m < len(sqlStruck); m++ {
units := strings.Split(sqlStruck[m].GroupRankData, ";")
list := []*msg.ChampshipsPlayerInfo{}
for i := 0; i < len(units); i++ {
item := units[i]
strr := strings.Split(item, "_")
temp := &msg.ChampshipsPlayerInfo{}
dwuin, _ := strconv.Atoi(strr[0])
temp.DwUin = int32(dwuin)
IsPlayer, _ := strconv.Atoi(strr[1])
temp.IsPlayer = int32(IsPlayer)
Score, _ := strconv.Atoi(strr[2])
temp.Score = int32(Score)
IsGet, _ := strconv.Atoi(strr[3])
temp.IsGet = int32(IsGet)
Times, _ := strconv.Atoi(strr[4])
temp.Times = int32(Times)
CS, _ := strconv.Atoi(strr[5])
temp.CurChampshipsId = int32(CS)
AI, _ := strconv.Atoi(strr[6])
temp.AIEnum = int32(AI)
list = append(list, temp)
}
p.MChampshipPlayerMap[sqlStruck[m].ChampshipsGroupID] = list
}
}
}
func (p *ChampshipsManager) ReqChampshipAddScore(player *Player, buf []byte) {
req := &msg.ReqChampshipAddScore{}
proto.Unmarshal(buf, req)
res := &msg.ResChampshipAddScore{}
if p.MStatus == 0 {
res.ResultCode = MergeConst.Protocol_Champship_End
} else {
_, ok := p.MChampshipPlayerMap[req.GroupId]
if ok {
List := p.MChampshipPlayerMap[req.GroupId]
isHave := false
for i := 0; i < len(List); i++ {
if List[i].DwUin == player.M_DwUin {
List[i].Score = List[i].Score + req.AddScore
res.ResultCode = 0
isHave = true
break
}
}
sort.Slice(List, func(i, j int) bool { return List[i].Score > List[j].Score })
if !isHave {
res.ResultCode = MergeConst.Protocol_Champship_No_Join
} else {
res.GroupRankDataList = List
isAdd := false
for i := 0; i < len(p.MUpdateNotifyList); i++ {
if p.MUpdateNotifyList[i] == req.GroupId {
isAdd = true
break
}
}
if !isAdd {
p.MUpdateNotifyList = append(p.MUpdateNotifyList, req.GroupId)
}
p.SaveDbDataByGroupId(req.GroupId)
}
} else {
res.ResultCode = MergeConst.Protocol_Champship_No_Exsit
}
}
res.GroupId = req.GroupId
agent := player.GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResChampshipAddScore", data)
}
func (p *ChampshipsManager) ReqChampshipAddTime(player *Player, buf []byte) {
req := &msg.ReqChampshipAddTime{}
proto.Unmarshal(buf, req)
res := &msg.ResChampshipAddTime{}
if p.MStatus == 0 {
res.ResultCode = MergeConst.Protocol_Champship_End
} else {
_, ok := p.MChampshipPlayerMap[req.GroupId]
if ok {
List := p.MChampshipPlayerMap[req.GroupId]
isHave := false
for i := 0; i < len(List); i++ {
if List[i].DwUin == player.M_DwUin {
List[i].Times = List[i].Times + req.AddTimes
res.ResultCode = 0
isHave = true
break
}
}
sort.Slice(List, func(i, j int) bool { return List[i].Score > List[j].Score })
if !isHave {
res.ResultCode = MergeConst.Protocol_Champship_No_Join
} else {
res.GroupRankDataList = List
p.SaveDbDataByGroupId(req.GroupId)
}
} else {
res.ResultCode = MergeConst.Protocol_Champship_No_Exsit
}
}
res.GroupId = req.GroupId
agent := player.GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResChampshipAddTime", data)
}

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

@ -1,10 +1,12 @@
package game
import (
"encoding/gob"
"fmt"
"server/GoUtil"
mergeCluster "server/cluster"
"server/conf"
"server/game/mod/card"
"server/game/mod/msg"
"server/pkg/github.com/name5566/leaf/log"
)
@ -19,7 +21,7 @@ type FirendData struct {
}
func (f *FriendMgr) Init() {
gob.Register(card.CardInfo{})
f.key = FRIEND_MGR_KEY
f.data = &FirendData{
List: make(map[int][]*msg.Msg),

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

@ -9,7 +9,6 @@ import (
"server/GoUtil"
"server/MergeConst"
"server/conf"
"sort"
"strconv"
l "log"
@ -20,8 +19,6 @@ import (
"server/msg"
"time"
"math/rand"
"github.com/robfig/cron/v3"
"google.golang.org/protobuf/proto"
@ -73,14 +70,10 @@ type GameLogic struct {
Mdispatr *timer.Dispatcher
M_LimitActiveList []int
NotInitPlayer *Player
MReadyToRemoveList map[*Player]*timer.Timer
Mlogger *log.Logger
MloggerErr error
Version int32
M_SvrGlobal db.SqlSvrGlobalStruct
MChampshipsManager *NewChampshipsManager
MPlayerProfileManager *PlayerProfileManager
MOldPlayerCompensateMgr *OldPlayerCompensateMgr
MHttpManager *HttpManager
MLogManager *LogMgr
@ -260,19 +253,6 @@ func (ad *GameLogic) CreateNewPlayer(a gate.Agent, UserName string) {
}
// 重新绑定玩家和网络连接代理
func (ad *GameLogic) RebindPlayerAndAgent(a gate.Agent, player *Player) {
internal.AsignPlayerToAgents(a, player)
ad.M_Players[player.M_DwUin] = player
player.Reconnect()
player.SetAgent(a)
timer1 := ad.MReadyToRemoveList[player]
timer1.Disabled()
ad.Mdispatr.ChanTimer <- timer1
timer1.Stop()
delete(G_GameLogicPtr.MReadyToRemoveList, player)
}
func (ad *GameLogic) GetPlayerByAgent(gate gate.Agent) *Player {
p, ok := internal.Agents.Load(gate)
if ok {
@ -433,13 +413,9 @@ func G_getGameLogic() *GameLogic {
G_GameLogicPtr.Mdispatr = timer.NewDispatcher(10)
G_GameLogicPtr.InitServerInfo()
G_GameLogicPtr.M_Players = make(map[int32]*Player)
G_GameLogicPtr.MReadyToRemoveList = make(map[*Player]*timer.Timer)
G_GameLogicPtr.NotInitPlayer = new(Player)
G_GameLogicPtr.M_LimitActiveList = []int{}
G_GameLogicPtr.LoadSvrGlobalData() // 加载服务器全局数据
G_GameLogicPtr.CreateChamshipsMgr() // 创建锦标赛管理器
G_GameLogicPtr.CreateProfileManager() // 创建玩家档案管理器
G_GameLogicPtr.CreateCompensateMgr() // 创建老玩家补偿管理器
G_GameLogicPtr.OpenTimestampTick() // 开启时间戳计时器
G_GameLogicPtr.ReadAllConfigs() // 读取所有配置文件
G_GameLogicPtr.RegisterEvent() // 注册事件
@ -472,34 +448,6 @@ func (ad *GameLogic) InitServerInfo() {
ad.SeverInfo = ServerInfo
}
func (ad *GameLogic) DisorderLuaTable(length int, Cnt int) []int {
// length := len(tb)
indexList := []int{}
copy := []int{}
for i := 0; i < Cnt; i++ {
index := rand.Intn(length - i)
if len(indexList) == 0 {
indexList = append(indexList, index)
} else {
for n := 0; n < len(copy); n++ {
if index >= copy[n] {
index = index + 1
}
}
indexList = append(indexList, index)
}
copy = []int{}
for j := 0; j < len(indexList); j++ {
copy = append(copy, indexList[j])
}
sort.Slice(copy, func(i, j int) bool { return copy[i] < copy[j] })
}
contentList := indexList[:]
return contentList
}
func (ad *GameLogic) GetVersion() {
sqlStr := "SELECT * FROM t_gameserver WHERE id = ?"
sqlStruck := db.SqlVersionStruct{}
@ -549,32 +497,6 @@ func (ad *GameLogic) ClearData(args []interface{}) {
}
}
func (ad *GameLogic) FindOfflinePlayer(dwUin int32) *Player {
for k := range G_GameLogicPtr.MReadyToRemoveList {
if k.M_DwUin == dwUin {
return k
}
}
return nil
}
func (ad *GameLogic) InitPassportInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
st := &db.SqlLimitPassportStruct{}
st.CurFreeLv = 0
st.CurPayLv = 0
st.DwUin = player.M_DwUin
st.IsPay = 0
st.Star = 0
st.StartSvrTime = StartSvrTime
st.EndSvrTime = EndSvrTime
st.Status = 0
st.ActiveID = 0
st.ConfigActId = int32(ConfigActId)
activityID, _ := db.FormatAllMemInsertDb(st, "t_player_LimitPassport")
return int32(activityID)
}
func (ad *GameLogic) InitPromotionInsertDb(player *Player, StartSvrTime int32, EndSvrTime int32, ConfigActId int) int32 {
st := &db.SqlLimitPromotionStruct{}
st.DwUin = player.M_DwUin
@ -648,53 +570,10 @@ func (ad *GameLogic) LoadSvrGlobalData() {
}
}
func (ad *GameLogic) OpenNewLimitActivity(args []interface{}) {
go func() {
internal.Agents.Range(func(k, v interface{}) bool {
if v == ad.NotInitPlayer {
return true
}
player := v.(*Player)
notify := &msg.NotifyLimitedTimeActiveData{}
notify.MActiveList = []*msg.LimitedTimeActiveStruct{}
id := args[0].(int)
activityCfg := gamedata.GetConfigByName("Activity")
record := activityCfg.Index(id).(*gamedata.ActivityRecord)
act := &msg.LimitedTimeActiveStruct{}
act.StartSvrTime = args[1].(int32)
act.EndSvrTime = args[2].(int32)
act.Type = int32(record.Type)
if act.Type == 1 {
act.ActiveID = ad.InitPassportInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
}
if act.Type == 2 {
act.ActiveID = ad.InitPromotionInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
}
if act.Type == 3 {
act.ActiveID = ad.InitInfinitePackInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
}
if act.Type == 4 {
act.ActiveID = ad.Init7DayLoginInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
}
if act.Type == 5 {
act.ActiveID = ad.InitCardCollectInsertDb(player, act.StartSvrTime, act.EndSvrTime, id)
}
notify.MActiveList = append(notify.MActiveList, act)
data, _ := proto.Marshal(notify)
ad.PackResInfo(k.(gate.Agent), "NotifyLimitedTimeActiveData", data)
return true
})
}()
}
func (ad *GameLogic) RegisterEvent() {
GoUtil.RegisterEvent(MergeConst.Notify_Socket_Closed, ad.ClearData, nil)
GoUtil.RegisterEvent(MergeConst.Notify_Socket_Connect, ad.NewPlayerConnect, nil)
GoUtil.RegisterEvent(MergeConst.OpenNewLimitActivity, ad.OpenNewLimitActivity, nil)
}
func (ad *GameLogic) NewPlayerConnect(args []interface{}) {
@ -769,144 +648,9 @@ func (ad *GameLogic) CreateDailyLogFile() {
func (ad *GameLogic) RegisterNetWorkFunc() {
RegisterMsgProcessFunc("ReqPlayerEmitUnlockData", ReqPlayerEmitUnlockDatafunction)
RegisterMsgProcessFunc("UpdatePlayerEmitUnlockData", UpdatePlayerEmitUnlockDatafunction)
RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc)
RegisterMsgProcessFunc("UpdateChessColorData", UpdateChessColorDataFunc)
RegisterMsgProcessFunc("ReqChessColorData", ResChessColorDataFunc)
RegisterMsgProcessFunc("ReqUnlockingChestID", ReqUnlockingChestIDFunc)
RegisterMsgProcessFunc("ReqChestUnlockCD", ReqChestUnlockCDFunc)
RegisterMsgProcessFunc("ReqEmitMergeMap", ReqEmitMergeMapFunc)
RegisterMsgProcessFunc("ReqEmitCountMap", ReqResEmitCountMapFunc)
RegisterMsgProcessFunc("ReqEmitCDStartData", ReqEmitCDStartDataFunc)
RegisterMsgProcessFunc("UpdateEmitMergeMap", UpdateEmitMergeMapFunc)
RegisterMsgProcessFunc("UpdateEmitCountMap", UpdateEmitCountMapFunc)
RegisterMsgProcessFunc("ReqEmitSubCD", ReqEmitSubCDFunc)
RegisterMsgProcessFunc("ReqShopData", ReqShopDatafunc)
RegisterMsgProcessFunc("ReqShopBuy", ReqShopBuyFunc)
RegisterMsgProcessFunc("ReqRenewItemBuyCnt", ReqRenewItemBuyCntFunc)
RegisterMsgProcessFunc("ReqBriefEmailData", ReqBriefEmailDataFunc)
RegisterMsgProcessFunc("ReqDetailEmailData", ReqDetailEmailDataFunc)
RegisterMsgProcessFunc("ReqGetEmailReward", ReqGetEmailRewardFunc)
RegisterMsgProcessFunc("ReqDeleteEmail", ReqDeleteEmailFunc)
RegisterMsgProcessFunc("ReqLimitPassportDetail", ReqLimitPassportDetailFunc)
RegisterMsgProcessFunc("ReqPromotionDetail", ReqPromotionDetailFunc)
RegisterMsgProcessFunc("ReqInfinitePackDetail", ReqInfinitePackDetailFunc)
RegisterMsgProcessFunc("ReqGetLimitPassportReward", ReqGetLimitPassportRewardFunc)
RegisterMsgProcessFunc("ReqBuyLimitPromotionReward", ReqBuyLimitPromotionRewardFunc)
RegisterMsgProcessFunc("ReqBuyInfinitePack", ReqBuyInfinitePackFunc)
RegisterMsgProcessFunc("ReqPayPassport", ReqPayPassportFunc)
RegisterMsgProcessFunc("ReqActiveAddStar", ReqActiveAddStarFunc)
RegisterMsgProcessFunc("ReqOfflineReconnect", ReqOfflineReconnectFunc)
RegisterMsgProcessFunc("ReqOpenNewPig", ReqOpenNewPigFunc)
RegisterMsgProcessFunc("ReqPigDetailInfo", ReqPigDetailInfoFunc)
RegisterMsgProcessFunc("UpdateFinishOrderDiamond", UpdateFinishOrderDiamondFunc)
RegisterMsgProcessFunc("ReqGetPigReward", ReqGetPigRewardFunc)
RegisterMsgProcessFunc("ReqDropPigReward", ReqDropPigRewardFunc)
RegisterMsgProcessFunc("ReqLevelUpPackInfo", ReqLevelUpPackInfoFunc)
RegisterMsgProcessFunc("ReqBuyLevelUpPack", ReqBuyLevelUpPackFunc)
RegisterMsgProcessFunc("ReqGrowthFundInfo", ReqGrowthFundInfoFunc)
RegisterMsgProcessFunc("ReqBuyGrowthFund", ReqBuyGrowthFundFunc)
RegisterMsgProcessFunc("ReqGetGrowthFundWard", ReqGetGrowthFundWardFunc)
RegisterMsgProcessFunc("ReqRemoveAd", ReqRemoveAdFunc)
RegisterMsgProcessFunc("ReqSupremeGiftInfo", ReqSupremeGiftInfoFunc)
RegisterMsgProcessFunc("ReqBuySupremeGift", ReqBuySupremeGiftFunc)
RegisterMsgProcessFunc("ReqIllustratedInfo", ReqIllustratedInfoFunc)
RegisterMsgProcessFunc("ReqGetIllustrateItemReward", ReqGetIllustrateItemRewardFunc)
RegisterMsgProcessFunc("UpdateIllustrateItem", UpdateIllustrateItemFunc)
RegisterMsgProcessFunc("ReqCardCollectDetail", ReqCardCollectDetailFunc)
RegisterMsgProcessFunc("ReqGetCardAlbumReward", ReqGetCardAlbumRewardFunc)
RegisterMsgProcessFunc("ReqGetAllCardReward", ReqGetAllCardRewardFunc)
RegisterMsgProcessFunc("ReqAddCard", ReqAddCardFunc)
RegisterMsgProcessFunc("ReqUnpackCard", ReqUnpackCardFunc)
RegisterMsgProcessFunc("ReqAddMasterCard", ReqAddMasterCardFunc)
RegisterMsgProcessFunc("ReqUseMasterCard", ReqUseMasterCardFunc)
RegisterMsgProcessFunc("ReqBuyStickerItem", ReqBuyStickerItemFunc)
RegisterMsgProcessFunc("ReqGetDonateCard", ReqGetDonateCardFunc)
RegisterMsgProcessFunc("ReqReceiptCard", ReqReceiptCardFunc)
RegisterMsgProcessFunc("ReqGetExchangeCard", ReqGetExchangeCardFunc)
RegisterMsgProcessFunc("ReqRefuseExchange", ReqRefuseExchangeFunc)
RegisterMsgProcessFunc("ReqRequestCard", ReqRequestCardFunc)
RegisterMsgProcessFunc("ReqCompleteRequestCard", ReqCompleteRequestCardFunc)
RegisterMsgProcessFunc("ReqRefuseRequestCard", ReqRefuseRequestCardFunc)
RegisterMsgProcessFunc("ReqGetRequestCard", ReqGetRequestCardFunc)
RegisterMsgProcessFunc("ReqDailyTaskData", ResDailyTaskDataFunc)
RegisterMsgProcessFunc("UpdateDailyTaskData", UpdateDailyTaskDataFunc)
RegisterMsgProcessFunc("RenewDailyTaskData", RenewDailyTaskDataFunc)
RegisterMsgProcessFunc("RenewWeekyActiveData", RenewWeekyActiveDataFunc)
RegisterMsgProcessFunc("ReqMileStoneData", ResMileStoneDataFunc)
RegisterMsgProcessFunc("UpdateMileStoneData", UpdateMileStoneDataFunc)
RegisterMsgProcessFunc("RenewMileStoneData", RenewMileStoneDataFunc)
RegisterMsgProcessFunc("ReqChampshipData", ReqChampshipDataFunc)
RegisterMsgProcessFunc("ReqChampshipAddScore", ReqChampshipAddScoreFunc)
RegisterMsgProcessFunc("ReqChampshipAddTime", ReqChampshipAddTimeFunc)
RegisterMsgProcessFunc("ReqPlayerChampshipData", ReqPlayerChampshipData)
RegisterMsgProcessFunc("ReqAdPackData", ReqAdPackDataFunc)
RegisterMsgProcessFunc("ReqWatchAdPack", ReqWatchAdPackFunc)
RegisterMsgProcessFunc("ReqPlayerSingleData", ReqPlayerSingleDataFunc)
RegisterMsgProcessFunc("ReqOpenNewbiePack", ReqOpenNewbiePackFunc)
RegisterMsgProcessFunc("ReqBuyNewbiePack", ReqBuyNewbiePackFunc)
RegisterMsgProcessFunc("ReqAddNoAdCnt", ReqAddNoAdCntFunc)
RegisterMsgProcessFunc("ReqAddWatchAdCnt", ReqAddWatchAdCntFunc)
RegisterMsgProcessFunc("ReqPlayerPayData", ReqPlayerPayDataFunc)
RegisterMsgProcessFunc("ReqAddPay", ReqAddPayFunc)
RegisterMsgProcessFunc("ReqFriendData", ReqFriendDataFunc)
RegisterMsgProcessFunc("ReqWillPlayerDetail", ReqWillPlayerDetailFunc)
RegisterMsgProcessFunc("ReqAddFriendData", ReqAddFriendDataFunc)
RegisterMsgProcessFunc("ReqAllAddFriendInfo", ReqAllAddFriendInfoFunc)
RegisterMsgProcessFunc("ReqAgreeFriendReq", ReqAgreeFriendReqFunc)
RegisterMsgProcessFunc("ReqRefuseFriendReq", ReqRefuseFriendReqFunc)
RegisterMsgProcessFunc("ReqDeleteFriend", ReqDeleteFriendFunc)
RegisterMsgProcessFunc("ReqAutoFBAddFriend", ReqAutoFBAddFriend)
RegisterMsgProcessFunc("ReqRecommendFriendList", ReqRecommendFriendList)
RegisterMsgProcessFunc("ReqFriendTreasureData", ReqFriendTreasureData)
RegisterMsgProcessFunc("ReqUpdateFriendStar", ReqUpdateFriendStar)
RegisterMsgProcessFunc("ReqPlayerProfileData", ReqPlayerProfileDataFunc)
RegisterMsgProcessFunc("ReqUpdatePlayerProfile", ReqUpdatePlayerProfileFunc)
RegisterMsgProcessFunc("ReqPlayerBriefProfileData", ReqPlayerBriefProfileDataFunc)
RegisterMsgProcessFunc("ReqFriendEventData", ReqFriendEventDataFunc)
RegisterMsgProcessFunc("ReqUpdateFBPicURL", ReqUpdateFBPicURLFunc)
RegisterMsgProcessFunc("ReqPlayerPetData", ReqPlayerPetData)
RegisterMsgProcessFunc("ReqUpdatePetProfile", ReqUpdatePetProfile)
RegisterMsgProcessFunc("ReqPetHomeData", ReqPetHomeData)
RegisterMsgProcessFunc("ReqOpenOtherPetHome", ReqOpenOtherPetHome)
RegisterMsgProcessFunc("ReqOpenSelfPet", ReqOpenSelfPet)
RegisterMsgProcessFunc("ReqPetHomeInterActST", ReqPetHomeInterActST)
RegisterMsgProcessFunc("ReqShiftVisitPet", ReqShiftVisitPet)
RegisterMsgProcessFunc("ReqCallBackPet", ReqCallBackPet)
RegisterMsgProcessFunc("ReqUnlockDecorate", ReqUnlockDecorate)
RegisterMsgProcessFunc("ReqSaveSelectDecorate", ReqSaveSelectDecorate)
// 玩家
RegisterMsgProcessFunc("ReqUserInfo", ReqUserInfo)
@ -917,6 +661,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
RegisterMsgProcessFunc("ReqKv", ReqKv) // 保存客户端数据
// 棋盘
RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc) //设置能量倍数
RegisterMsgProcessFunc("ReqChessEx", ReqChessEx) // 转换棋子
@ -1032,80 +777,6 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
}
func (ad *GameLogic) ResPlayerEmitUnlockData(param []interface{}) {
data := (param[0].(*Player).GetIFGameData("PlayerEmitUnlockData"))
data.(*PlayerEmitUnlockData).ResPlayerEmitUnlockData(param[0].(*Player))
}
func (ad *GameLogic) broadcastInfoAllPlayer(Func string, data []byte) {
internal.Agents.Range(func(k, v interface{}) bool {
if v == ad.NotInitPlayer {
return true
}
ad.PackResInfo(k.(gate.Agent), Func, data)
return true
})
}
func (ad *GameLogic) JudgeIsActivity(c *cron.Cron, Id int) int {
activityCfg := gamedata.GetConfigByName("Activity")
record := activityCfg.Index(Id).(*gamedata.ActivityRecord)
timeStamp := time.Now().Unix()
t := time.Unix(timeStamp, 0).Local()
nianchu := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second()) - int64((t.YearDay()-1)*3600*24)
key := ad.m_CronEntryIDs[record.Id]
Schedule := c.Entry(key.StartCronID).Schedule
Next := Schedule.Next(time.Unix(nianchu, 0))
if timeStamp >= Next.Unix() && timeStamp <= Next.Unix()+int64(record.Duration) {
return 2
} else {
if timeStamp < Next.Unix() {
return 1
}
}
return 3
}
func (ad *GameLogic) CalcDeltaEndTime(c *cron.Cron, Id int) int32 {
activityCfg := gamedata.GetConfigByName("Activity")
record := activityCfg.Index(Id).(*gamedata.ActivityRecord)
timeStamp := time.Now().Unix()
t := time.Unix(timeStamp, 0).Local()
nianchu := timeStamp - (int64)(t.Hour()*3600+t.Minute()*60+t.Second()) - int64((t.YearDay()-1)*3600*24)
key := ad.m_CronEntryIDs[record.Id]
Schedule := c.Entry(key.StartCronID).Schedule
Next := Schedule.Next(time.Unix(nianchu, 0))
return int32(Next.Unix() + int64(record.Duration) - timeStamp)
}
func (ad *GameLogic) GetActiveParamById(Id int) *LimitActPeriod {
v, ok := ad.m_CronEntryIDs[Id]
if ok {
return v
}
return nil
}
func (ad *GameLogic) CreateProfileManager() {
ad.MPlayerProfileManager = new(PlayerProfileManager)
ad.MPlayerProfileManager.InitManager()
}
func (ad *GameLogic) CreateChamshipsMgr() {
ad.MChampshipsManager = new(NewChampshipsManager)
ad.MChampshipsManager.InitManager()
}
func (ad *GameLogic) CreateCompensateMgr() {
ad.MOldPlayerCompensateMgr = new(OldPlayerCompensateMgr)
ad.MOldPlayerCompensateMgr.InitManager()
}
func (ad *GameLogic) CreateHttpManager() {
go func() {

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

@ -102,9 +102,11 @@ func ReqGmCommand(args []interface{}) error {
G_GameLogicPtr.ChampshipMgrSend(&MsgMod.Msg{
Type: MsgMod.HANDLE_TYPE_CHAMPSHIP_ZERO,
})
case "debug":
case "resetEmitOrder":
OrderMod := player.PlayMod.getOrderMod()
OrderMod.EimtOrder = make(map[string]struct{})
HandbookMod := player.PlayMod.getHandbookMod()
delete(HandbookMod.BookList, 125)
}
player.PlayMod.save()
return nil

19
src/server/game/HttpSvr.go
View File

@ -4,11 +4,8 @@ import (
"fmt"
"net/http"
"server/conf"
"server/msg"
// "server/msg"
"encoding/json"
"strconv"
"github.com/gorilla/mux"
)
@ -36,23 +33,7 @@ func (p *HttpManager) InitPlayerProfileInfo() {
}
func (p *HttpManager) GetPlayerProfileInfo(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
Id, ok := vars["Id"]
if ok {
Uin, _ := strconv.Atoi(Id)
data := G_GameLogicPtr.MPlayerProfileManager.HttpReqPlayerBriefProfileData(int32(Uin))
test := []*msg.ResPlayerBriefProfileData{data, data}
bytes, _ := json.Marshal(test)
v := []*msg.ResPlayerBriefProfileData{}
json.Unmarshal(bytes, &v)
fmt.Println("bytes Length:" + strconv.Itoa(len(v)))
fmt.Println("bytes Length:" + strconv.Itoa(len(v)))
w.Write(bytes)
}
}
func (p *HttpManager) AddFriend(w http.ResponseWriter, r *http.Request) {

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

@ -10,4 +10,5 @@ type PlayerSimpleData struct {
Login int64
Loginout int64
FaceBook string
FaceBookPic string
}

1314
src/server/game/NewChampshipsManager.go
View File

File diff suppressed because it is too large Load Diff

113
src/server/game/OldPlayerCompensateMgr.go
View File

@ -1,113 +0,0 @@
package game
import (
"fmt"
"math"
"server/db"
"strconv"
"strings"
"time"
)
type OldPlayerCompensateMgr struct {
MSqlCompensateStruct map[string]*db.SqlCompensateStruct
}
func (p *OldPlayerCompensateMgr) SuccessSendEmail(username string) bool {
emailst, ok := p.MSqlCompensateStruct[username]
if ok {
emailst.IsSendEmail = 1
db.FormatAllMemUpdateDb(emailst, "t_player_compensate_Data", "auto_id")
return true
}
return false
}
func (p *OldPlayerCompensateMgr) SendEmailToDb(username string, dwUin int32) bool {
emailst, ok := p.MSqlCompensateStruct[username]
if ok {
if emailst.IsSendEmail == 1 {
return false
} else {
sqlSt := &db.SqlEmailStruct{}
sqlSt.DwUin = dwUin
sqlSt.Content = `Welcome back to our game!
Here comes your refund for your scene progress and payment in test version!
Have fun in new version!`
sqlSt.CurrencyCount = 0
sqlSt.CurrencyInfo = ""
sqlSt.RecvTime = 0
sqlSt.Title = "Test Players' Refund"
sqlSt.Sender = "System"
sqlSt.ItemCount = 0
sqlSt.ItemInfo = ""
sqlSt.SendTime = int32(time.Now().Unix())
sqlSt.Status = 0
sqlSt.Type = 1
sqlSt.RewardId = ""
sqlSt.RewardCount = ""
sqlSt.LinkUrl = ""
strarr := []string{}
if emailst.DecorationCnt-5 > 0 {
SceneDiamond := (emailst.DecorationCnt-5)*10 + 25
temp := fmt.Sprintf("Diamond|%d", SceneDiamond)
strarr = append(strarr, temp)
}
f, err := strconv.ParseFloat(emailst.ChargeCnt, 64)
var ChargeDiamond float64 = 0
if err == nil {
ChargeDiamond = f * 1.5 * 75
}
if ChargeDiamond > 0 {
cd := int32(math.Ceil(ChargeDiamond))
remain := cd % 10
if remain != 0 && remain != 5 {
if remain < 5 {
cd = cd - remain + 5
} else {
cd = cd - remain + 10
}
}
temp := fmt.Sprintf("Diamond|%d", cd)
strarr = append(strarr, temp)
}
sqlSt.RewardType = strings.Join(strarr, "_")
insertId, err1 := db.FormatAllMemInsertDb(sqlSt, "system_mail_info")
if err1 == nil {
p.SuccessSendEmail(username)
fmt.Sprintln("Success Intert Mail:" + strconv.Itoa(int(insertId)))
}
return true
}
}
return false
}
func (p *OldPlayerCompensateMgr) LoadData() {
sqlStr := "SELECT * FROM t_player_compensate_Data"
sqlStrucks := []db.SqlCompensateStruct{}
p.MSqlCompensateStruct = make(map[string]*db.SqlCompensateStruct)
if err := db.SqlDb.Select(&sqlStrucks, sqlStr); err != nil {
return
} else {
}
for i := 0; i < len(sqlStrucks); i++ {
p.MSqlCompensateStruct[sqlStrucks[i].DeviceId] = &sqlStrucks[i]
}
}
func (p *OldPlayerCompensateMgr) InitManager() {
p.LoadData()
}

65
src/server/game/Player.go
View File

@ -44,7 +44,6 @@ type Player struct {
PlayMod PlayerMod
M_DwUin int32
agent gate.Agent
PAMgr *PlayerActiveMgr
lock sync.Mutex
stopSignal chan bool
Msg map[string]PlayerMsg
@ -197,27 +196,6 @@ func (p *Player) InitPlayer(UserName string) error {
p.playerdataIF[PLAYER_BASE_DATA] = Base
p.M_DwUin = Base.Data.DwUin
// 发射器解锁数据
unlock := &PlayerEmitUnlockData{PlayerData: NewPlayerData("PlayerEmitUnlockData", p)}
ok = unlock.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerEmitUnlockData failed:", UserName)
return errors.New("load PlayerEmitUnlockData failed")
}
p.playerdata["PlayerEmitUnlockData"] = unlock
p.playerdataIF["PlayerEmitUnlockData"] = unlock
// 发射器数据
Detail := &PlayerEmitDetailData{PlayerData: NewPlayerData("PlayerEmitDetailData", p)}
ok = Detail.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerEmitDetailData failed! username: %s", UserName)
return errors.New("load PlayerEmitDetailData failed")
}
p.playerdata["PlayerEmitDetailData"] = Detail
p.playerdataIF["PlayerEmitDetailData"] = Detail
G_getGameLogic().Mlogger.Debug("load PlayerEmitDetailData:", Base.Data.DwUin)
// 棋盘数据
Chess := &PlayerChessData{PlayerData: NewPlayerData("PlayerChessData", p)}
ok = Chess.LoadDataFromDB(Base.Data.DwUin)
@ -228,46 +206,6 @@ func (p *Player) InitPlayer(UserName string) error {
p.playerdata["PlayerChessData"] = Chess
p.playerdataIF["PlayerChessData"] = Chess
// 玩家解锁宝箱数据
Chest := &PlayerUnlockingChestData{PlayerData: NewPlayerData("PlayerUnlockingChestData", p)}
ok = Chest.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerUnlockingChestData failed:", UserName)
return errors.New("load PlayerUnlockingChestData failed")
}
p.playerdata["PlayerUnlockingChestData"] = Chest
p.playerdataIF["PlayerUnlockingChestData"] = Chest
// 玩家解锁宝箱数据
Single := &PlayerSingleData{PlayerData: NewPlayerData("PlayerSingleData", p)}
ok = Single.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerSingleData failed:", UserName)
return errors.New("load PlayerSingleData failed")
}
p.playerdata["PlayerSingleData"] = Single
p.playerdataIF["PlayerSingleData"] = Single
// 玩家订单数据
Charge := &PlayerChargeData{PlayerData: NewPlayerData("PlayerChargeData", p)}
ok = Charge.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerChargeData failed:", UserName)
return errors.New("load PlayerChargeData failed")
}
p.playerdata["PlayerChargeData"] = Charge
p.playerdataIF["PlayerChargeData"] = Charge
// 玩家好友数据
friendEvt := &PlayerFriendEventData{PlayerData: NewPlayerData("PlayerFriendEventData", p)}
ok = friendEvt.LoadDataFromDB(Base.Data.DwUin)
if !ok {
log.Debug("load PlayerFriendEventData failed:", UserName)
return errors.New("load PlayerFriendEventData failed")
}
p.playerdata["PlayerFriendEventData"] = friendEvt
p.playerdataIF["PlayerFriendEventData"] = friendEvt
// 玩家模块数据
modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
ok = modData.LoadDataFromDB(Base.Data.DwUin)
@ -283,8 +221,6 @@ func (p *Player) InitPlayer(UserName string) error {
p.PlayMod.mod_list = modData.ModList
p.PlayMod.is_update = IsUpdate
p.PAMgr = new(PlayerActiveMgr)
p.PAMgr.InitActiveMgr(p)
go func() { // 处理数据回调
var cb *timer.Timer
for {
@ -761,6 +697,7 @@ func (p *Player) UpdateUserInfo() {
simple.Login = int64(Base.Data.LoginTime)
simple.Loginout = int64(Base.Data.LogoutTime)
simple.FaceBook = Base.Data.FaceBookId
simple.FaceBookPic = p.PlayMod.getBaseMod().FacebookUrl
value, _ := json.Marshal(simple)
IdStr := strconv.Itoa(int(p.M_DwUin))
db.RedisSetKey(IdStr, string(value), 0)

2232
src/server/game/PlayerActiveData.go
View File

File diff suppressed because it is too large Load Diff

208
src/server/game/PlayerActiveManager.go
View File

@ -1,208 +0,0 @@
package game
import (
"server/db"
"server/gamedata"
"server/msg"
"google.golang.org/protobuf/proto"
)
type PlayerActiveMgr struct {
M_Player *Player
}
func (p *PlayerActiveMgr) OpenNewLimitActivity(args []interface{}) {
notify := &msg.NotifyLimitedTimeActiveData{}
notify.MActiveList = []*msg.LimitedTimeActiveStruct{}
id := args[0].(int)
activityCfg := gamedata.GetConfigByName("Activity")
record := activityCfg.Index(id).(*gamedata.ActivityRecord)
act := &msg.LimitedTimeActiveStruct{}
act.StartSvrTime = args[1].(int32)
act.EndSvrTime = args[2].(int32)
act.Type = int32(record.Type)
ActiveID := args[3].(int32)
if act.Type == 1 {
if ActiveID == int32(0) {
act.ActiveID = G_GameLogicPtr.InitPassportInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
} else {
act.ActiveID = ActiveID
}
actor := &PlayerPassportData{PlayerActiveData: NewActiveData("PlayerPassportData", p.M_Player)}
ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["PlayerPassportData"] = actor
p.M_Player.playerdataIF["PlayerPassportData"] = actor
}
}
if act.Type == 2 {
if ActiveID == int32(0) {
act.ActiveID = G_GameLogicPtr.InitPromotionInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
} else {
act.ActiveID = ActiveID
}
actor := &PlayerPromotionData{PlayerActiveData: NewActiveData("PlayerPromotionData", p.M_Player)}
ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["PlayerPromotionData"] = actor
p.M_Player.playerdataIF["PlayerPromotionData"] = actor
}
}
if act.Type == 3 {
if ActiveID == int32(0) {
act.ActiveID = G_GameLogicPtr.InitInfinitePackInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
} else {
act.ActiveID = ActiveID
}
actor := &PlayerInfinitePackData{PlayerActiveData: NewActiveData("PlayerInfinitePackData", p.M_Player)}
ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["PlayerInfinitePackData"] = actor
p.M_Player.playerdataIF["PlayerInfinitePackData"] = actor
}
}
if act.Type == 4 {
if ActiveID == int32(0) {
act.ActiveID = G_GameLogicPtr.Init7DayLoginInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
} else {
act.ActiveID = ActiveID
}
actor := &Player7DayLoginData{PlayerActiveData: NewActiveData("Player7DayLoginData", p.M_Player)}
ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["Player7DayLoginData"] = actor
p.M_Player.playerdataIF["Player7DayLoginData"] = actor
}
}
if act.Type == 5 {
if ActiveID == int32(0) {
act.ActiveID = G_GameLogicPtr.InitCardCollectInsertDb(p.M_Player, act.StartSvrTime, act.EndSvrTime, id)
} else {
act.ActiveID = ActiveID
}
actor := &PlayerCardCollectData{PlayerActiveData: NewActiveData("PlayerCardCollectData", p.M_Player)}
ok := actor.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["PlayerCardCollectData"] = actor
p.M_Player.playerdataIF["PlayerCardCollectData"] = actor
}
}
notify.MActiveList = append(notify.MActiveList, act)
data, _ := proto.Marshal(notify)
agent := p.M_Player.GetAgentByPlayer()
G_GameLogicPtr.PackResInfo(agent, "NotifyLimitedTimeActiveData", data)
}
func NewActiveData(dataName string, player *Player) *PlayerActiveData {
act := &PlayerActiveData{
PlayerData: NewPlayerData(dataName, player),
MisDirty: false,
}
return act
}
func (p *PlayerActiveMgr) InitActiveMgr(player *Player) {
p.M_Player = player
activityCfg := gamedata.GetConfigByName("Activity")
map1 := make(map[int]string)
map1[1] = "t_player_LimitPassport"
map1[2] = "t_player_LimitPromotion"
map1[3] = "t_player_LimitInfinitePack"
map1[4] = "t_player_Limit7DayLogin"
map1[5] = "t_player_card_data"
for i := 0; i < len(G_GameLogicPtr.M_LimitActiveList); i++ {
Id := G_GameLogicPtr.M_LimitActiveList[i]
record := activityCfg.Index(Id).(*gamedata.ActivityRecord)
sqlStr := "Select * From " + map1[record.Type] + " Where ConfigActId = ? And dwUin = ?"
if record.Type == 1 {
struct1 := []db.SqlLimitPassportStruct{}
st := G_GameLogicPtr.GetActiveParamById(Id)
Start := st.StartTime
EndTime := st.EndTime
if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
if len(struct1) == 0 {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
}
}
}
if record.Type == 2 {
struct1 := []db.SqlLimitPromotionStruct{}
st := G_GameLogicPtr.GetActiveParamById(Id)
Start := st.StartTime
EndTime := st.EndTime
if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
if len(struct1) == 0 {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
}
}
}
if record.Type == 3 {
struct1 := []db.SqlLimitInfinitePackStruct{}
st := G_GameLogicPtr.GetActiveParamById(Id)
Start := st.StartTime
EndTime := st.EndTime
if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
if len(struct1) == 0 {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
}
}
}
if record.Type == 4 {
struct1 := []db.SqlSevenDayLoginStruct{}
st := G_GameLogicPtr.GetActiveParamById(Id)
Start := st.StartTime
EndTime := st.EndTime
if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
if len(struct1) == 0 {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
}
}
}
if record.Type == 5 {
struct1 := []db.SqlCardCollectStruct{}
st := G_GameLogicPtr.GetActiveParamById(Id)
Start := st.StartTime
EndTime := st.EndTime
if err := db.SqlDb.Select(&struct1, sqlStr, Id, player.M_DwUin); err != nil {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
if len(struct1) == 0 {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, int32(0)})
} else {
p.OpenNewLimitActivity([]interface{}{Id, Start, EndTime, struct1[0].ActiveID})
}
}
}
}
}

7
src/server/game/PlayerBaseMod.go
View File

@ -141,7 +141,7 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
p.Data.FaceBookId = sqlStruck.FaceBookId
p.McronSave = cron.New()
p.Reconnect(false)
p.AddCompensateEmail()
p.KeyValueData = make(map[int]string)
if len(sqlStruck1.ModData) > 0 {
var buf bytes.Buffer
@ -189,10 +189,6 @@ func (p *PlayerBaseData) Reconnect(b bool) {
GoUtil.RegisterEvent(MergeConst.Notify_Daily_Renew, p.Notify_Daily_Renew, p)
}
func (p *PlayerBaseData) AddCompensateEmail() {
G_GameLogicPtr.MOldPlayerCompensateMgr.SendEmailToDb(p.Data.UserName, p.Data.DwUin)
}
func (p *PlayerBaseData) SetChampshipID(ChampshipsGroupID int32, isNotify bool) {
p.Data.LastChampGroupID = p.Data.ChampshipsGroupID
p.Data.ChampshipsGroupID = ChampshipsGroupID
@ -751,7 +747,6 @@ func (p *PlayerBaseData) GetDataByUid(Uid interface{}) bool {
p.Data.FaceBookId = sqlStruck.FaceBookId
p.McronSave = cron.New()
p.Reconnect(false)
p.AddCompensateEmail()
return true
}

121
src/server/game/PlayerChessMod.go
View File

@ -5,14 +5,11 @@ import (
"math"
"server/GoUtil"
mergeDataCfg "server/conf/mergeData"
"server/db"
"server/game/mod/item"
"server/game/mod/quest"
"server/msg"
"server/pkg/github.com/name5566/leaf/log"
"sort"
"strconv"
"strings"
"google.golang.org/protobuf/proto"
)
@ -24,51 +21,7 @@ type PlayerChessData struct {
}
func (p *PlayerChessData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_chess_data WHERE dwUin = ?"
sqlStruck := db.SqlChessStruct{}
p.Data.MChessData = make(map[string]int32)
p.ColorData.MChessColorData = make(map[string]int32)
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
if sqlStruck.MChessData != "" {
arr := strings.Split(sqlStruck.MChessData, "_")
for i := 0; i < len(arr); i++ {
ss := strings.Split(arr[i], ",")
id, err := strconv.ParseInt(ss[1], 10, 32)
key := ss[0]
if err != nil {
panic(err)
}
p.Data.MChessData[key] = int32(id)
}
}
if sqlStruck.MChessColorData != "" {
arr := strings.Split(sqlStruck.MChessColorData, "_")
for i := 0; i < len(arr); i++ {
ss := strings.Split(arr[i], ",")
id, err := strconv.ParseInt(ss[1], 10, 32)
key := ss[0]
if err != nil {
panic(err)
}
p.ColorData.MChessColorData[key] = int32(id)
}
}
p.Data.DwUin = dwUin.(int32)
p.Reconnect(false)
return true
}
@ -76,58 +29,8 @@ func (p *PlayerChessData) Reconnect(b bool) {
}
func (p *PlayerChessData) SetValueByKey(k string) {
if k != "" {
p.Data.MChessData[k] = p.Data.MChessData[k] + 1
}
}
func (p *PlayerChessData) GetValueByKey(k string) int32 {
v, ok := p.Data.MChessData[k]
if ok {
return v
}
return -1
}
func (p *PlayerChessData) GetKeyByEmitID(EmitID int32) string {
for k := range p.Data.MChessData {
units := strings.Split(k, "@")
if len(units) >= 4 {
n, _ := strconv.Atoi(units[3])
if EmitID == int32(n) {
return k
}
}
}
return ""
}
func (p *PlayerChessData) SaveDataFromDB(Key interface{}) bool {
var strarr []string
var strarr1 []string
for k, v := range p.Data.MChessData {
str := fmt.Sprintf("%s,%d", k, v)
strarr = append(strarr, str)
}
str_concat := strings.Join(strarr, "_")
for k, v := range p.ColorData.MChessColorData {
str := fmt.Sprintf("%s,%d", k, v)
strarr1 = append(strarr1, str)
}
str_concat1 := strings.Join(strarr1, "_")
sqlStruck := db.SqlChessStruct{}
sqlStruck.DwUin = p.M_Player.M_DwUin
sqlStruck.MChessData = str_concat
sqlStruck.MChessColorData = str_concat1
if p.IsHaveDataDb {
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_chess_data", "dwUin")
} else {
db.FormatAllMemInsertDb(&sqlStruck, "t_player_chess_data")
}
p.IsHaveDataDb = true
return true
}
@ -319,30 +222,6 @@ func (p *PlayerChessData) HandleChess(handle_list []*msg.ChessHandle) error {
return nil
}
func (p *PlayerChessData) UpdateChessColorData(buf []byte) {
update := &msg.UpdateChessColorData{}
err := proto.Unmarshal(buf, update)
if err != nil {
fmt.Println("unmarshal failed, err:", err)
return
}
p.ColorData.MChessColorData = update.MChessColorData
}
func (p *PlayerChessData) GetChestKeyByValue(id int32) string {
for k, v := range p.Data.MChessData {
if id == v {
return k
}
}
return ""
}
func (p *PlayerChessData) ClearData() bool {
p.SaveDataFromDB("")
return true
}
//********************************************************************************
// api

2103
src/server/game/PlayerDataModule.go
View File

File diff suppressed because it is too large Load Diff

284
src/server/game/PlayerEmailData.go
View File

@ -1,284 +0,0 @@
package game
import (
"fmt"
"server/MergeConst"
"server/db"
"server/msg"
"sort"
"time"
"github.com/robfig/cron/v3"
"google.golang.org/protobuf/proto"
)
type PlayerEmailData struct {
*PlayerData
Data msg.ResBriefEmailData
SqlStructs []db.SqlEmailStruct
ZeroCronID cron.EntryID
WeekCronID cron.EntryID
Mcron *cron.Cron
}
func (p *PlayerEmailData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM system_mail_info WHERE dwUin = ?"
if err := db.SqlDb.Select(&p.SqlStructs, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
CurTime := int32(time.Now().Unix())
deleteList := []int{}
deleteDbList := []int32{}
for i := 0; i < len(p.SqlStructs); i++ {
item := p.SqlStructs[i]
if item.RecvTime > 0 && item.Status == 1 && CurTime-item.RecvTime >= MergeConst.G_Clear_Read_Email_Limit {
deleteList = append(deleteList, i)
deleteDbList = append(deleteDbList, item.EmailId)
}
}
tempList := []db.SqlEmailStruct{}
startIndex := 0
for i := 0; i < len(deleteList); i++ {
curIndex := deleteList[i]
if curIndex == startIndex {
startIndex = startIndex + 1
continue
}
tempList = append(tempList, p.SqlStructs[startIndex:curIndex]...)
startIndex = curIndex + 1
}
if startIndex <= len(p.SqlStructs)-1 {
tempList = append(tempList, p.SqlStructs[startIndex:]...)
}
p.SqlStructs = tempList
p.DeleteOutlineMail(deleteDbList)
sort.Slice(p.SqlStructs, func(i, j int) bool {
if p.SqlStructs[i].Status == p.SqlStructs[j].Status {
if p.SqlStructs[i].Type == p.SqlStructs[j].Type {
return p.SqlStructs[i].SendTime > p.SqlStructs[j].SendTime
} else {
return p.SqlStructs[i].Type > p.SqlStructs[j].Type
}
} else {
return p.SqlStructs[i].Status < p.SqlStructs[j].Status
}
})
for i := 0; i < len(p.SqlStructs); i++ {
item := p.SqlStructs[i]
if item.Status == 0 {
p.SqlStructs[i].Status = 1
db.FormatAllMemUpdateDb(&p.SqlStructs[i], "system_mail_info", "mail_id")
}
}
p.Mcron = cron.New()
p.Reconnect(false)
return true
}
func (p *PlayerEmailData) Reconnect(b bool) {
p.ZeroCronID, _ = p.Mcron.AddFunc("@every 5s", func() {
p.IntervalGetUnsendMails()
})
p.Mcron.Start()
}
func (p *PlayerEmailData) DeleteOutlineMail(deleteList []int32) {
sqlStr := "DELETE FROM system_mail_info WHERE mail_id = ?"
for i := 0; i < len(deleteList); i++ {
result, err := db.SqlDb.Exec(sqlStr, deleteList[i])
if err != nil {
fmt.Printf("exec failed, err:%v\n", err)
return
}
affectedRows, err := result.RowsAffected()
if err != nil {
fmt.Printf("get affected failed, err:%v\n", err)
return
}
fmt.Printf("delete data success, affected rows:%d\n", affectedRows)
}
}
func (p *PlayerEmailData) IntervalGetUnsendMails() {
sqlStr := "SELECT * FROM system_mail_info WHERE dwUin = ? AND state = ?"
SqlStructs := []db.SqlEmailStruct{}
if err := db.SqlDb.Select(&SqlStructs, sqlStr, p.M_Player.M_DwUin, 0); err != nil {
} else {
for i := 0; i < len(SqlStructs); i++ {
SqlStructs[i].Status = 1
db.FormatAllMemUpdateDb(&SqlStructs[i], "system_mail_info", "mail_id")
}
if len(SqlStructs) > 0 {
p.NotifyNewBriefEmailData(SqlStructs)
}
}
}
func (p *PlayerEmailData) NotifyNewBriefEmailData(SqlStructs []db.SqlEmailStruct) {
notify := &msg.NotifyNewBriefEmailData{}
notify.DwUin = p.M_Player.M_DwUin
notify.MEmailList = []*msg.BriefEmailStruct{}
p.SqlStructs = append(p.SqlStructs, SqlStructs...)
for i := 0; i < len(SqlStructs); i++ {
st := &msg.BriefEmailStruct{}
st.EmailId = SqlStructs[i].EmailId
st.Sender = SqlStructs[i].Sender
st.Title = SqlStructs[i].Title
st.CurrencyCount = SqlStructs[i].CurrencyCount
st.CurrencyInfo = SqlStructs[i].CurrencyInfo
st.ItemCount = SqlStructs[i].ItemCount
st.ItemInfo = SqlStructs[i].ItemInfo
st.SendTime = SqlStructs[i].SendTime
st.Status = 1
st.Type = SqlStructs[i].Type
SqlStructs[i].Status = 1
notify.MEmailList = append(notify.MEmailList, st)
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(notify)
G_getGameLogic().PackResInfo(agent, "NotifyNewBriefEmailData", data)
}
func (p *PlayerEmailData) ResBriefEmailData() {
res := &msg.ResBriefEmailData{}
res.DwUin = p.M_Player.M_DwUin
res.MEmailList = []*msg.BriefEmailStruct{}
for i := 0; i < len(p.SqlStructs); i++ {
st := &msg.BriefEmailStruct{}
st.EmailId = p.SqlStructs[i].EmailId
st.Sender = p.SqlStructs[i].Sender
st.Title = p.SqlStructs[i].Title
st.CurrencyCount = p.SqlStructs[i].CurrencyCount
st.CurrencyInfo = p.SqlStructs[i].CurrencyInfo
st.ItemCount = p.SqlStructs[i].ItemCount
st.ItemInfo = p.SqlStructs[i].ItemInfo
st.SendTime = p.SqlStructs[i].SendTime
st.Status = p.SqlStructs[i].Status
st.Type = p.SqlStructs[i].Type
res.MEmailList = append(res.MEmailList, st)
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResBriefEmailData", data)
}
func (p *PlayerEmailData) FindSqlStructByMailId(mailId int32) *db.SqlEmailStruct {
for i := 0; i < len(p.SqlStructs); i++ {
if p.SqlStructs[i].EmailId == mailId {
return &p.SqlStructs[i]
}
}
return nil
}
func (p *PlayerEmailData) DeleteSqlStructByMailId(mailId int32) *db.SqlEmailStruct {
var temp *db.SqlEmailStruct = nil
var list []db.SqlEmailStruct
for i := 0; i < len(p.SqlStructs); i++ {
if p.SqlStructs[i].EmailId == mailId {
temp = &p.SqlStructs[i]
if i > 0 {
list = append(list, p.SqlStructs[:i]...)
}
if i < len(p.SqlStructs)-1 {
list = append(list, p.SqlStructs[i+1:]...)
}
break
}
}
p.SqlStructs = list
return temp
}
func (p *PlayerEmailData) ResDetailEmailData(buf []byte) {
res := &msg.ResDetailEmailData{}
req := &msg.ReqDetailEmailData{}
proto.Unmarshal(buf, req)
st := p.FindSqlStructByMailId(req.EmailId)
if st != nil {
res.ResultCode = 0
res.Content = st.Content
res.EmailId = req.EmailId
res.RewardType = st.RewardType
res.RewardId = st.RewardId
res.RewardCount = st.RewardCount
res.LinkUrl = st.LinkUrl
if st.Type == 0 {
st.Status = 2
st.RecvTime = int32(time.Now().Unix())
db.FormatAllMemUpdateDb(st, "system_mail_info", "mail_id")
}
} else {
res.ResultCode = MergeConst.Protocol_Email_Find_Fail
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResDetailEmailData", data)
}
func (p *PlayerEmailData) ResDeleteEmail(buf []byte) {
res := &msg.ResDeleteEmail{}
req := &msg.ReqDeleteEmail{}
proto.Unmarshal(buf, req)
if p.DeleteSqlStructByMailId(req.EmailId) != nil {
res.EmailId = req.EmailId
res.ResultCode = 0
deleteList := []int32{req.EmailId}
p.DeleteOutlineMail(deleteList)
} else {
res.ResultCode = MergeConst.Protocol_Email_Find_Fail
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResDeleteEmail", data)
}
func (p *PlayerEmailData) ResGetEmailReward(buf []byte) {
res := &msg.ResGetEmailReward{}
req := &msg.ReqGetEmailReward{}
proto.Unmarshal(buf, req)
st := p.FindSqlStructByMailId(req.EmailId)
if st != nil {
res.ResultCode = 0
res.EmailId = req.EmailId
res.RewardType = st.RewardType
res.RewardId = st.RewardId
res.RewardCount = st.RewardCount
st.Status = 2
st.RecvTime = int32(time.Now().Unix())
db.FormatAllMemUpdateDb(st, "system_mail_info", "mail_id")
///发送奖励
} else {
res.ResultCode = MergeConst.Protocol_Email_Find_Fail
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResGetEmailReward", data)
}
func (p *PlayerEmailData) ClearData() bool {
p.SaveDataFromDB("")
p.Mcron.Remove(p.ZeroCronID)
p.Mcron.Stop()
return true
}

129
src/server/game/PlayerEmitUnlockMod.go
View File

@ -1,129 +0,0 @@
package game
import (
"fmt"
"server/GoUtil"
"server/MergeConst"
"server/db"
"server/msg"
"strconv"
"strings"
"google.golang.org/protobuf/proto"
)
type PlayerEmitUnlockData struct {
*PlayerData
Data msg.ResPlayerEmitUnlockData
}
func (p *PlayerEmitUnlockData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_emit_unlock WHERE dwUin = ?"
sqlStruck := db.SqlEmitUnlockStruct{RenewTime: 0}
p.Data.MEmitUnlockData = make(map[int32]int32)
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
if sqlStruck.Value != "" {
arr := strings.Split(sqlStruck.Value, "_")
for i := 0; i < len(arr); i++ {
ss := strings.Split(arr[i], ",")
id, err := strconv.ParseInt(ss[0], 10, 32)
cnt, _ := strconv.ParseInt(ss[1], 10, 32)
if err != nil {
panic(err)
}
p.Data.MEmitUnlockData[int32(id)] = int32(cnt)
}
}
p.Data.DwUin = dwUin.(int32)
p.Data.RenewTime = sqlStruck.RenewTime
p.Reconnect(false)
return true
}
func (p *PlayerEmitUnlockData) Reconnect(b bool) {
if G_GameLogicPtr.DailyTaskTimestamp > (int64)(p.Data.RenewTime) {
p.Data.RenewTime = int32(G_GameLogicPtr.DailyTaskTimestamp)
for k := range p.Data.MEmitUnlockData {
p.Data.MEmitUnlockData[k] = 0
}
if b {
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_getGameLogic().PackResInfo(agent, "NotifyDailyRenewEmitUnlock", data)
}
}
GoUtil.RegisterEvent(MergeConst.Notify_Daily_Renew, p.NotifyDailyRenewEmitUnlock, p)
}
func (p *PlayerEmitUnlockData) GetUnlockCntByID(id int32) int32 {
cnt, ok := p.Data.MEmitUnlockData[id]
if ok {
return cnt
}
return 0
}
func (p *PlayerEmitUnlockData) ClearData() bool {
p.SaveDataFromDB("")
GoUtil.RemoveEvent(MergeConst.Notify_Daily_Renew, p.NotifyDailyRenewEmitUnlock, p)
return true
}
func (p *PlayerEmitUnlockData) SaveDataFromDB(Key interface{}) bool {
var strarr []string
for k, v := range p.Data.MEmitUnlockData {
str := fmt.Sprintf("%d,%d", k, v)
strarr = append(strarr, str)
}
str_concat := strings.Join(strarr, "_")
// sqlStr := "UPDATE user SET age = ?, degree = ? WHERE id = ?"
// result, err := SqlDb.Exec(sqlStr, 22, 10, 4)
sqlStruck := db.SqlEmitUnlockStruct{}
sqlStruck.DwUin = p.M_Player.M_DwUin
sqlStruck.Value = str_concat
if p.IsHaveDataDb {
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_emit_unlock", "dwUin")
} else {
db.FormatAllMemInsertDb(&sqlStruck, "t_player_emit_unlock")
}
p.IsHaveDataDb = true
return true
}
func (p *PlayerEmitUnlockData) ResPlayerEmitUnlockData(player *Player) {
if player != p.M_Player {
return
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_getGameLogic().PackResInfo(agent, "ResPlayerEmitUnlockData", data)
}
func (p *PlayerEmitUnlockData) NotifyDailyRenewEmitUnlock(param []interface{}) {
p.Data.RenewTime = int32(param[0].(int64))
for k := range p.Data.MEmitUnlockData {
p.Data.MEmitUnlockData[k] = 0
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_getGameLogic().PackResInfo(agent, "NotifyDailyRenewEmitUnlock", data)
// p.SaveDataFromDB("")
}
func (p *PlayerEmitUnlockData) UpdatePlayerEmitUnlockData(buf []byte) {
update := &msg.UpdatePlayerEmitUnlockData{}
proto.Unmarshal(buf, update)
p.Data.MEmitUnlockData = update.MEmitUnlockData
p.SaveDataFromDB("")
}

1398
src/server/game/PlayerFriendData.go
View File

File diff suppressed because it is too large Load Diff

2
src/server/game/PlayerFunc.go
View File

@ -289,6 +289,8 @@ func FriendLogBackData(p *Player) {
Player: ps,
Type: int32(v.Type),
Time: int32(v.Time),
Param: v.Param,
Id: int32(v.Id),
})
}
p.PushClientRes(&proto.ResFriendTimeLine{

97
src/server/game/PlayerGiftMod.go
View File

@ -1,97 +0,0 @@
package game
import (
"fmt"
"server/db"
"server/msg"
"strconv"
"strings"
"google.golang.org/protobuf/proto"
)
type PlayerGiftData struct {
*PlayerData
Data msg.ResPlayerGiftData
}
func (p *PlayerGiftData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_gift_data WHERE dwUin = ?"
sqlStruck := db.SqlGiftStruct{}
p.Data.MGiftData = make(map[int32]int32)
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
if sqlStruck.MGiftData != "" {
arr := strings.Split(sqlStruck.MGiftData, "_")
for i := 0; i < len(arr); i++ {
ss := strings.Split(arr[i], ",")
id, err := strconv.ParseInt(ss[1], 10, 32)
key, _ := strconv.ParseInt(ss[0], 10, 32)
if err != nil {
panic(err)
}
p.Data.MGiftData[int32(key)] = int32(id)
}
}
p.Data.DwUin = dwUin.(int32)
p.Reconnect(false)
return true
}
func (p *PlayerGiftData) Reconnect(b bool) {
}
func (p *PlayerGiftData) SaveDataFromDB(Key interface{}) bool {
var strarr []string
for k, v := range p.Data.MGiftData {
str := fmt.Sprintf("%d,%d", k, v)
strarr = append(strarr, str)
}
str_concat := strings.Join(strarr, "_")
sqlStruck := db.SqlGiftStruct{}
sqlStruck.DwUin = p.M_Player.M_DwUin
sqlStruck.MGiftData = str_concat
if p.IsHaveDataDb {
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_gift_data", "dwUin")
} else {
db.FormatAllMemInsertDb(&sqlStruck, "t_player_gift_data")
}
p.IsHaveDataDb = true
return true
}
func (p *PlayerGiftData) ResPlayerGiftData(player *Player) {
if player != p.M_Player {
return
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_getGameLogic().PackResInfo(agent, "ResPlayerGiftData", data)
}
func (p *PlayerGiftData) UpdatePlayerGiftData(buf []byte) {
update := &msg.UpdatePlayerGiftData{}
proto.Unmarshal(buf, update)
p.Data.MGiftData = update.MGiftData
p.SaveDataFromDB("")
}
func (p *PlayerGiftData) ClearData() bool {
p.SaveDataFromDB("")
return true
}

2
src/server/game/PlayerMod.go
View File

@ -165,7 +165,7 @@ func (p *PlayerMod) ClearData(player *Player) {
fmt.Println(err)
return
}
log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
// log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
modData := &db.SqlModStruct{
DwUin: player.M_DwUin,
ModData: buf.Bytes(),

168
src/server/game/PlayerPigData.go
View File

@ -1,168 +0,0 @@
package game
import (
"server/MergeConst"
"server/db"
"server/msg"
"time"
"google.golang.org/protobuf/proto"
)
type PlayerPigData struct {
*PlayerData
Data msg.ResPigDetailInfo
}
func (p *PlayerPigData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_piginfo WHERE dwUin = ?"
sqlStruck := db.SqlPigDetailInfoStruct{}
sqlStruck.PigId = 0
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
p.Data.CurDiamonds = sqlStruck.CurDiamonds
p.Data.DwUin = p.M_Player.M_DwUin
p.Data.PigId = sqlStruck.PigId
p.Data.PigType = sqlStruck.PigType
p.Data.StartSvrTime = sqlStruck.StartSvrTime
p.Data.EndSvrTime = sqlStruck.EndSvrTime
p.Data.CurGetLv = sqlStruck.CurGetLv
p.Reconnect(false)
return true
}
func (p *PlayerPigData) Reconnect(b bool) {
}
func (p *PlayerPigData) DeleteLastPigData(pigid int32) {
sqlStr := "DELETE FROM " + "t_player_piginfo" + " WHERE PigId = ?"
db.SqlDb.Exec(sqlStr, pigid)
p.Data.PigId = 0
}
func (p *PlayerPigData) ClearData() bool {
p.SaveDataFromDB("")
return true
}
func (p *PlayerPigData) SaveDataFromDB(Key interface{}) bool {
sqlStruck := db.SqlPigDetailInfoStruct{}
sqlStruck.DwUin = p.M_Player.M_DwUin
sqlStruck.CurDiamonds = p.Data.CurDiamonds
sqlStruck.CurGetLv = p.Data.CurGetLv
sqlStruck.CurSvrTime = 0
sqlStruck.EndSvrTime = p.Data.EndSvrTime
sqlStruck.StartSvrTime = p.Data.StartSvrTime
sqlStruck.PigId = p.Data.PigId
sqlStruck.PigType = p.Data.PigType
if p.IsHaveDataDb {
if p.Data.PigId != 0 {
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_piginfo", "PigId")
}
} else {
if p.Data.PigId != 0 {
db.FormatAllMemInsertDb(&sqlStruck, "t_player_piginfo")
}
}
p.IsHaveDataDb = true
return true
}
func (p *PlayerPigData) ResOpenNewPig(player *Player) {
res := &msg.ResOpenNewPig{}
st := &db.SqlPigDetailInfoStruct{}
st.DwUin = player.M_DwUin
st.StartSvrTime = (int32)(time.Now().Unix())
st.EndSvrTime = st.StartSvrTime + MergeConst.G_Pig_Limite
st.PigType = 1
st.CurDiamonds = 0
st.CurSvrTime = 0
st.CurGetLv = 1
PigId, _ := db.FormatAllMemInsertDb(st, "t_player_piginfo")
res.PigId = (int32)(PigId)
p.Data.CurDiamonds = st.CurDiamonds
p.Data.DwUin = p.M_Player.M_DwUin
p.Data.PigId = int32(PigId)
p.Data.PigType = st.PigType
p.Data.StartSvrTime = st.StartSvrTime
p.Data.EndSvrTime = st.EndSvrTime
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResOpenNewPig", data)
}
func (p *PlayerPigData) ResPigDetailInfo(player *Player) {
// res := &msg.ReqPigDetailInfo{}
p.Data.CurSvrTime = int32(time.Now().Unix())
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_getGameLogic().PackResInfo(agent, "ResPigDetailInfo", data)
}
func (p *PlayerPigData) UpdateFinishOrderDiamond(buf []byte) {
update := &msg.UpdateFinishOrderDiamond{}
proto.Unmarshal(buf, update)
p.Data.CurDiamonds = update.CurDiamonds
p.SaveDataFromDB("")
}
func (p *PlayerPigData) ResGetPigReward(buf []byte) {
req := &msg.ReqGetPigReward{}
proto.Unmarshal(buf, req)
res := &msg.ResGetPigReward{}
res.PigId = req.PigId
if req.PigId != p.Data.PigId {
res.ResultCode = MergeConst.Protocol_PigID_No_Exsit
} else {
res.ResultCode = 0
p.Data.CurGetLv = p.Data.CurGetLv + 1
res.CurGetLv = p.Data.CurGetLv
}
res.CurDiamonds = p.Data.CurDiamonds
if MergeConst.G_PigIsOne {
p.DeleteLastPigData(req.PigId)
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResGetPigReward", data)
}
func (p *PlayerPigData) ResDropPigReward(buf []byte) {
req := &msg.ReqDropPigReward{}
proto.Unmarshal(buf, req)
res := &msg.ResDropPigReward{}
res.PigId = req.PigId
if req.PigId != p.Data.PigId {
res.ResultCode = MergeConst.Protocol_PigID_No_Exsit
} else {
res.ResultCode = 0
}
p.DeleteLastPigData(req.PigId)
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResDropPigReward", data)
}

418
src/server/game/PlayerProfileDataManager.go
View File

@ -1,418 +0,0 @@
package game
import (
"math"
"math/rand"
"server/db"
"server/game/internal"
"server/msg"
"strconv"
"server/pkg/github.com/name5566/leaf/gate"
"google.golang.org/protobuf/proto"
)
type PlayerProfileManager struct {
MsqlStrucks []db.SqlPlayerProfileStruct
MapSql map[int32]*db.SqlPlayerProfileStruct
}
func (p *PlayerProfileManager) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_Profile_Data"
p.MsqlStrucks = []db.SqlPlayerProfileStruct{}
p.MapSql = make(map[int32]*db.SqlPlayerProfileStruct)
db.SqlDb.Select(&p.MsqlStrucks, sqlStr)
for i := 0; i < len(p.MsqlStrucks); i++ {
item := p.MsqlStrucks[i]
p.MapSql[item.DwUin] = &item
}
return true
}
func (p *PlayerProfileManager) GetPlayerDecorate(dwUin int32) (int, int, string) {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{}
decorate := 0
ActiveTime := 0
FaceBookId := ""
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin); err != nil {
} else {
Score := 0
for i := 1; i < int(sqlStruck.Level); i++ {
Score = Score + (i-1)*10 + 20
}
Score = Score + int(sqlStruck.Exp)
decorate = Score / 10
ActiveTime = int(math.Max(float64(sqlStruck.LoginTime), float64(sqlStruck.LogoutTime)))
FaceBookId = sqlStruck.FaceBookId
}
return decorate, ActiveTime, FaceBookId
}
func (p *PlayerProfileManager) InitManager() {
p.LoadDataFromDB("")
}
func (p *PlayerProfileManager) AddNewProfile(st *db.SqlPlayerProfileStruct) bool {
if p.GetPlayerProfile(st.DwUin) == nil {
p.MapSql[st.DwUin] = st
db.FormatAllMemInsertDb(st, "t_player_Profile_Data")
}
return true
}
func (p *PlayerProfileManager) UpdateNewProfile(st *db.SqlPlayerProfileStruct) bool {
if p.GetPlayerProfile(st.DwUin) != nil {
p.MapSql[st.DwUin] = st
db.FormatAllMemUpdateDb(st, "t_player_Profile_Data", "dwUin")
} else {
p.AddNewProfile(st)
}
return true
}
func (p *PlayerProfileManager) GetPlayerProfileByNick(nick string) []*db.SqlPlayerProfileStruct {
ret := []*db.SqlPlayerProfileStruct{}
// G_getGameLogic().Mlogger.Debug("p.MapSql" + strconv.Itoa(len(p.MapSql)))
// G_getGameLogic().Mlogger.Debug("nick:" + nick)
for k, v := range p.MapSql {
if strconv.Itoa(int(k)) == nick {
ret = append(ret, v)
} else {
// G_getGameLogic().Mlogger.Debug("v.NickName:" + v.NickName)
if nick == v.NickName {
ret = append(ret, v)
}
}
}
return ret
}
func (p *PlayerProfileManager) GetPlayerProfile(id int32) *db.SqlPlayerProfileStruct {
st, ok := p.MapSql[id]
if ok {
return st
}
return nil
}
func (p *PlayerProfileManager) GetIsHavePlayerById(id int32) bool {
sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
sqlStruck := db.ResPlayerBaseInfo{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, id); err != nil {
} else {
return true
}
return false
}
func (p *PlayerProfileManager) ReqPlayerProfileData(args []interface{}) {
a := args[0].(gate.Agent)
play, _ := internal.Agents.Load(a)
buf := args[1].([]byte)
player := play.(*Player)
req := &msg.ReqPlayerProfileData{}
res := &msg.ResPlayerProfileData{}
proto.Unmarshal(buf, req)
profile := p.GetPlayerProfile(player.M_DwUin)
if profile != nil {
res.DwUin = player.M_DwUin
res.NickName = profile.NickName
res.ImageFrame = profile.ImageFrame
res.ImageIcon = profile.ImageIcon
res.PicURL = profile.PicURL
res.UnlockFrame = profile.UnlockFrame
res.UnlockIcon = profile.UnlockIcon
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(player.M_DwUin)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
} else {
res.DwUin = player.M_DwUin
res.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
res.ImageFrame = 1
res.ImageIcon = 1
res.UnlockFrame = ""
res.UnlockIcon = ""
res.PicURL = ""
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(player.M_DwUin)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
st := db.SqlPlayerProfileStruct{}
st.DwUin = player.M_DwUin
st.ImageFrame = 1
st.ImageIcon = 1
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = ""
st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
p.UpdateNewProfile(&st)
}
agent := player.GetAgentByPlayer()
data1, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResPlayerProfileData", data1)
}
func (p *PlayerProfileManager) ReqUpdatePlayerProfile(args []interface{}) {
a := args[0].(gate.Agent)
play, _ := internal.Agents.Load(a)
buf := args[1].([]byte)
player := play.(*Player)
req := &msg.ReqUpdatePlayerProfile{}
res := &msg.ResUpdatePlayerProfile{}
proto.Unmarshal(buf, req)
profile := p.GetPlayerProfile(player.M_DwUin)
if profile != nil {
if req.Type == 1 {
profile.NickName = req.Param
}
if req.Type == 2 {
value, _ := strconv.Atoi(req.Param)
profile.ImageFrame = int32(value)
}
if req.Type == 3 {
value, _ := strconv.Atoi(req.Param)
profile.ImageIcon = int32(value)
}
p.UpdateNewProfile(profile)
} else {
st := db.SqlPlayerProfileStruct{}
st.DwUin = player.M_DwUin
st.ImageFrame = 1
st.ImageIcon = 1
st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
if req.Type == 1 {
st.NickName = req.Param
}
if req.Type == 2 {
value, _ := strconv.Atoi(req.Param)
st.ImageFrame = int32(value)
}
if req.Type == 3 {
value, _ := strconv.Atoi(req.Param)
st.ImageIcon = int32(value)
}
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = ""
p.UpdateNewProfile(&st)
}
res.DwUin = req.DwUin
res.Type = req.Type
res.Param = req.Param
res.ResultCode = 0
agent := player.GetAgentByPlayer()
data1, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResUpdatePlayerProfile", data1)
}
func (p *PlayerProfileManager) HttpReqPlayerBriefProfileData(Id int32) *msg.ResPlayerBriefProfileData {
profile := p.GetPlayerProfile(Id)
res := &msg.ResPlayerBriefProfileData{}
if profile != nil {
res.DwUin = profile.DwUin
res.NickName = profile.NickName
res.ImageFrame = profile.ImageFrame
res.ImageIcon = profile.ImageIcon
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(Id)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
res.PicURL = profile.PicURL
} else {
res.DwUin = Id
res.NickName = "Player" + strconv.Itoa(int(Id))
res.ImageFrame = 1
res.ImageIcon = 1
res.PicURL = ""
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(Id)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
st := db.SqlPlayerProfileStruct{}
st.DwUin = Id
st.ImageFrame = 1
st.ImageIcon = 1
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = ""
st.NickName = "Player" + strconv.Itoa(int(Id))
p.UpdateNewProfile(&st)
}
return res
}
func (p *PlayerProfileManager) ReqPlayerBriefProfileData(args []interface{}) {
a := args[0].(gate.Agent)
play, _ := internal.Agents.Load(a)
buf := args[1].([]byte)
player := play.(*Player)
req := &msg.ReqPlayerBriefProfileData{}
res := &msg.ResPlayerBriefProfileData{}
proto.Unmarshal(buf, req)
profile := p.GetPlayerProfile(req.DwUin)
if profile != nil {
res.DwUin = profile.DwUin
res.NickName = profile.NickName
res.ImageFrame = profile.ImageFrame
res.ImageIcon = profile.ImageIcon
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(req.DwUin)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
res.PicURL = profile.PicURL
} else {
res.DwUin = req.DwUin
res.NickName = "Player" + strconv.Itoa(int(req.DwUin))
res.ImageFrame = 1
res.ImageIcon = 1
res.PicURL = ""
DecorateCnt, ActiveTime, _ := p.GetPlayerDecorate(req.DwUin)
res.DecorateCnt = int32(DecorateCnt)
res.ActiveTime = int32(ActiveTime)
st := db.SqlPlayerProfileStruct{}
st.DwUin = req.DwUin
st.ImageFrame = 1
st.ImageIcon = 1
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = ""
st.NickName = "Player" + strconv.Itoa(int(req.DwUin))
p.UpdateNewProfile(&st)
}
agent := player.GetAgentByPlayer()
data1, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResPlayerBriefProfileData", data1)
}
func (p *PlayerProfileManager) RandomGetAnPlayer(origin int32) *db.SqlPlayerProfileStruct {
idx := rand.Intn(len(p.MsqlStrucks))
for p.MsqlStrucks[idx].DwUin == origin {
idx = rand.Intn(len(p.MsqlStrucks))
}
Profile := p.GetPlayerProfile(p.MsqlStrucks[idx].DwUin)
if Profile != nil {
return Profile
} else {
sql := &db.SqlPlayerProfileStruct{}
sql.DwUin = p.MsqlStrucks[idx].DwUin
sql.ImageFrame = 1
sql.ImageIcon = 1
sql.NickName = "Player" + strconv.Itoa(int(p.MsqlStrucks[idx].DwUin))
sql.PicURL = ""
p.UpdateNewProfile(sql)
return sql
}
}
func (p *PlayerProfileManager) GetIsHaveAddFriendInfo(sender int32, receive int32) (bool, *db.SqlAddFriendStruct) {
sqlStr := "SELECT * FROM t_player_Req_add_Friend WHERE SenderId = ? AND ReceiverId = ?"
sqlStruck := db.SqlAddFriendStruct{}
if err := db.SqlDb.Get(&sqlStruck, sqlStr, sender, receive); err != nil {
return false, nil
} else {
return true, &sqlStruck
}
// return false
}
func (p *PlayerProfileManager) RandomGetPlayers(Cnt int, originId int32, ExcludeList []int32) []*db.SqlPlayerProfileStruct {
var CurCnt int = 0
ret := []*db.SqlPlayerProfileStruct{}
var Loops int = 0
for {
Ids := G_GameLogicPtr.DisorderLuaTable(len(p.MsqlStrucks), int(math.Min(float64(len(p.MsqlStrucks)), float64(Cnt))))
for i := 0; i < len(Ids); i++ {
IsIll := true
for j := 0; j < len(ExcludeList); j++ {
if ExcludeList[j] == p.MsqlStrucks[Ids[i]].DwUin {
IsIll = false
break
}
}
if IsIll {
isHave1, _ := p.GetIsHaveAddFriendInfo(originId, p.MsqlStrucks[Ids[i]].DwUin)
isHave2, _ := p.GetIsHaveAddFriendInfo(p.MsqlStrucks[Ids[i]].DwUin, originId)
if !isHave1 && !isHave2 {
CurCnt += 1
ret = append(ret, &p.MsqlStrucks[Ids[i]])
ExcludeList = append(ExcludeList, p.MsqlStrucks[Ids[i]].DwUin)
if CurCnt == Cnt {
return ret
}
}
}
}
Loops += 1
if Loops == 3 {
break
}
}
return ret
}
func (p *PlayerProfileManager) ReqUpdateFBPicURL(args []interface{}) {
a := args[0].(gate.Agent)
play, _ := internal.Agents.Load(a)
buf := args[1].([]byte)
player := play.(*Player)
req := &msg.ReqUpdateFBPicURL{}
res := &msg.ResUpdateFBPicURL{}
proto.Unmarshal(buf, req)
profile := p.GetPlayerProfile(player.M_DwUin)
res.ResultCode = 0
if profile != nil {
profile.PicURL = req.URL
p.UpdateNewProfile(profile)
} else {
st := db.SqlPlayerProfileStruct{}
st.DwUin = player.M_DwUin
st.ImageFrame = 1
st.ImageIcon = 1
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = req.URL
st.NickName = "Player" + strconv.Itoa(int(player.M_DwUin))
p.UpdateNewProfile(&st)
}
agent := player.GetAgentByPlayer()
data1, _ := proto.Marshal(res)
G_getGameLogic().PackResInfo(agent, "ResUpdateFBPicURL", data1)
}
func (p *PlayerProfileManager) NewGetPlayerProfile(DwUin int32) *db.SqlPlayerProfileStruct {
profile := p.GetPlayerProfile(DwUin)
if profile != nil {
return profile
} else {
st := db.SqlPlayerProfileStruct{}
st.DwUin = DwUin
st.ImageFrame = 1
st.ImageIcon = 1
st.UnlockFrame = ""
st.UnlockIcon = ""
st.PicURL = ""
st.NickName = "Player" + strconv.Itoa(int(DwUin))
p.UpdateNewProfile(&st)
return &st
}
}

1236
src/server/game/PlayerShopData.go
View File

File diff suppressed because it is too large Load Diff

227
src/server/game/PlayerUnlockingChestMod.go
View File

@ -1,227 +0,0 @@
package game
import (
"fmt"
mergeDataCfg "server/conf/mergeData"
"server/db"
"server/msg"
"server/pkg/github.com/name5566/leaf/timer"
"time"
"google.golang.org/protobuf/proto"
)
type PlayerUnlockingChestData struct {
*PlayerData
Data msg.ResUnlockingChestID
MLeafTimer *timer.Timer
Mdispatr *timer.Dispatcher
}
func (p *PlayerUnlockingChestData) LoadDataFromDB(dwUin interface{}) bool {
sqlStr := "SELECT * FROM t_player_chest_data WHERE dwUin = ?"
sqlStruck := db.SqlChestStruct{}
p.Mdispatr = timer.NewDispatcher(1)
if err := db.SqlDb.Get(&sqlStruck, sqlStr, dwUin.(int32)); err != nil {
p.IsHaveDataDb = false
} else {
p.IsHaveDataDb = true
}
p.Data.DwUin = dwUin.(int32)
p.Data.ChestID = sqlStruck.ChestID
p.Data.UnlockStartTime = sqlStruck.UnlockStartTime
p.Data.CurSvrTime = int32(time.Now().Unix())
p.Reconnect(false)
return true
}
func (p *PlayerUnlockingChestData) Reconnect(b bool) {
if p.Data.ChestID > 0 {
chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
if chessKey == "" {
p.Data.ChestID = 0
p.Data.UnlockStartTime = 0
return
}
MergeId := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetValueByKey(chessKey)
item, _ := mergeDataCfg.GetOne(int(MergeId))
cool := item.CoolTime
deltaTime := time.Now().Unix() - (int64)(p.Data.UnlockStartTime)
if deltaTime >= (int64)(cool) { //注意后面读表
if p.M_Player.GetGameData("PlayerChessData") == nil {
data := &PlayerChessData{PlayerData: NewPlayerData("PlayerChessData", p.M_Player)}
ok := data.LoadDataFromDB(p.M_Player.M_DwUin)
if ok {
p.M_Player.playerdata["PlayerChessData"] = data
p.M_Player.playerdataIF["PlayerChessData"] = data
}
}
p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
fmt.Println("chessKey:", chessKey)
p.Data.ChestID = 0
p.Data.UnlockStartTime = 0
if b {
p.NotifyUnlockingChestData()
}
} else {
go func() {
// 注释内容也可以使用
t1 := (int64)(cool) - deltaTime
p.MLeafTimer = p.Mdispatr.AfterFunc(time.Duration(t1)*time.Second, func() {
p.NotifyUnlockingChestData()
p.MLeafTimer = nil
})
(<-p.Mdispatr.ChanTimer).Cb()
}()
}
p.NotifyInitUnlockingChestID()
}
}
func (p *PlayerUnlockingChestData) RenewData() {
if p.Data.ChestID > 0 {
chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
MergeId := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetValueByKey(chessKey)
// MergeId := p.M_Player.GetIFGameData("PlayerEmitDetailData").(*PlayerEmitDetailData).GetMergeIDByChestid(p.Data.ChestID)
item, _ := mergeDataCfg.GetOne(int(MergeId))
cool := item.CoolTime
deltaTime := time.Now().Unix() - (int64)(p.Data.UnlockStartTime)
if p.MLeafTimer != nil {
p.MLeafTimer.Disabled()
p.Mdispatr.ChanTimer <- p.MLeafTimer
p.MLeafTimer.Stop()
p.MLeafTimer = nil
}
if deltaTime >= (int64)(cool) { //注意后面读表
p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
p.Data.ChestID = 0
p.Data.UnlockStartTime = 0
} else {
go func() {
// 注释内容也可以使用
t1 := (int64)(cool) - deltaTime
p.MLeafTimer = p.Mdispatr.AfterFunc(time.Duration(t1)*time.Second, func() {
p.NotifyUnlockingChestData()
p.MLeafTimer = nil
})
(<-p.Mdispatr.ChanTimer).Cb()
}()
}
p.NotifyInitUnlockingChestID()
}
}
func (p *PlayerUnlockingChestData) NotifyInitUnlockingChestID() {
notify := &msg.NotifyInitUnlockingChestID{}
notify.ChestID = p.Data.ChestID
notify.UnlockStartTime = p.Data.UnlockStartTime
notify.DwUin = p.M_Player.M_DwUin
notify.CurSvrTime = int32(time.Now().Unix())
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(notify)
G_GameLogicPtr.PackResInfo(agent, "NotifyInitUnlockingChestID", data)
}
func (p *PlayerUnlockingChestData) ClearData() bool {
p.SaveDataFromDB("")
if p.MLeafTimer != nil {
p.MLeafTimer.Disabled()
p.Mdispatr.ChanTimer <- p.MLeafTimer
p.MLeafTimer.Stop()
p.MLeafTimer = nil
}
return true
}
func (p *PlayerUnlockingChestData) SaveDataFromDB(Key interface{}) bool {
sqlStruck := db.SqlChestStruct{}
sqlStruck.DwUin = p.M_Player.M_DwUin
sqlStruck.ChestID = p.Data.ChestID
sqlStruck.UnlockStartTime = p.Data.UnlockStartTime
if p.IsHaveDataDb {
db.FormatAllMemUpdateDb(&sqlStruck, "t_player_chest_data", "dwUin")
} else {
db.FormatAllMemInsertDb(&sqlStruck, "t_player_chest_data")
}
p.IsHaveDataDb = true
return true
}
func (p *PlayerUnlockingChestData) ResUnlockingChestID(buf []byte) {
update := &msg.ReqUnlockingChestID{}
proto.Unmarshal(buf, update)
p.Data.ChestID = update.ChestID
p.Data.UnlockStartTime = int32(time.Now().Unix())
// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID1:", p.Data.ChestID, update.MergeID)
p.M_Player.GetIFGameData("PlayerEmitDetailData").(*PlayerEmitDetailData).SetMergeIDByChestid(update.ChestID, update.MergeID)
// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID2:", p.Data.ChestID, update.MergeID)
p.RenewData()
// G_GameLogicPtr.Mlogger.Debug("ResUnlockingChestID3:", p.Data.ChestID, update.MergeID)
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(&p.Data)
G_GameLogicPtr.PackResInfo(agent, "ResUnlockingChestID", data)
}
func (p *PlayerUnlockingChestData) ResChestUnlockCD(buf []byte) {
update := &msg.ReqChestUnlockCD{}
proto.Unmarshal(buf, update)
res := &msg.ResChestUnlockCD{}
res.DwUin = p.GetPlayer().M_DwUin
res.ChestID = update.ChestID
res.Type = update.Type
res.CurSvrTime = int32(time.Now().Unix())
////ad
if res.Type == 3 {
p.Data.UnlockStartTime = p.Data.UnlockStartTime - 60*30
res.UnlockStartTime = p.Data.UnlockStartTime
p.RenewData()
}
///diamond
if res.Type == 2 {
p.Data.UnlockStartTime = 0
p.RenewData()
}
if res.Type == 1 {
p.Data.ChestID = 0
p.Data.UnlockStartTime = 0
if p.MLeafTimer != nil {
p.MLeafTimer.Disabled()
p.Mdispatr.ChanTimer <- p.MLeafTimer
p.MLeafTimer.Stop()
p.MLeafTimer = nil
}
}
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(res)
G_GameLogicPtr.PackResInfo(agent, "ResChestUnlockCD", data)
}
func (p *PlayerUnlockingChestData) NotifyUnlockingChestData() {
chessKey := p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).GetKeyByEmitID(p.Data.ChestID)
p.GetPlayer().GetIFGameData("PlayerChessData").(*PlayerChessData).SetValueByKey(chessKey)
notify := &msg.NotifyUnlockingChestData{}
notify.DwUin = p.GetPlayer().M_DwUin
notify.ChestID = 0
notify.UnlockStartTime = 0
p.Data.ChestID = 0
p.Data.UnlockStartTime = 0
notify.CurSvrTime = int32(time.Now().Unix())
agent := p.GetPlayer().GetAgentByPlayer()
data, _ := proto.Marshal(notify)
G_GameLogicPtr.PackResInfo(agent, "NotifyUnlockingChestData", data)
}

1541
src/server/game/RegisterNetworkFunc.go
View File

File diff suppressed because it is too large Load Diff

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

@ -120,16 +120,9 @@ func HandleClientReq(args []interface{}) {
if ResLogin.DwUin > 0 {
if OldPlayer, ok := G_GameLogicPtr.M_Players[ResLogin.DwUin]; ok {
G_GameLogicPtr.ReplaceExistPlayerAndAgent(a, OldPlayer)
OldPlayer.PAMgr.InitActiveMgr(OldPlayer)
} else {
player := G_GameLogicPtr.FindOfflinePlayer(ResLogin.DwUin)
if player != nil {
G_GameLogicPtr.RebindPlayerAndAgent(a, player)
player.PAMgr.InitActiveMgr(player)
} else {
G_GameLogicPtr.CreateNewPlayer(a, detail.UserName)
}
}
}
p, _ := internal.Agents.Load(a)

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

@ -337,7 +337,7 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int) bool
}
//额外订单补充1；CDEG发射器首次合成时，生成其对应2及棋子订单，完成后生成3及，再完成生成4及的；
if b1 {
ChessColor := mergeDataCfg.GetEmitProduceType(OrderEmit)
ChessColor := mergeDataCfg.GetEmitProduceChessType(OrderEmit)
ChessId := mergeDataCfg.GetChessIdByLvAndColor(2, ChessColor[0])
if ChessId != 0 {
o.addOrder([]int{ChessId}, diff_low, Preheat_type)

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

@ -94,7 +94,6 @@ func (a *agent) Run() {
for {
data, err := a.conn.ReadMsg()
if err != nil {
log.Debug("read messagefdsdf: %v", err)
break
}