651 lines
20 KiB
Go
651 lines
20 KiB
Go
package game
|
||
|
||
import (
|
||
"fmt"
|
||
activityCfg "server/conf/activity"
|
||
catnipCfg "server/conf/catnip"
|
||
dailyTaskCfg "server/conf/daily_task"
|
||
guesscolorCfg "server/conf/guess_color"
|
||
languageCfg "server/conf/language"
|
||
miningCfg "server/conf/mining"
|
||
orderCfg "server/conf/order"
|
||
passCfg "server/conf/pass"
|
||
raceCfg "server/conf/race"
|
||
"server/game/mod/activity"
|
||
"server/game/mod/item"
|
||
"server/game/mod/mail"
|
||
GoUtil "server/game_util"
|
||
"server/msg"
|
||
|
||
"gitea.bywaystudios.com/pet_home/leaf/log"
|
||
)
|
||
|
||
// 活动模块 登录
|
||
func (p *Player) ActivityLogin() {
|
||
ItemMod := p.PlayMod.getItemMod()
|
||
// 通用登录处理：检查旧Activity道具并通过邮件退还
|
||
handleSimpleLogin := func(actType int, loginFn func(int) int) {
|
||
ActivityId := p.GetActivityId(actType)
|
||
OldId := loginFn(ActivityId)
|
||
if OldId == 0 {
|
||
return
|
||
}
|
||
var ItemId int
|
||
switch actType {
|
||
case activity.ACT_TYPE_MINING:
|
||
ItemId = miningCfg.GetActivityItemId(OldId)
|
||
case activity.ACT_TYPE_GUESS_COLOR:
|
||
ItemId = guesscolorCfg.GetActivityItemId(OldId)
|
||
case activity.ACT_TYPE_RACE:
|
||
ItemId = raceCfg.GetCoin(OldId)
|
||
case activity.ACT_TYPE_PASS:
|
||
ItemId = passCfg.GetActivityItemId(OldId)
|
||
default:
|
||
return
|
||
}
|
||
ItemNum := ItemMod.GetItem(ItemId)
|
||
if ItemNum != 0 {
|
||
ItemMod.AddItem(ItemId, -ItemNum)
|
||
p.SendActivityMail(item.ITEM_ENERGY_ID, ItemNum, OldId, nil)
|
||
}
|
||
}
|
||
|
||
// 挖矿
|
||
handleSimpleLogin(activity.ACT_TYPE_MINING, p.PlayMod.getMiningMod().Login)
|
||
// 猜颜色
|
||
handleSimpleLogin(activity.ACT_TYPE_GUESS_COLOR, p.PlayMod.getGuessColorMod().Login)
|
||
// 赛跑
|
||
handleSimpleLogin(activity.ACT_TYPE_RACE, p.PlayMod.getRaceMod().Login)
|
||
// 猫草大作战
|
||
catnipActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
oldId, catnipUnReward := CatnipMod.Login(catnipActivityId)
|
||
if oldId != 0 && len(catnipUnReward) > 0 {
|
||
// 清空猫草大作战数据无需发邮件
|
||
MailMod := p.PlayMod.getMailMod()
|
||
MailMod.SendMail(&mail.MailStruct{
|
||
Title: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, "backend_gardenend_mail_title"),
|
||
TitleEn: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, "backend_gardenend_mail_title"),
|
||
Content: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, "backend_gardenend_mail_content"),
|
||
ContentEn: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, "backend_gardenend_mail_content"),
|
||
TitlePtBr: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, "backend_gardenend_mail_title"),
|
||
ContentPtBr: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, "backend_gardenend_mail_content"),
|
||
TitleEsLatam: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_title"),
|
||
ContentEsLatam: languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, "backend_gardenend_mail_content"),
|
||
Items: catnipUnReward,
|
||
Type: mail.MAIL_TYPE_NORMAL,
|
||
})
|
||
}
|
||
|
||
// 通行证
|
||
passActivityId := p.GetActivityId(activity.ACT_TYPE_PASS)
|
||
PassMod := p.PlayMod.getPassMod()
|
||
passOldId := PassMod.Login(passActivityId)
|
||
if passOldId != 0 {
|
||
ItemId := passCfg.GetActivityItemId(passOldId)
|
||
ItemNum := PassMod.Num
|
||
RewardItems, _ := PassMod.GetRewardItems()
|
||
if ItemNum != 0 {
|
||
ItemMod.AddItem(ItemId, -ItemNum)
|
||
p.SendActivityMail(ItemId, ItemNum, passActivityId, RewardItems)
|
||
}
|
||
}
|
||
// 初始化活动道具
|
||
initItem := p.GetMiningMod().GetInitItem()
|
||
if len(initItem) > 0 {
|
||
err := p.HandleItem(initItem, "")
|
||
if err != nil {
|
||
log.Debug("ActivityLogin initItem err : %s", err)
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// 发送活动邮件
|
||
func (p *Player) SendActivityMail(ItemId, ItemNum, ActivityId int, RewardItems []*item.Item) {
|
||
MailMod := p.PlayMod.getMailMod()
|
||
activity_title_key, mail_title_key, mail_content_key := activityCfg.GetActivityRecycleMail(ActivityId)
|
||
activity_title_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, activity_title_key)
|
||
activity_title_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, activity_title_key)
|
||
activity_title_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, activity_title_key)
|
||
activity_title_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, activity_title_key)
|
||
mt_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_title_key)
|
||
mc_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_content_key)
|
||
mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_title_key)
|
||
mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_content_key)
|
||
mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_title_key)
|
||
mc_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_content_key)
|
||
mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_title_key)
|
||
mc_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_content_key)
|
||
Items := []*item.Item{item.NewItem(ItemId, ItemNum)}
|
||
Items = append(Items, RewardItems...)
|
||
MailMod.SendMail(&mail.MailStruct{
|
||
Title: fmt.Sprintf(mt_zh, activity_title_zh),
|
||
Content: fmt.Sprintf(mc_zh, activity_title_zh),
|
||
TitleEn: fmt.Sprintf(mt_en, activity_title_en),
|
||
ContentEn: fmt.Sprintf(mc_en, activity_title_en),
|
||
TitlePtBr: fmt.Sprintf(mt_pt, activity_title_pt),
|
||
ContentPtBr: fmt.Sprintf(mc_pt, activity_title_pt),
|
||
TitleEsLatam: fmt.Sprintf(mt_es, activity_title_es),
|
||
ContentEsLatam: fmt.Sprintf(mc_es, activity_title_es),
|
||
Items: Items,
|
||
Type: mail.MAIL_TYPE_NORMAL,
|
||
})
|
||
}
|
||
|
||
// 发送活动邮件
|
||
func (p *Player) SendActivityMail2(items []*item.Item, mail_title, mail_content string) {
|
||
MailMod := p.PlayMod.getMailMod()
|
||
mt_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_title)
|
||
mc_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_content)
|
||
mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_title)
|
||
mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_content)
|
||
mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_title)
|
||
mc_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_content)
|
||
mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_title)
|
||
mc_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_content)
|
||
MailMod.SendMail(&mail.MailStruct{
|
||
Title: mt_zh,
|
||
Content: mc_zh,
|
||
TitleEn: mt_en,
|
||
ContentEn: mc_en,
|
||
TitlePtBr: mt_pt,
|
||
ContentPtBr: mc_pt,
|
||
TitleEsLatam: mt_es,
|
||
ContentEsLatam: mc_es,
|
||
Items: items,
|
||
Type: mail.MAIL_TYPE_NORMAL,
|
||
})
|
||
}
|
||
|
||
// 活动模块 零点更新
|
||
func (p *Player) ActivityZeroUpdate() {
|
||
p.CatReturnGiftZeroUpdate()
|
||
p.ActivityLogin()
|
||
type zeroHandler struct {
|
||
actType int
|
||
updateFn func(int)
|
||
}
|
||
handlers := []zeroHandler{
|
||
{activity.ACT_TYPE_MINING, func(id int) { p.PlayMod.getMiningMod().ZeroUpdate(id) }},
|
||
{activity.ACT_TYPE_GUESS_COLOR, func(id int) { p.PlayMod.getGuessColorMod().ZeroUpdate(id) }},
|
||
{activity.ACT_TYPE_RACE, func(id int) { p.PlayMod.getRaceMod().ZeroUpdate(id) }},
|
||
{activity.ACT_TYPE_PASS, func(id int) { p.PlayMod.getPassMod().ZeroUpdate(id) }},
|
||
{activity.ACT_TYPE_CATNIP, func(id int) { p.PlayMod.getCatnipMod().ZeroUpdate(id) }},
|
||
}
|
||
for _, h := range handlers {
|
||
if info := p.GetActivityInfo(h.actType); info != nil {
|
||
h.updateFn(info.Id)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 猫猫回礼0点更新
|
||
func (p *Player) CatReturnGiftZeroUpdate() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CAT_RETURN_GIFT)
|
||
var aid int
|
||
var id int
|
||
if activityInfo != nil {
|
||
id = activityInfo.Id
|
||
aid = activityInfo.AId
|
||
}
|
||
oldId, oldScore, oldReward := p.GetCatReturnGiftMod().ZeroUpdate(id, aid)
|
||
if oldId != 0 {
|
||
log.Debug("CatReturnGiftZeroUpdate oldId : %d, oldScore : %d, oldReward : %d", oldId, oldScore, oldReward)
|
||
cfg := G_GameLogicPtr.ActivityMgr.GetCatReturnGiftCfg(oldId)
|
||
items := make([]*item.Item, 0)
|
||
if cfg != nil {
|
||
for _, v := range cfg.RewardList {
|
||
if oldScore >= int(v.Score) && oldReward < int(v.Id) {
|
||
items = append(items, item.MsgToItem(v.Reward)...)
|
||
}
|
||
}
|
||
}
|
||
if len(items) > 0 {
|
||
p.SendActivityMail2(items, "backend_milestone_mail_title", "backend_milestone_mail_content")
|
||
}
|
||
}
|
||
}
|
||
|
||
// 获取活动信息
|
||
func (p *Player) GetActivityInfo(actType int) *ActivityInfo {
|
||
for _, v := range p.activity {
|
||
if v.Type == actType {
|
||
return v
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 获取活动ID
|
||
func (p *Player) GetActivityId(actType int) int {
|
||
for _, v := range p.activity {
|
||
if v.Type == actType {
|
||
return v.Id
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// 根据活动ID获取活动信息
|
||
func (p *Player) GetActivityInfoById(Id int) *ActivityInfo {
|
||
for _, v := range p.activity {
|
||
if v.Id == Id {
|
||
return v
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 获取活动状态
|
||
func (p *Player) GetActivityStatus(actType int) int {
|
||
activityInfo := p.GetActivityInfo(actType)
|
||
if activityInfo == nil {
|
||
return ACT_STATUS_NOT_START
|
||
}
|
||
now := GoUtil.Now()
|
||
if now < activityInfo.StartT {
|
||
return ACT_STATUS_NOT_START
|
||
}
|
||
if now > activityInfo.EndT {
|
||
return ACT_STATUS_END
|
||
}
|
||
return ACT_STATUS_START
|
||
}
|
||
|
||
// 挖矿活动数据返回
|
||
func (p *Player) MiningBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
status := p.GetActivityStatus(activity.ACT_TYPE_MINING)
|
||
template := miningCfg.GetTemplate(activityInfo.Id)
|
||
DecorateMod := p.PlayMod.getDecorateMod()
|
||
orderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
|
||
passRewardList := miningCfg.GetPassItemList(orderFactor)
|
||
resPassRewardList := make(map[int32]*msg.ItemList)
|
||
for k, v := range passRewardList {
|
||
resPassRewardList[int32(k)] = item.ItemListToMsg(v)
|
||
}
|
||
MiningMod := p.PlayMod.getMiningMod()
|
||
p.PushClientRes(&msg.ResMining{
|
||
Id: int32(activityInfo.Id),
|
||
Status: int32(status),
|
||
EndTime: int32(activityInfo.EndT),
|
||
Template: int32(template),
|
||
Pass: int32(MiningMod.GetPass()),
|
||
Gem: GoUtil.IntToInt32(MiningMod.GetGem()),
|
||
Map: MiningMod.GetMap(),
|
||
Mining: int32(MiningMod.GetMining()),
|
||
PassReward: resPassRewardList,
|
||
})
|
||
}
|
||
|
||
// 猜颜色活动数据返回
|
||
func (p *Player) GuessColorBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_GUESS_COLOR)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
|
||
status := p.GetActivityStatus(activity.ACT_TYPE_GUESS_COLOR)
|
||
GuessColorMod := p.PlayMod.getGuessColorMod()
|
||
mapList := make([]*msg.GuessColorInfo, 0, len(GuessColorMod.MapList))
|
||
for _, v := range GuessColorMod.MapList {
|
||
mapList = append(mapList, &msg.GuessColorInfo{
|
||
Map: v,
|
||
})
|
||
}
|
||
p.PushClientRes(&msg.ResGuessColor{
|
||
Id: int32(activityInfo.Id),
|
||
Status: int32(status),
|
||
EndTime: int32(activityInfo.EndT),
|
||
Pass: int32(GuessColorMod.Pass),
|
||
Opponent: &msg.Opponent{
|
||
Name: GuessColorMod.Opponent.Name,
|
||
Face: int32(GuessColorMod.Opponent.Face),
|
||
Avatar: int32(GuessColorMod.Opponent.Avatar),
|
||
Progress: int32(GuessColorMod.Opponent.Progress),
|
||
},
|
||
WinTime: int32(GuessColorMod.WinTime),
|
||
MapList: mapList,
|
||
OMap: GuessColorMod.OMap,
|
||
})
|
||
}
|
||
|
||
// 赛跑活动数据返回
|
||
func (p *Player) RaceBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_RACE)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
status := p.GetActivityStatus(activity.ACT_TYPE_RACE)
|
||
RaceMod := p.PlayMod.getRaceMod()
|
||
opponent := make([]*msg.Raceopponent, 0, len(RaceMod.Opponent))
|
||
for _, v := range RaceMod.Opponent {
|
||
opponent = append(opponent, &msg.Raceopponent{
|
||
Id: int32(v.Id),
|
||
Name: v.Name,
|
||
Face: int32(v.Face),
|
||
Avatar: int32(v.Avatar),
|
||
Progress: int32(v.Progress),
|
||
})
|
||
}
|
||
p.PushClientRes(&msg.ResRace{
|
||
Id: int32(activityInfo.Id),
|
||
Status: int32(status),
|
||
EndTime: int32(activityInfo.EndT),
|
||
Pass: int32(RaceMod.Pass),
|
||
GameStartTime: int32(RaceMod.StartTime),
|
||
Progress: int32(RaceMod.Progress),
|
||
GameEndTime: int32(RaceMod.EndTime),
|
||
Opponent: opponent,
|
||
Rank: int32(RaceMod.Rank),
|
||
})
|
||
}
|
||
|
||
// 红点数据返回
|
||
func (p *Player) RedBackData() {
|
||
result := make(map[int32]int32)
|
||
now := GoUtil.Now()
|
||
for _, v := range p.activity {
|
||
if v.StartT < now && v.EndT > now {
|
||
result[int32(v.Type)] = int32(p.GetRed(v))
|
||
}
|
||
}
|
||
p.PushClientRes(&msg.ResActRed{Red: result})
|
||
}
|
||
|
||
func (p *Player) GetMiningItemId() int {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
|
||
if activityInfo == nil {
|
||
return 0
|
||
}
|
||
return miningCfg.GetActivityItemId(activityInfo.Id)
|
||
}
|
||
|
||
// 通行证活动数据返回
|
||
func (p *Player) ActPassBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
status := p.GetActivityStatus(activity.ACT_TYPE_PASS)
|
||
template := passCfg.GetTemplate(activityInfo.Id)
|
||
PassMod := p.PlayMod.getPassMod()
|
||
p.PushClientRes(&msg.ResActPass{
|
||
Id: int32(activityInfo.Id),
|
||
Status: int32(status),
|
||
Template: int32(template),
|
||
EndTime: int32(activityInfo.EndT),
|
||
LowPass: PassMod.LowPass > 0,
|
||
HighPass: PassMod.HighPass > 0,
|
||
Score: int32(PassMod.Num),
|
||
Reward: GoUtil.IntToInt32(PassMod.Reward),
|
||
})
|
||
}
|
||
|
||
// 获取活动道具
|
||
func (p *Player) GetActivityItem(ActType []int) []*item.Item {
|
||
items := make([]*item.Item, 0)
|
||
now := GoUtil.Now()
|
||
for _, v := range ActType {
|
||
activityInfo := p.GetActivityInfo(v)
|
||
if activityInfo == nil {
|
||
continue
|
||
}
|
||
status := ACT_STATUS_START
|
||
if now < activityInfo.StartT {
|
||
status = ACT_STATUS_NOT_START
|
||
} else if now > activityInfo.EndT {
|
||
status = ACT_STATUS_END
|
||
}
|
||
if status != ACT_STATUS_START {
|
||
continue
|
||
}
|
||
switch v {
|
||
case activity.ACT_TYPE_MINING:
|
||
itemInfo := miningCfg.GetLoseItem(activityInfo.Id)
|
||
items = item.Merge(items, itemInfo)
|
||
case activity.ACT_TYPE_GUESS_COLOR:
|
||
itemInfo := guesscolorCfg.GetLoseItem(activityInfo.Id)
|
||
items = item.Merge(items, itemInfo)
|
||
case activity.ACT_TYPE_RACE:
|
||
itemId := raceCfg.GetCoin(activityInfo.Id)
|
||
itemInfo := item.NewItem(itemId, 1)
|
||
items = append(items, itemInfo)
|
||
case activity.ACT_TYPE_PASS:
|
||
itemId := passCfg.GetActivityItemId(activityInfo.Id)
|
||
itemInfo := item.NewItem(itemId, 1)
|
||
items = append(items, itemInfo)
|
||
}
|
||
}
|
||
return items
|
||
}
|
||
|
||
// 猫草大作战活动数据返回
|
||
func (p *Player) CatnipBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
CatnipMod := p.PlayMod.getCatnipMod()
|
||
status := p.GetActivityStatus(activity.ACT_TYPE_CATNIP)
|
||
if CatnipMod == nil {
|
||
return
|
||
}
|
||
FriendMod := p.PlayMod.getFriendMod()
|
||
gameList := make([]*msg.CatnipGame, 0, len(CatnipMod.Game))
|
||
for _, v := range CatnipMod.Game {
|
||
gameInfo := &msg.CatnipGame{
|
||
Id: int32(v.Id),
|
||
Progress: int32(v.Progress),
|
||
Status: int32(v.Status),
|
||
Reward: GoUtil.SliceIntToInt32(v.Reward),
|
||
Emoji: int32(v.EmojiId),
|
||
FriendProgress: int32(v.PartnerAdd),
|
||
SendEmoji: int32(v.SendEmoji),
|
||
}
|
||
if v.Partner != 0 {
|
||
playerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
|
||
if playerData != nil {
|
||
gameInfo.Partner = playerData
|
||
}
|
||
}
|
||
|
||
gameList = append(gameList, gameInfo)
|
||
}
|
||
tmpData := make(map[int]*msg.CatnipInvite)
|
||
for uid, info := range CatnipMod.InviteList {
|
||
tmpData[uid] = &msg.CatnipInvite{
|
||
Uid: int64(uid),
|
||
Time: info.Time,
|
||
Type: 1,
|
||
}
|
||
}
|
||
for uid, info := range CatnipMod.BeInvitedList {
|
||
tmpData[uid] = &msg.CatnipInvite{
|
||
Uid: int64(uid),
|
||
Time: info.Time,
|
||
Type: 2,
|
||
}
|
||
}
|
||
|
||
for uid := range FriendMod.NewFriendList {
|
||
partnerList := p.GetCatnipPartner(uid)
|
||
if len(GoUtil.IntSlice(partnerList)) >= 4 {
|
||
tmpData[uid] = &msg.CatnipInvite{
|
||
Uid: int64(uid),
|
||
Type: 3,
|
||
}
|
||
continue
|
||
}
|
||
if _, ok := tmpData[uid]; !ok {
|
||
tmpData[uid] = &msg.CatnipInvite{
|
||
Uid: int64(uid),
|
||
Type: 0,
|
||
}
|
||
}
|
||
}
|
||
for _, v := range CatnipMod.Game {
|
||
if invite, ok := tmpData[v.Partner]; ok {
|
||
invite.Type = 4 // 已参与游戏的好友不显示邀请
|
||
}
|
||
}
|
||
inviteList := make([]*msg.CatnipInvite, 0, len(tmpData))
|
||
for _, v := range tmpData {
|
||
resPlayerSimple := G_getGameLogic().GetResSimplePlayerByUid(int(v.Uid))
|
||
if resPlayerSimple != nil {
|
||
v.Player = resPlayerSimple
|
||
}
|
||
inviteList = append(inviteList, v)
|
||
}
|
||
|
||
template := catnipCfg.GetTemplateId(CatnipMod.Id)
|
||
res := &msg.ResCatnip{
|
||
Id: int32(CatnipMod.Id),
|
||
EndTime: int32(activityInfo.EndT),
|
||
Status: int32(status),
|
||
Template: int32(template),
|
||
GameList: gameList,
|
||
Multiply: int32(CatnipMod.Mul),
|
||
FriendList: inviteList,
|
||
}
|
||
p.PushClientRes(res)
|
||
}
|
||
|
||
func (p *Player) GetChampshipActivityId() (int, int) {
|
||
var todayActivityId int
|
||
var yesterdayActivityId int
|
||
activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
|
||
now := GoUtil.Now()
|
||
yesterday := GoUtil.ZeroTimestamp() - 1
|
||
level := p.GetBaseMod().GetLevel()
|
||
for _, v := range activiyCfgList {
|
||
if v.Type != activity.ACT_TYPE_CHAMPION {
|
||
continue
|
||
}
|
||
if v.Level > level {
|
||
continue
|
||
}
|
||
if v.Startime <= now && v.Endtime >= now {
|
||
todayActivityId = v.Id
|
||
}
|
||
if v.Startime <= yesterday && v.Endtime >= yesterday {
|
||
yesterdayActivityId = v.Id
|
||
}
|
||
}
|
||
return todayActivityId, yesterdayActivityId
|
||
}
|
||
|
||
func (p *Player) ChampionshipZeroUpdate() {
|
||
todayActivityId, _ := p.GetChampshipActivityId()
|
||
ChampionshipMod := p.PlayMod.getChampshipMod()
|
||
aid := ChampionshipMod.AId
|
||
var items []*item.Item
|
||
items = p.GetChampshipReward(aid)
|
||
if len(items) > 0 {
|
||
p.SendActivityMail2(items, "backend_championship_mail_title", "backend_championship_mail_content")
|
||
}
|
||
p.PlayMod.getChampshipMod().ZeroUpdate(todayActivityId)
|
||
}
|
||
|
||
func (p *Player) GetChampshipReward(id int) []*item.Item {
|
||
ChampionshipMod := p.PlayMod.getChampshipMod()
|
||
if id == 0 { // 兼容旧数据，之前没有活动id的只要发放一次奖励
|
||
DecorateMod := p.PlayMod.getDecorateMod()
|
||
orderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
|
||
return ChampionshipMod.GetReward(0, orderFactor)
|
||
}
|
||
if ChampionshipMod == nil {
|
||
return nil
|
||
}
|
||
cfg := G_GameLogicPtr.ActivityMgr.GetChampshipCfg(id)
|
||
if cfg == nil {
|
||
return nil
|
||
}
|
||
DecorateMod := p.PlayMod.getDecorateMod()
|
||
orderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
|
||
var maxRewardId int
|
||
var items []*item.Item
|
||
for _, v := range cfg.GetJackpotList() {
|
||
if ChampionshipMod.GetScore() >= int(v.Total) && int(v.Id) > ChampionshipMod.GetRewardId() {
|
||
maxRewardId = int(v.Id)
|
||
items = item.Merge(items, item.MsgToItem(v.Items))
|
||
if v.StarReward > 0 {
|
||
itemNum := GoUtil.FormatStarItemNum(int(v.StarReward), orderFactor)
|
||
starItem := item.NewItem(item.ITEM_STAR_ID, itemNum)
|
||
items = item.Merge(items, []*item.Item{starItem})
|
||
}
|
||
}
|
||
}
|
||
ChampionshipMod.SetRewardId(maxRewardId)
|
||
return items
|
||
}
|
||
|
||
func (p *Player) GetChampshipRankReward(rank, aid int) ([]*item.Item, error) {
|
||
ChampionshipMod := p.PlayMod.getChampshipMod()
|
||
if aid == 0 { // 兼容旧数据，之前没有活动id的只要发放一次奖励
|
||
return ChampionshipMod.GetRankReward(rank, aid)
|
||
}
|
||
if ChampionshipMod == nil {
|
||
return nil, fmt.Errorf("championship mod is nil")
|
||
}
|
||
cfg := G_GameLogicPtr.ActivityMgr.GetChampshipCfg(aid)
|
||
if cfg == nil {
|
||
return nil, fmt.Errorf("championship config is nil")
|
||
}
|
||
rankRewardList := cfg.GetRankList()
|
||
var items []*item.Item
|
||
for _, v := range rankRewardList {
|
||
if rank <= int(v.Max) && rank >= int(v.Min) {
|
||
items = item.Merge(items, item.MsgToItem(v.Items))
|
||
return items, nil
|
||
}
|
||
}
|
||
return nil, fmt.Errorf("no rank reward found for rank %d", rank)
|
||
}
|
||
|
||
func (p *Player) GetDailyTaskActivityId() int {
|
||
var activityId int
|
||
activiyCfgList := G_GameLogicPtr.ActivityMgr.GetActivityList()
|
||
now := GoUtil.Now()
|
||
level := p.GetBaseMod().GetLevel()
|
||
activityIds := dailyTaskCfg.GetActivityIds()
|
||
for _, v := range activiyCfgList {
|
||
if !GoUtil.InArray(v.Type, activityIds) {
|
||
continue
|
||
}
|
||
if v.Level > level {
|
||
continue
|
||
}
|
||
if v.Startime <= now && v.Endtime >= now {
|
||
activityId = v.Id
|
||
break
|
||
}
|
||
}
|
||
return activityId
|
||
}
|
||
|
||
// 猫猫回礼返回
|
||
func (p *Player) CatReturnGiftBackData() {
|
||
activityInfo := p.GetActivityInfo(activity.ACT_TYPE_CAT_RETURN_GIFT)
|
||
if activityInfo == nil {
|
||
return
|
||
}
|
||
cfg := G_GameLogicPtr.ActivityMgr.GetCatReturnGiftCfg(activityInfo.Id)
|
||
if cfg == nil {
|
||
return
|
||
}
|
||
CatReturnGiftMod := p.GetCatReturnGiftMod()
|
||
res := &msg.ResCatReturnGift{
|
||
StartTime: activityInfo.StartT,
|
||
EndTime: activityInfo.EndT,
|
||
Cfg: cfg,
|
||
Score: int32(CatReturnGiftMod.GetScore()),
|
||
Reward: int32(CatReturnGiftMod.GetReward()),
|
||
}
|
||
p.PushClientRes(res)
|
||
}
|