276 lines
7.2 KiB
Go
276 lines
7.2 KiB
Go
package main
|
|
|
|
import (
|
|
"time"
|
|
|
|
"mongo.games.com/goserver/core/logger"
|
|
"mongo.games.com/goserver/core/netlib"
|
|
|
|
"mongo.games.com/game/common"
|
|
"mongo.games.com/game/model"
|
|
taskproto "mongo.games.com/game/protocol/task"
|
|
"mongo.games.com/game/srvdata"
|
|
)
|
|
|
|
const (
|
|
TaskStateFinish = 1 // 任务完成
|
|
TaskStateReward = 2 // 任务奖励已领取
|
|
)
|
|
|
|
func init() {
|
|
// 获取任务列表
|
|
common.Register(int(taskproto.TaskPacketID_PACKET_CSTaskList), taskproto.CSTaskList{}, CSTaskList)
|
|
// 领取任务奖励
|
|
common.Register(int(taskproto.TaskPacketID_PACKET_CSTaskReward), taskproto.CSTaskReward{}, CSTaskReward)
|
|
// 测试用：直接增加任务计数
|
|
common.Register(int(taskproto.TaskPacketID_PACKET_CSDebugInc), taskproto.CSTaskDebugInc{}, CSTaskDebugInc)
|
|
}
|
|
|
|
// GetTaskTimes 获取任务完成进度
|
|
func GetTaskTimes(p *Player, id int32) int64 {
|
|
if p.WelfData != nil && p.WelfData.Task[id] != nil {
|
|
return p.WelfData.Task[id].N
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// IsTaskFinish 是否任务完成
|
|
func IsTaskFinish(p *Player, id int32) bool {
|
|
data := srvdata.PBDB_TaskMgr.GetData(id)
|
|
if data == nil {
|
|
return false
|
|
}
|
|
if p.WelfData != nil && p.WelfData.Task[id] != nil {
|
|
return p.WelfData.Task[id].N >= data.GetTargetTimes()
|
|
}
|
|
return false
|
|
}
|
|
|
|
// IsTaskReward 是否任务奖励已领取
|
|
func IsTaskReward(p *Player, id int32) bool {
|
|
if p.WelfData != nil && p.WelfData.Task != nil {
|
|
if data := p.WelfData.Task[id]; data != nil && data.Ts > 0 {
|
|
t := srvdata.PBDB_TaskMgr.GetData(id)
|
|
switch t.ActivityType {
|
|
case common.TaskActivityTypeEveryDay, common.TaskActivityTypePermitEveryDay:
|
|
if common.TsInSameDay(time.Now().Unix(), data.Ts) {
|
|
return true
|
|
}
|
|
|
|
case common.TaskActivityTypeWeek:
|
|
if common.TsInSameWeek(time.Now().Unix(), data.Ts) {
|
|
return true
|
|
}
|
|
|
|
case common.TaskActivityTypeNovice, common.TaskActivityTypeInvite, common.TaskActivityTypeAchieve:
|
|
if data.Ts > 0 {
|
|
return true
|
|
}
|
|
case common.TaskActivityTypePermit:
|
|
startTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs
|
|
endTs := PlatformMgrSingleton.GetConfig(p.Platform).PermitEndTs
|
|
if startTs > 0 {
|
|
return data.Ts >= startTs && data.Ts < endTs
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func SendReward(p *Player, m map[int64]int64, tp int32) {
|
|
isPermit := p.GetIsPermit()
|
|
var items []*Item
|
|
for k, v := range m {
|
|
if k == common.ItemIDPermit && isPermit {
|
|
v += int64(float64(v) * common.PermitAdd)
|
|
}
|
|
items = append(items, &Item{
|
|
ItemId: int32(k),
|
|
ItemNum: v,
|
|
})
|
|
}
|
|
gain := int32(0)
|
|
giveType := int32(-1)
|
|
switch tp {
|
|
case 1:
|
|
gain = common.GainWayItemTaskEveryDay
|
|
giveType = model.SystemFreeGive_GiveType_TaskEveryDay
|
|
case 2:
|
|
gain = common.GainWayItemWeekActive
|
|
giveType = model.SystemFreeGive_GiveType_TaskWeekActive
|
|
case 3:
|
|
gain = common.GainWayItemTaskNewPlayer
|
|
giveType = model.SystemFreeGive_GiveType_TaskNewPlayer
|
|
case 4:
|
|
gain = common.GainWayItemTaskInvite
|
|
giveType = model.SystemFreeGive_GiveType_TaskInvite
|
|
case 5:
|
|
gain = common.GainWayItemTaskAchievement
|
|
giveType = model.SystemFreeGive_GiveType_TaskAchievement
|
|
case 6:
|
|
gain = common.GainWayItemTaskPermit
|
|
giveType = model.SystemFreeGive_GiveType_TaskPermit
|
|
}
|
|
BagMgrSingleton.AddItems(p, items, 0, gain, "system", "任务奖励", 0, 0, false)
|
|
for _, v := range items {
|
|
tp := int32(-1)
|
|
if v.ItemId == common.ItemIDCoin {
|
|
tp = model.SystemFreeGive_CoinType_Coin
|
|
} else if v.ItemId == common.ItemIDDiamond {
|
|
tp = model.SystemFreeGive_CoinType_Diamond
|
|
}
|
|
if !p.IsRob && tp >= 0 && giveType >= 0 {
|
|
LogChannelSingleton.WriteMQData(
|
|
model.GenerateSystemFreeGive(p.SnId, p.Name, p.Platform, p.Channel, giveType, tp, v.ItemNum))
|
|
}
|
|
}
|
|
}
|
|
|
|
func CSTaskList(s *netlib.Session, packetId int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSTaskList %v", data)
|
|
msg, ok := data.(*taskproto.CSTaskList)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
ret := &taskproto.SCTaskList{
|
|
Tp: msg.GetTp(),
|
|
}
|
|
|
|
for _, v := range srvdata.TaskMgr.GetActivityType(msg.GetTp()) {
|
|
item := &taskproto.TaskData{
|
|
Id: v.Id,
|
|
N: GetTaskTimes(p, v.Id),
|
|
TargetN: v.GetTargetTimes(),
|
|
Status: 0,
|
|
Reward: v.GetAward(),
|
|
TaskType: v.GetTaskType(),
|
|
}
|
|
if item.N > item.TargetN {
|
|
item.N = item.TargetN
|
|
}
|
|
if IsTaskReward(p, v.Id) {
|
|
item.Status = TaskStateReward
|
|
} else if IsTaskFinish(p, v.Id) {
|
|
item.Status = TaskStateFinish
|
|
}
|
|
ret.List = append(ret.List, item)
|
|
}
|
|
p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCTaskList), ret)
|
|
logger.Logger.Tracef("SCTaskList %v", ret)
|
|
return nil
|
|
}
|
|
|
|
func CSTaskReward(s *netlib.Session, packetId int, data interface{}, sid int64) error {
|
|
logger.Logger.Tracef("CSTaskReward %v", data)
|
|
msg, ok := data.(*taskproto.CSTaskReward)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
now := time.Now()
|
|
|
|
ret := &taskproto.SCTaskReward{
|
|
OpCode: taskproto.OpResultCode_OPRC_Error,
|
|
Tp: msg.GetTp(),
|
|
Id: msg.GetId(),
|
|
Reward: make(map[int64]int64),
|
|
}
|
|
isPermit := p.GetIsPermit()
|
|
f := func(id int32) {
|
|
if IsTaskFinish(p, id) && !IsTaskReward(p, id) {
|
|
p.WelfData.Task[id].Ts = time.Now().Unix()
|
|
// 任务完成记录
|
|
taskLog := &model.BackendPermitTask{
|
|
Platform: p.Platform,
|
|
StartTs: PlatformMgrSingleton.GetConfig(p.Platform).PermitStartTs,
|
|
SnId: p.SnId,
|
|
TaskId: id,
|
|
Ts: now.Unix(),
|
|
}
|
|
data := srvdata.PBDB_TaskMgr.GetData(id)
|
|
if data != nil {
|
|
SendReward(p, data.Award, msg.Tp)
|
|
for k, vv := range data.GetAward() {
|
|
if k == common.ItemIDPermit && isPermit {
|
|
vv += int64(float64(vv) * common.PermitAdd)
|
|
}
|
|
ret.Reward[k] = ret.Reward[k] + vv
|
|
}
|
|
for k, v := range ret.Reward {
|
|
taskLog.Gain = append(taskLog.Gain, model.AwardItem{
|
|
Id: int32(k),
|
|
Num: v,
|
|
})
|
|
}
|
|
taskLog.TaskName = data.GetDes()
|
|
taskLog.ActivityType = data.GetActivityType()
|
|
taskLog.TaskType = data.GetTaskType()
|
|
}
|
|
LogChannelSingleton.WriteLog(taskLog)
|
|
ret.OpCode = taskproto.OpResultCode_OPRC_Success
|
|
}
|
|
}
|
|
|
|
if msg.Tp > 0 && msg.Id == 0 {
|
|
// 一键领取
|
|
for _, v := range srvdata.TaskMgr.GetActivityType(msg.GetTp()) {
|
|
f(v.GetId())
|
|
}
|
|
ret.OpCode = taskproto.OpResultCode_OPRC_Success
|
|
} else {
|
|
f(msg.GetId())
|
|
}
|
|
|
|
p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCTaskReward), ret)
|
|
logger.Logger.Tracef("SCTaskReward %v", ret)
|
|
return nil
|
|
}
|
|
|
|
func CSTaskDebugInc(s *netlib.Session, packetId int, data interface{}, sid int64) error {
|
|
if !common.Config.IsDevMode {
|
|
return nil
|
|
}
|
|
|
|
logger.Logger.Tracef("CSTaskDebugInc %v", data)
|
|
msg, ok := data.(*taskproto.CSTaskDebugInc)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
p := PlayerMgrSington.GetPlayer(sid)
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
|
|
id := msg.GetId()
|
|
taskType := int32(-1)
|
|
d := srvdata.PBDB_TaskMgr.GetData(id)
|
|
if d != nil {
|
|
taskType = d.TaskType
|
|
}
|
|
|
|
p.ResetTaskN(taskType)
|
|
TaskSubjectSingleton.Touch(int(taskType), &TaskData{
|
|
SnId: p.SnId,
|
|
Num: int64(msg.GetAddNum()),
|
|
Debug: true,
|
|
})
|
|
|
|
ret := &taskproto.SCTaskDebugInc{
|
|
OpCode: taskproto.OpResultCode_OPRC_Success,
|
|
}
|
|
p.SendToClient(int(taskproto.TaskPacketID_PACKET_SCDebugInc), ret)
|
|
logger.Logger.Tracef("CSTaskDebugInc %v", ret)
|
|
return nil
|
|
}
|