545 lines
14 KiB
Go
545 lines
14 KiB
Go
package game
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"math"
|
||
"server/GoUtil"
|
||
"server/MergeConst"
|
||
"server/conf"
|
||
champshipCfg "server/conf/champship"
|
||
languageCfg "server/conf/language"
|
||
mailCfg "server/conf/mail"
|
||
mergeDataCfg "server/conf/mergeData"
|
||
"server/db"
|
||
"server/game/mod/chess"
|
||
"server/game/mod/item"
|
||
"server/game/mod/mail"
|
||
"server/game/mod/order"
|
||
"server/game/mod/quest"
|
||
"server/msg"
|
||
"server/pkg/github.com/name5566/leaf/log"
|
||
"sort"
|
||
"time"
|
||
)
|
||
|
||
const (
|
||
TRIGGER_PARAM_LV = "lv" // 等级
|
||
TRIGGER_PARAM_REQ = "reg" // 注册天数
|
||
)
|
||
|
||
func (player *Player) MailTrigger(Tr *quest.Trigger) bool {
|
||
MailMod := player.PlayMod.getMailMod()
|
||
TriggerMail := mailCfg.GetTriggerMail()
|
||
t := make([]*mailCfg.TriggerMail, 0)
|
||
for _, v := range TriggerMail {
|
||
if GoUtil.InArray(v.Id, MailMod.TriggerMail) {
|
||
continue
|
||
}
|
||
if Tr.Label != v.Trigger[0] {
|
||
continue
|
||
}
|
||
t = append(t, v)
|
||
}
|
||
if len(t) == 0 {
|
||
return false
|
||
}
|
||
tr := false
|
||
for _, v := range t {
|
||
if checkTriggerCondition(player, v.Trigger) {
|
||
Title := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, v.Title)
|
||
Content := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, v.Content)
|
||
TitleEn := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, v.Title)
|
||
ContentEn := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, v.Content)
|
||
TitlePtBr := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, v.Title)
|
||
ContentPtBr := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, v.Content)
|
||
|
||
MailMod.SendMail(&mail.MailStruct{
|
||
Title: Title,
|
||
SubTitle: "",
|
||
Content: Content,
|
||
TitleEn: TitleEn,
|
||
SubTitleEn: "",
|
||
ContentEn: ContentEn,
|
||
TitlePtBr: TitlePtBr,
|
||
SubTitlePtBr: "",
|
||
ContentPtBr: ContentPtBr,
|
||
Items: v.Items,
|
||
Type: v.Type,
|
||
})
|
||
MailMod.AddTriggerMail(v.Id)
|
||
tr = true
|
||
}
|
||
}
|
||
|
||
return tr
|
||
}
|
||
|
||
func checkTriggerCondition(player *Player, Trigger []string) bool {
|
||
if len(Trigger) < 4 {
|
||
return false
|
||
}
|
||
switch Trigger[1] {
|
||
case TRIGGER_PARAM_LV:
|
||
lv := player.PlayMod.getBaseMod().GetLevel()
|
||
return GoUtil.Compare(lv, Trigger[2], GoUtil.Int(Trigger[3]))
|
||
case TRIGGER_PARAM_REQ:
|
||
reg := player.GetPlayerBaseMod().GetRegisterTime()
|
||
Day := GoUtil.DaysSince(reg)
|
||
return GoUtil.Compare(Day, Trigger[2], GoUtil.Int(Trigger[3]))
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func TriggerShippingOrderOrigin(player *Player, req *msg.ReqShippingOrder) {
|
||
OrderSn := req.OrderSn
|
||
Status := int(req.Status)
|
||
if Status == MergeConst.ORDER_STATUS_CANCEL { // 取消支付
|
||
CancelOrder(player, OrderSn)
|
||
player.PushClientRes(&msg.ResShippingOrder{
|
||
Code: msg.RES_CODE_SUCCESS,
|
||
Msg: "cancel success",
|
||
})
|
||
return
|
||
}
|
||
var err error
|
||
OrderData, err := db.GetPlayerChargeData(OrderSn)
|
||
if err != nil {
|
||
log.Debug("charge shipping GetPlayerChargeData err:%v", err)
|
||
return
|
||
}
|
||
if OrderData.PayStatus == MergeConst.ORDER_STATUS_SHIP {
|
||
log.Debug("charge shipping order already shipped OrderSn:%s", OrderSn)
|
||
return
|
||
}
|
||
// if !conf.Server.GoogleVerify {
|
||
// Order.PayStatus = MergeConst.ORDER_STATUS_PAY
|
||
// return
|
||
// }
|
||
if conf.Server.GameName == "Merge_Pet_online" {
|
||
GoUtil.SendFeishuOrder(int(player.M_DwUin), OrderData.PayChannelOrderId, OrderData.Price, req.ProduceId, OrderData.PayTime, GoUtil.Now())
|
||
}
|
||
log.Debug("[order verify success] Uid:%d;OrderSn:%s;PayOrder:%s;Token:%s", player.M_DwUin, OrderData.OrderId, OrderData.PayChannelOrderId, req.Token)
|
||
player.lock.Lock()
|
||
defer player.lock.Unlock()
|
||
OrderExtraData := &ChargeExtra{}
|
||
if OrderData.PayChannelExtra != "" {
|
||
err = json.Unmarshal([]byte(OrderData.PayChannelExtra), OrderExtraData)
|
||
if err != nil {
|
||
log.Debug("GoogleVerify err:%v", err)
|
||
return
|
||
}
|
||
OrderExtraData.ChargeId = OrderData.ProductId
|
||
}
|
||
if OrderExtraData.Type == 0 {
|
||
Charge(player, int(OrderData.ProductId))
|
||
} else {
|
||
SendCharge(player, OrderExtraData)
|
||
}
|
||
OrderData.PayStatus = MergeConst.ORDER_STATUS_SHIP
|
||
OrderData.ProductName = req.ProduceId
|
||
db.UpdatePlayerChargeData(OrderData)
|
||
player.PlayMod.save()
|
||
orderDataMap := map[string]interface{}{
|
||
"AppId": conf.Server.AppID,
|
||
"ServerId": conf.Server.ServerID,
|
||
"OrderId": OrderData.OrderId,
|
||
"PayChannelOrderId": OrderData.PayChannelOrderId,
|
||
"ProductId": OrderData.ProductId,
|
||
"CreateTime": OrderData.CreateTime,
|
||
"PayTime": OrderData.PayTime,
|
||
"Token": req.Token,
|
||
"Price": OrderData.Price,
|
||
"PayType": OrderData.PayType,
|
||
}
|
||
player.Kafka("pay", orderDataMap)
|
||
player.PushClientRes(&msg.ResShippingOrder{
|
||
Code: msg.RES_CODE_SUCCESS,
|
||
})
|
||
player.SendClientRes()
|
||
}
|
||
|
||
func TriggerShippingOrder(player *Player, req *msg.ReqShippingOrder) {
|
||
OrderSn := req.OrderSn
|
||
Status := int(req.Status)
|
||
if Status == MergeConst.ORDER_STATUS_CANCEL { // 取消支付
|
||
CancelOrder(player, OrderSn)
|
||
player.PushClientRes(&msg.ResShippingOrder{
|
||
Code: msg.RES_CODE_SUCCESS,
|
||
Msg: "cancel success",
|
||
})
|
||
return
|
||
}
|
||
OrderData := &db.SqlChargeOrderStruct{}
|
||
var err error
|
||
n := 0
|
||
for {
|
||
n++
|
||
if n > 14 {
|
||
break
|
||
}
|
||
OrderData, err = GoogleVerify(player, OrderSn, req.ProduceId, req.Token)
|
||
if err != nil {
|
||
log.Debug("GoogleVerify parmas OrderSn：%s; ProduceId:%s; Token:%s", OrderSn, req.ProduceId, req.Token)
|
||
log.Debug("GoogleVerify err:%v", err)
|
||
if n < 5 {
|
||
time.Sleep(1 * time.Second)
|
||
continue
|
||
}
|
||
if n >= 5 && n < 10 {
|
||
time.Sleep(10 * time.Second)
|
||
continue
|
||
}
|
||
if n >= 10 {
|
||
time.Sleep(30 * time.Second)
|
||
continue
|
||
}
|
||
}
|
||
if OrderData.PayStatus != MergeConst.ORDER_STATUS_PAY {
|
||
time.Sleep(1 * time.Second)
|
||
continue
|
||
}
|
||
if OrderData.PayStatus == MergeConst.ORDER_STATUS_PAY {
|
||
break
|
||
}
|
||
}
|
||
if OrderData == nil {
|
||
GoUtil.SendFeishuFatal(int(player.M_DwUin), "GoogleVerify支付校验异常", fmt.Sprintf("GoogleVerify parmas OrderSn：%s; ProduceId:%s; Token:%s; err: %v", OrderSn, req.ProduceId, req.Token, err))
|
||
log.Debug("[order data nil] Uid:%d;OrderSn:%s;PayOrder:%s;", player.M_DwUin, OrderSn, req.ProduceId)
|
||
return
|
||
} else {
|
||
if conf.Server.GameName == "Merge_Pet_online" {
|
||
GoUtil.SendFeishuOrder(int(player.M_DwUin), OrderData.PayChannelOrderId, OrderData.Price, req.ProduceId, OrderData.PayTime, GoUtil.Now())
|
||
}
|
||
}
|
||
log.Debug("[order verify success] Uid:%d;OrderSn:%s;PayOrder:%s;Token:%s", player.M_DwUin, OrderData.OrderId, OrderData.PayChannelOrderId, req.Token)
|
||
player.lock.Lock()
|
||
defer player.lock.Unlock()
|
||
OrderExtraData := &ChargeExtra{}
|
||
if OrderData.PayChannelExtra != "" {
|
||
err = json.Unmarshal([]byte(OrderData.PayChannelExtra), OrderExtraData)
|
||
if err != nil {
|
||
log.Debug("GoogleVerify err:%v", err)
|
||
return
|
||
}
|
||
OrderExtraData.ChargeId = OrderData.ProductId
|
||
}
|
||
if OrderExtraData.Type == 0 {
|
||
Charge(player, int(OrderData.ProductId))
|
||
} else {
|
||
SendCharge(player, OrderExtraData)
|
||
}
|
||
OrderData.PayStatus = MergeConst.ORDER_STATUS_SHIP
|
||
OrderData.ProductName = req.ProduceId
|
||
db.UpdatePlayerChargeData(OrderData)
|
||
player.PlayMod.save()
|
||
orderDataMap := map[string]interface{}{
|
||
"AppId": conf.Server.AppID,
|
||
"ServerId": conf.Server.ServerID,
|
||
"OrderId": OrderData.OrderId,
|
||
"PayChannelOrderId": OrderData.PayChannelOrderId,
|
||
"ProductId": OrderData.ProductId,
|
||
"CreateTime": OrderData.CreateTime,
|
||
"PayTime": OrderData.PayTime,
|
||
"Token": req.Token,
|
||
"Price": OrderData.Price,
|
||
"PayType": OrderData.PayType,
|
||
}
|
||
player.Kafka("pay", orderDataMap)
|
||
player.SendClientRes()
|
||
}
|
||
|
||
func TriggerComfortOrder(p *Player) {
|
||
BaseMod := p.PlayMod.getBaseMod()
|
||
Now := GoUtil.Now()
|
||
Lv := BaseMod.GetLevel()
|
||
|
||
if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 23 {
|
||
return
|
||
}
|
||
OrderMod := p.PlayMod.getOrderMod()
|
||
ChessMod := p.PlayMod.getChessMod()
|
||
OrderMod.ComfortEndTime = int(Now + 86400)
|
||
EmitList := ChessMod.GetEmitList()
|
||
EnergyMul := BaseMod.GetEnergyMul()
|
||
OrderMod.CreateNormalOrder(BaseMod.GetLevel(), EmitList, EnergyMul, order.COMFORT_TYPE)
|
||
}
|
||
|
||
func TriggerSeed(player *Player) {
|
||
ChampshipMod := player.PlayMod.getChampshipMod()
|
||
Items, Score := champshipCfg.GetRewardItems(ChampshipMod.Reward + 1)
|
||
if Score < 50 {
|
||
return
|
||
}
|
||
b := false
|
||
for _, v := range Items {
|
||
if v.Id == item.ITEM_ENERGY_ID {
|
||
b = true
|
||
break
|
||
}
|
||
}
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
if !b {
|
||
BaseMod.SetSeed(false)
|
||
} else {
|
||
BaseMod.SetSeed(true)
|
||
}
|
||
}
|
||
|
||
func TriggerSeedSource(player *Player) {
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
if !BaseMod.GetSeed() {
|
||
return
|
||
}
|
||
Total := 0
|
||
Energy := BaseMod.GetEnergy()
|
||
Total += Energy
|
||
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
ChessList := ChessMod.GetUnlockChessList()
|
||
ChessBuff := ChessMod.GetChessBuf()
|
||
AllChess := append(ChessList, ChessBuff...)
|
||
for _, v := range AllChess {
|
||
ChessColor := mergeDataCfg.GetColorById(v)
|
||
if ChessColor == "Energy" {
|
||
Total += mergeDataCfg.GetSellNumById(v)
|
||
}
|
||
if v == chess.CHESS_ENERGY_CHEST {
|
||
Total += 50
|
||
}
|
||
if v == chess.CHESS_SURPRISE_CHEST_LOCK || v == chess.CHESS_SURPRISE_CHEST {
|
||
Total += 10
|
||
}
|
||
if v == chess.CHESS_SOURCE_CHEST {
|
||
Total += 100
|
||
}
|
||
if v == chess.CHESS_HIGH_SOURCE_CHEST {
|
||
Total += 250
|
||
}
|
||
}
|
||
|
||
Total += (5 - BaseMod.EnergyAD) * 25
|
||
BaseMod.SetSource(Total)
|
||
}
|
||
|
||
func TriggerSeedOrder(player *Player) *order.Order {
|
||
OrderMod := player.PlayMod.getOrderMod()
|
||
ChessMod := player.PlayMod.getChessMod()
|
||
BaseMod := player.PlayMod.getBaseMod()
|
||
if !BaseMod.GetSeed() {
|
||
return nil
|
||
}
|
||
OrderMod.CreatOrderPool(BaseMod.Level, ChessMod.GetOrderEmit(), BaseMod.EnergyMul)
|
||
ChampshipMod := player.PlayMod.getChampshipMod()
|
||
NeedScore := champshipCfg.GetRewardTotalScore(ChampshipMod.Reward + 1)
|
||
E := BaseMod.GetSource()
|
||
ChessList := ChessMod.GetUnlockChessList()
|
||
ChessBuff := ChessMod.GetChessBuf()
|
||
AllChess := append(ChessList, ChessBuff...)
|
||
NewOrder := &order.Order{}
|
||
MaxQ := 0
|
||
MinQ := 0
|
||
// 计算Q值
|
||
for _, Order := range OrderMod.OrderPool {
|
||
Q := 0
|
||
for _, v := range Order.MergeId {
|
||
Color := mergeDataCfg.GetColorById(v)
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
Q1 := int(math.Pow(2, float64(Lv))) - 1
|
||
Q2 := 0
|
||
Q3 := 0
|
||
for _, Chess := range AllChess {
|
||
Lv1 := mergeDataCfg.GetLvById(Chess)
|
||
Color1 := mergeDataCfg.GetColorById(Chess)
|
||
Type := mergeDataCfg.GetTypeById(Chess)
|
||
if Type != "Product" {
|
||
continue
|
||
}
|
||
if Color != Color1 {
|
||
continue
|
||
}
|
||
if Lv1 > Lv {
|
||
continue
|
||
}
|
||
Q2 += int(math.Pow(2, float64(Lv1))) - 1
|
||
}
|
||
for _, Chess := range AllChess {
|
||
if Chess == chess.CHESS_ZIXUAN_CHEST {
|
||
if Lv < 3 {
|
||
continue
|
||
}
|
||
Q3 += int(math.Pow(2, 3)) - 1
|
||
}
|
||
if Chess == chess.CHESS_HIGH_ZIXUAN_CHEST {
|
||
if Lv < 7 {
|
||
continue
|
||
}
|
||
Q3 += int(math.Pow(2, 7)) - 1
|
||
}
|
||
if Chess == chess.CHESS_SOURCE_CHEST {
|
||
if Lv < 3 {
|
||
continue
|
||
}
|
||
Q3 += int(math.Pow(2, 3)) - 1
|
||
Q3 += int(math.Pow(2, 4)) - 1
|
||
}
|
||
if Chess == chess.CHESS_HIGH_SOURCE_CHEST {
|
||
if Lv < 7 {
|
||
continue
|
||
}
|
||
Q3 += int(math.Pow(2, 7)) - 1
|
||
Q3 += int(math.Pow(2, 7)) - 1
|
||
}
|
||
}
|
||
Q += max(Q1-Q2-Q3, 0)
|
||
Order.Q = Q
|
||
MaxQ = max(MaxQ, Q)
|
||
MinQ = min(MinQ, Q)
|
||
}
|
||
}
|
||
|
||
if E > MaxQ {
|
||
return nil
|
||
}
|
||
// 生成订单
|
||
ProduceChessList := []int{}
|
||
for _, v := range AllChess {
|
||
Type := mergeDataCfg.GetTypeById(v)
|
||
if Type != "Product" {
|
||
continue
|
||
}
|
||
ProduceChessList = append(ProduceChessList, v)
|
||
}
|
||
if E == MaxQ {
|
||
for _, Order := range OrderMod.OrderPool {
|
||
if Order.Q == MaxQ {
|
||
NewOrder = Order
|
||
break
|
||
}
|
||
}
|
||
EmitTypeList := []string{}
|
||
for _, v := range NewOrder.MergeId {
|
||
Color := mergeDataCfg.GetColorById(v)
|
||
EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
|
||
EmitTypeList = append(EmitTypeList, EmitType)
|
||
}
|
||
ChessList := []int{}
|
||
for _, v := range ProduceChessList {
|
||
Color := mergeDataCfg.GetColorById(v)
|
||
EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
if Lv < 3 || Lv > 4 {
|
||
continue
|
||
}
|
||
if GoUtil.InStringArray(EmitType, EmitTypeList) {
|
||
continue
|
||
}
|
||
ChessList = append(ChessList, v)
|
||
}
|
||
if len(ChessList) != 0 {
|
||
RandChess := GoUtil.RandSlice(ChessList)
|
||
Color := mergeDataCfg.GetColorById(RandChess)
|
||
Lv := mergeDataCfg.GetLvById(RandChess)
|
||
NewChess := mergeDataCfg.GetChessIdByLvAndColor(Lv, Color)
|
||
NewOrder.MergeId = append(NewOrder.MergeId, NewChess)
|
||
}
|
||
return NewOrder
|
||
}
|
||
|
||
if E == MinQ {
|
||
for _, Order := range OrderMod.OrderPool {
|
||
if Order.Q == MinQ {
|
||
return Order
|
||
}
|
||
}
|
||
}
|
||
|
||
if E < MinQ {
|
||
for _, Order := range OrderMod.OrderPool {
|
||
if Order.Q == MinQ {
|
||
ChessList := []int{}
|
||
for _, v := range ProduceChessList {
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
if Lv < 5 {
|
||
ChessList = append(ChessList, v)
|
||
}
|
||
}
|
||
if len(ChessList) != 0 {
|
||
NewChess := GoUtil.RandSlice(ChessList)
|
||
Order.MergeId = append(Order.MergeId, NewChess)
|
||
}
|
||
return Order
|
||
}
|
||
}
|
||
}
|
||
|
||
if E > MinQ && E < MaxQ {
|
||
L1 := []*order.Order{}
|
||
for _, Order := range OrderMod.OrderPool {
|
||
if Order.Q > E {
|
||
L1 = append(L1, Order)
|
||
}
|
||
}
|
||
Smax := 0
|
||
Smin := 0
|
||
for _, Order := range L1 {
|
||
Score := 0
|
||
for _, v := range Order.MergeId {
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
Score += champshipCfg.GetChessScore(Lv)
|
||
}
|
||
Smax = max(Score, Smax)
|
||
Smin = min(Score, Smin)
|
||
Order.S = Score
|
||
}
|
||
|
||
if NeedScore > Smax {
|
||
for _, Order := range OrderMod.OrderPool {
|
||
if Order.Q == MinQ {
|
||
ChessList := []int{}
|
||
for _, v := range ProduceChessList {
|
||
Lv := mergeDataCfg.GetLvById(v)
|
||
if Lv < 5 {
|
||
ChessList = append(ChessList, v)
|
||
}
|
||
}
|
||
if len(ChessList) != 0 {
|
||
NewChess := GoUtil.RandSlice(ChessList)
|
||
Order.MergeId = append(Order.MergeId, NewChess)
|
||
}
|
||
return Order
|
||
}
|
||
}
|
||
}
|
||
if NeedScore == Smax {
|
||
for _, Order := range L1 {
|
||
if Order.S == Smax {
|
||
return Order
|
||
}
|
||
}
|
||
}
|
||
|
||
if NeedScore == Smin {
|
||
for _, Order := range L1 {
|
||
if Order.S == Smin {
|
||
return Order
|
||
}
|
||
}
|
||
}
|
||
L2 := []*order.Order{}
|
||
for _, Order := range L1 {
|
||
if Order.S > NeedScore {
|
||
L2 = append(L2, Order)
|
||
}
|
||
}
|
||
if len(L2) != 0 {
|
||
sort.Slice(L2, func(i, j int) bool {
|
||
return L2[i].Q < L2[j].Q
|
||
})
|
||
return L2[0]
|
||
}
|
||
}
|
||
return NewOrder
|
||
}
|