Seed订单机制

src/server/conf/champship/ChampshipCfg.go

@@ -62,6 +62,22 @@ func GetReward(Reward, Score int) (int, []*item.Item) {
 	return NewReward, r
 }
 
+func GetRewardItems(Reward int) ([]*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_CHAMPSHIP_JACKPOT, Reward)
+	if err != nil {
+		return nil, 0
+	}
+	return gamedata.GetItemList(data, "Items"), gamedata.GetIntValue(data, "Score")
+}
+
+func GetRewardTotalScore(Reward int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_CHAMPSHIP_JACKPOT, Reward)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Total")
+}
+
 func GetRankReward(Rank int) []*item.Item {
 	data, err := gamedata.GetData(CFG_CHAMPSHIP_RANK)
 	if err != nil {

src/server/conf/mergeData/MergeDataCfg.go

@@ -40,13 +40,18 @@ func GetEmitTypeProduce(EmitType string) []string {
 	return strings.Split(gamedata.GetStringValue(data, "Produce"), ",")
 }
 
-func GetEmitType2(EmitType string) int {
-	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT_TYPE, EmitType)
+func GetEmitTypeByColor(Color string) string {
+	data, err := gamedata.GetData(CFG_MERGE_EMIT)
 	if err != nil {
-		// log.Debug("GetEmitTypeProduce GetOne EmitType:%s not found", EmitType)
-		return 0
+		return ""
 	}
-	return gamedata.GetIntValue(data, "Type2")
+	for _, v := range data {
+		ColorList := strings.Split(gamedata.GetStringValue(data, "Order_Type"), ",")
+		if GoUtil.InStringArray(Color, ColorList) {
+			return gamedata.GetStringValue(v, "Type")
+		}
+	}
+	return ""
 }
 
 func GetEmitProduce(EmitType string) []string {
@@ -200,6 +205,16 @@ func GetColorById(Id int) string {
 	return gamedata.ParseString(data["Color"])
 }
 
+// 根据Id获取棋子类型
+func GetSellNumById(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetColorById GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "SellNum")
+}
+
 // 根据Id获取发射器产出类型
 func GetEmitProduceType(Id int) []string {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)

src/server/game/RegisterNetworkFunc.go

@@ -316,8 +316,13 @@ func ReqRewardOrder(player *Player, buf []byte) error {
 	Lv := player.GetPlayerBaseMod().GetLevel()
 	EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
 	Emit := ChessMod.GetOrderEmit()
-	OrderMod.CreateOrder(Lv, Emit, EnergyMul)
-
+	TriggerSeedSource(player)
+	NewOrder := TriggerSeedOrder(player)
+	if NewOrder == nil {
+		OrderMod.CreateOrder(Lv, Emit, EnergyMul)
+	} else {
+		OrderMod.CreateOrderSeed(NewOrder)
+	}
 	// 存钱罐增加钻石
 	PiggyBankMod := player.PlayMod.getPiggyBankMod()
 	PiggyBankMod.Trigger()
@@ -2359,6 +2364,7 @@ func ReqChampshipReward(player *Player, buf []byte) error {
 	}
 	player.PlayMod.save()
 	BackChampship(player)
+	TriggerSeed(player)
 	player.PushClientRes(&msg.ResChampshipReward{
 		Code: msg.RES_CODE_SUCCESS,
 	})

src/server/game/Trigger.go

@@ -1,13 +1,19 @@
 package game
 
 import (
+	"math"
 	"server/GoUtil"
 	"server/MergeConst"
 	"server/conf"
+	champshipCfg "server/conf/champship"
+	mergeDataCfg "server/conf/mergeData"
 	"server/db"
+	"server/game/mod/chess"
+	"server/game/mod/item"
 	"server/game/mod/order"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
+	"sort"
 	"time"
 )
 
@@ -105,3 +111,272 @@ func TriggerComfortOrder(p *Player) {
 		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 3)
 	}
 }
+
+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
+	}
+
+	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 AllChess {
+			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 AllChess {
+					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 AllChess {
+						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
+}

src/server/game/UnitTest.go

@@ -51,6 +51,15 @@ func UnitOrder(p *Player) error {
 	return nil
 }
 
+func UnitOrderSeed(player *Player) error {
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.Seed = true
+	TriggerSeedSource(player)
+	o := TriggerSeedOrder(player)
+	fmt.Println(o)
+	return nil
+}
+
 func UnitChess(p *Player) error {
 	CardMod := p.PlayMod.getCardMod()
 	for i := 0; i < 1000; i++ {

src/server/game/mod/base/Base.go

@@ -34,6 +34,8 @@ type Base struct {
 	TodayCumulative int  // 今日累计在线时间
 	LoginBack       bool // 回归补偿
 	EnergyAD        int  // 每日看广告获得的能量次数
+	Seed            bool
+	Source          int // 体力资源
 }
 
 func (b *Base) InitData(Uid int) {
@@ -50,6 +52,22 @@ func (b *Base) Login() {
 	b.LogoutTime = 0
 }
 
+func (b *Base) GetSeed() bool {
+	return b.Seed
+}
+
+func (b *Base) SetSeed(Seed bool) {
+	b.Seed = Seed
+}
+
+func (b *Base) GetSource() int {
+	return b.Source
+}
+
+func (b *Base) SetSource(Source int) {
+	b.Source = Source
+}
+
 func (b *Base) GetNickName() string {
 	return b.NickName
 }

src/server/game/mod/chess/Chess.go

@@ -14,12 +14,19 @@ import (
 )
 
 const (
-	ModuleName              = "chess"
-	ChessBoradMaxNum        = 63
-	CHESS_SOURCE_CHEST      = 705
-	CHESS_HIGH_SOURCE_CHEST = 706
-	CHESS_SEPARATE          = 707 // 分解器
-	CHESS_UPGRADE           = 708 // 升级器
+	ModuleName                = "chess"
+	ChessBoradMaxNum          = 63
+	CHESS_ENERGY_CHEST        = 562
+	CHESS_SURPRISE_CHEST_LOCK = 563
+	CHESS_SURPRISE_CHEST      = 564
+	CHESS_ZIXUAN_CHEST        = 701 // 自选宝箱
+	CHESS_HIGH_ZIXUAN_CHEST   = 702 // 高级自选宝箱
+	CHESS_TREASURE_CHEST      = 703 // 宝藏宝箱
+	CHESS_HIGH_TREASURE_CHEST = 704 // 高级宝藏宝箱
+	CHESS_SOURCE_CHEST        = 705 // 资源补给箱
+	CHESS_HIGH_SOURCE_CHEST   = 706 // 高级资源补给箱
+	CHESS_SEPARATE            = 707 // 分解器
+	CHESS_UPGRADE             = 708 // 升级器
 )
 
 type ChessBorad struct {
@@ -88,6 +95,10 @@ func (cb *ChessBorad) ver() {
 	}
 }
 
+func (cb *ChessBorad) GetChessBuf() []int {
+	return cb.ChessBuff
+}
+
 // 棋子合成
 func (cb *ChessBorad) ComposeChess(id int) (int, error) {
 	CfgRecord, err := mergeDataCfg.GetOne(id)

src/server/game/mod/order/Order.go

@@ -25,6 +25,7 @@ type OrderMod struct {
 	PreheatStep     map[string]int // 预热订单步骤
 	EmitShuffle     []string       // 发射器乱序
 	ChessPool       []int          // 棋子池
+	OrderPool       map[int]*Order // 订单池
 }
 
 type Order struct {
@@ -32,6 +33,8 @@ type Order struct {
 	Diff      int   // 难度
 	Type      int   // 类型
 	Timestamp int64 // 时间戳
+	Q         int
+	S         int
 }
 
 const (
@@ -57,6 +60,9 @@ func (o *OrderMod) InitData() {
 	if o.PreheatStep == nil {
 		o.PreheatStep = make(map[string]int)
 	}
+	if o.OrderPool == nil {
+		o.OrderPool = make(map[int]*Order)
+	}
 	if o.Step == 0 {
 		o.OrderList = make(map[int]Order)
 		Cfg := startOrderCfg.GetStartOrderByStep(o.Step + 1)
@@ -103,6 +109,58 @@ func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
 	}
 	return ItemList, MergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
 }
+func (o *OrderMod) CreateOrderSeed(Order *Order) error {
+	for k, v := range o.OrderPool {
+		if v.Timestamp == Order.Timestamp {
+			delete(o.OrderPool, k)
+			break
+		}
+	}
+	o.addOrder(Order.MergeId, Order.Diff, Common_type)
+	return nil
+}
+
+func (o *OrderMod) CreatOrderPool(lv int, Emit []int, EnergyMul int) error {
+	o.OrderPool = make(map[int]*Order)
+	index := 1
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_LOW)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_MID)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_HIGH)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	return nil
+}
 
 // 生成新订单
 func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
@@ -215,6 +273,39 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
 	return false
 }
 
+// 生成新订单
+func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff int) []int {
+	if len(Emit) == 0 {
+		return nil
+	}
+	randNum := 0
+	mergeList := make([]int, 0)
+	var err error
+	for {
+		if randNum > 50 {
+			break
+		}
+		randNum++
+		mergeList, _, err = randOrderChessSeed(o, lv, Emit, EnergyMul, Diff)
+		if err != nil {
+			continue
+		}
+		lastMergelist := o.LastNormalOrder.MergeId
+		conbine := false
+		for _, v := range mergeList {
+			if GoUtil.InArray(v, lastMergelist) {
+				conbine = true
+				break
+			}
+		}
+		if conbine {
+			continue
+		}
+		break
+	}
+	return mergeList
+}
+
 // 生成新订单
 func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {

src/server/game/mod/order/OrderFunc.go

@@ -315,6 +315,39 @@ func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int,
 	return mergeList, OrderDiff, nil
 }
 
+func randOrderChessSeed(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff int) ([]int, int, error) {
+	initReflectChess(Emit, EnergyMul)
+	filterPool(o)
+	OrderN, err := userCfg.GetOrderNByLv(lv)
+	if err != nil {
+		return nil, DIFF_LOW, err
+	}
+	// 生成订单难度和棋子数量
+	ChessNum := 2
+	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
+	mergeList := make([]int, 0, len(ChessDiff))
+	// 根据订单棋子难度生成棋子
+	for _, v := range ChessDiff {
+		ChessId := 0
+		Num := 0
+		for {
+			Num++
+			if Num > 50 {
+				break
+			}
+			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
+			if ChessId == 0 {
+				continue
+			}
+			if !GoUtil.InArray(ChessId, mergeList) {
+				break
+			}
+		}
+		mergeList = append(mergeList, ChessId)
+	}
+	return mergeList, OrderDiff, nil
+}
+
 // 筛选棋子池 从中剔除不符合难度的棋子
 func filterPool(o *OrderMod) {
 	NewPool := make([]int, 0)