订单优化

src/server/GoUtil/randUtil.go

@@ -7,7 +7,7 @@ import (
 
 func RandMap(d map[int]int) int {
 	if len(d) == 0 {
-		return -1
+		return 0
 	}
 	total := 0
 	for _, v := range d {
@@ -26,7 +26,7 @@ func RandMap(d map[int]int) int {
 	}
 
 	// 如果没有找到，返回一个默认值
-	return -1
+	return 0
 }
 
 func RandStringMap(d map[string]int) string {

src/server/game/Gm.go

@@ -196,7 +196,7 @@ func ReqGmCommand_(player *Player, Command string) error {
 		EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
 		OrderMod := player.PlayMod.getOrderMod()
 		OrderMod.LastOrder.Type = 1
-		OrderMod.CreateOrder(Lv, EmitList, EnergyMul)
+		OrderMod.CreateOrder(Lv, EmitList, EnergyMul, order.Common_type)
 		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 	case "resetCardReq":
 		CardMod := player.PlayMod.getCardMod()

src/server/game/PlayerFunc.go

@@ -985,8 +985,21 @@ func (player *Player) GetPetOrderItemExp() int {
 	}
 	return playroomCfg.GetPetOrderItemExpByList(itemList)
 }
-
+func (player *Player) ClearOrder() {
-func (player *Player) FormatOrderReward() {
+	BaseMod := player.PlayMod.getBaseMod()
+	OrderMod := player.PlayMod.getOrderMod()
+	MaxOrderNum := orderCfg.GetOrderNum(BaseMod.GetLevel())
+	n := 0
+	for _, v := range OrderMod.OrderList {
+		if v.Type == order.Common_type || v.Type == order.Pet_type || v.Type == order.Part_type {
+			n++
+		}
+	}
+	for i := n; i < MaxOrderNum; i++ {
+		player.CreateNormalOrder()
+	}
+}
+func (player *Player) CreateNormalOrder() {
 	Exp, PExp := userCfg.GetLevUpExp(player.GetPlayerBaseMod().GetLevel())
 	BaseMod := player.PlayMod.getBaseMod()
 	DecorateMod := player.PlayMod.getDecorateMod()
@@ -995,28 +1008,45 @@ func (player *Player) FormatOrderReward() {
 	ExpCoin := (Exp-BaseMod.GetExp())*decorateCfg.GetAreaPerPExp(DecorateMod.GetAreaId()) - BaseMod.GetStar()
 	PExpCoin := (PExp-BaseMod.GetPExp())*50 - player.GetPetOrderItemExp()
 	OrderMod := player.PlayMod.getOrderMod()
-	if ExpCoin > PExpCoin || BaseMod.GetLevel() < 17 {
+
-		for k, v := range OrderMod.GetOrderList() {
+	// 预热订单
-			if len(v.Items) != 0 {
+	if OrderMod.LastOrder.Type == order.Preheat_type {
-				continue
+		ChessId := OrderMod.LastOrder.MergeId[0]
+		ChessColor := mergeDataCfg.GetColorById(ChessId)
+		PreheatStep := OrderMod.PreheatStep[ChessColor]
+		if PreheatStep < 4 {
+			NewChessId := mergeDataCfg.GetChessIdByLvAndColor(BaseMod.GetEnergyMul()+PreheatStep+1, ChessColor)
+			Items, ok := order.PreheatItems[OrderMod.PreheatStep[ChessColor]]
+			if !ok {
+				Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}))}
 			}
-			if v.Type != order.Common_type {
+			OrderMod.AddPreheatOrder([]int{NewChessId}, order.DIFF_LOW, order.Preheat_type, Items)
-				continue
+			OrderMod.PreheatStep[ChessColor]++
-			}
+			return
-			Star := order.GetOrderStar(v.MergeId)
-			Star = int(float64(Star)*float64(OrderFactor)/10) * 10
-			v.Items = append(v.Items, &item.Item{
-				Id:  item.ITEM_STAR_ID,
-				Num: Star,
-			})
-			OrderMod.OrderList[k] = v
 		}
-	} else {
+	}
+
+	// 安慰订单
+	Now := GoUtil.Now()
+	if OrderMod.LastOrder.Type == order.COMFORT_TYPE && Now < int64(OrderMod.ComfortEndTime) {
+		OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.COMFORT_TYPE)
+		return
+	}
+
+	PetTrigger := true
+	for _, v := range OrderMod.GetOrderList() {
+		if v.Type == order.Pet_type {
+			PetTrigger = false
+			break
+		}
+	}
+	if PExpCoin > ExpCoin && PetTrigger && BaseMod.GetLevel() >= 17 {
+		OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Pet_type)
 		for k, v := range OrderMod.GetOrderList() {
 			if len(v.Items) != 0 {
 				continue
 			}
-			if v.Type != order.Common_type {
+			if v.Type != order.Pet_type {
 				continue
 			}
 			Items := make([]*item.Item, 0)
@@ -1031,7 +1061,45 @@ func (player *Player) FormatOrderReward() {
 			v.Items = Items
 			OrderMod.OrderList[k] = v
 		}
+		return
 	}
+	// if ExpCoin > PExpCoin || BaseMod.GetLevel() < 17 {
+	// 	for k, v := range OrderMod.GetOrderList() {
+	// 		if len(v.Items) != 0 {
+	// 			continue
+	// 		}
+	// 		if v.Type != order.Common_type {
+	// 			continue
+	// 		}
+	// 		Star := order.GetOrderStar(v.MergeId)
+	// 		Star = int(float64(Star)*float64(OrderFactor)/10) * 10
+	// 		v.Items = append(v.Items, &item.Item{
+	// 			Id:  item.ITEM_STAR_ID,
+	// 			Num: Star,
+	// 		})
+	// 		OrderMod.OrderList[k] = v
+	// 	}
+	// } else {
+	// 	for k, v := range OrderMod.GetOrderList() {
+	// 		if len(v.Items) != 0 {
+	// 			continue
+	// 		}
+	// 		if v.Type != order.Common_type {
+	// 			continue
+	// 		}
+	// 		Items := make([]*item.Item, 0)
+	// 		Star := order.GetOrderStar(v.MergeId)
+	// 		Star = int(float64(Star)*float64(OrderFactor)/10) * 10
+	// 		Items = player.GetPetOrderReward(Star, Items)
+	// 		if len(Items) == 1 && Items[0].Id == item.ITEM_STAR_ID {
+	// 			v.Type = order.Common_type
+	// 		} else {
+	// 			v.Type = order.Pet_type
+	// 		}
+	// 		v.Items = Items
+	// 		OrderMod.OrderList[k] = v
+	// 	}
+	// }
 
 	// 触发式订单 满足条件生成零件订单
 	PartCost := DecorateMod.GetPartCost()
@@ -1048,20 +1116,17 @@ func (player *Player) FormatOrderReward() {
 			Trigger2 = true
 		}
 	}
-	if Trigger && Trigger2 {
+	if Trigger && Trigger2 && BaseMod.GetLevel() >= 12 {
+		OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Part_type)
 		for k, v := range OrderMod.GetOrderList() {
-			if v.Type != order.Common_type {
+			if v.Type == order.Part_type {
-				continue
+				v.Items = []*item.Item{item.NewItem(item.ITEM_LAUNCHER_ID, 2)}
+				OrderMod.OrderList[k] = v
 			}
-			if v.Diff == order.DIFF_LOW {
-				continue
-			}
-			v.Items = []*item.Item{item.NewItem(item.ITEM_LAUNCHER_ID, 2)}
-			v.Type = order.Part_type
-			OrderMod.OrderList[k] = v
-			break
 		}
+		return
 	}
+	OrderMod.CreateOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Common_type)
 }
 
 func (player *Player) GetPetOrderReward(Star int, Items []*item.Item) []*item.Item {

src/server/game/RegisterNetworkFunc.go

@@ -144,7 +144,6 @@ func RegSetEneryFunc(player *Player, buf []byte) error {
 	Emit := player.PlayMod.getChessMod().GetOrderEmit()
 	ChessList := player.PlayMod.getChessMod().GetUnlockChessList()
 	OrderMod.ChangeEnergyMul(Lv, Emit, int(req.EnergyMul), ChessList)
-	player.FormatOrderReward()
 	player.PushClientRes(OrderMod.BackData())
 	player.PushClientRes(player.PlayMod.getBaseMod().BackData())
 	return nil
@@ -344,7 +343,7 @@ func ReqRewardOrder(player *Player, buf []byte) error {
 	// 	OrderMod.CreateOrderSeed(NewOrder)
 	// }
 	OrderMod.TriggerOrder(Lv, order.TRIGGER_TYPE_ORDER, Emit, EnergyMul)
-	player.FormatOrderReward()
+	player.CreateNormalOrder()
 	// 存钱罐增加钻石
 	PiggyBankMod := player.PlayMod.getPiggyBankMod()
 	PiggyBankMod.Trigger()

src/server/game/Trigger.go

@@ -157,34 +157,15 @@ func TriggerComfortOrder(p *Player) {
 	Now := GoUtil.Now()
 	Lv := BaseMod.GetLevel()
 
-	if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 17 {
+	if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 23 {
 		return
 	}
 	OrderMod := p.PlayMod.getOrderMod()
 	ChessMod := p.PlayMod.getChessMod()
-	ChessList := ChessMod.GetUnlockChessList()
+	OrderMod.ComfortEndTime = int(Now + 86400)
-	TriggerType := 1
-	for _, Order := range OrderMod.GetOrderList() {
-		if GoUtil.IsContain(ChessList, Order.MergeId) {
-			continue
-		}
-		if Order.Diff == order.DIFF_LOW {
-			return
-		}
-		if Order.Diff == order.DIFF_MID {
-			TriggerType = 2
-		}
-	}
 	EmitList := ChessMod.GetEmitList()
 	EnergyMul := BaseMod.GetEnergyMul()
-	if TriggerType == 1 {
+	OrderMod.CreateNormalOrder(BaseMod.GetLevel(), EmitList, EnergyMul, order.COMFORT_TYPE)
-		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 2)
-		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 3)
-		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_MID, 2)
-	} else {
-		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 2)
-		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 3)
-	}
 }
 
 func TriggerSeed(player *Player) {

src/server/game/UnitTest.go

@@ -48,12 +48,12 @@ func UnitOrder(p *Player) error {
 	for i := 0; i < 100; i++ {
 		//OrderMod.ChessPool = nil
 		//OrderMod.EmitShuffle = nil
-		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul())
+		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetOrderEmit(), BaseMod.GetEnergyMul(), order.Common_type)
 		if err != nil {
 			return err
 		}
 	}
-	p.FormatOrderReward()
+	p.CreateNormalOrder()
 	NumMap := make(map[int]int)
 	for _, v := range OrderMod.OrderList {
 		NumMap[len(v.MergeId)]++
@@ -235,7 +235,7 @@ func UnitOrder2(p *Player, Lv, EnergyMul int) float64 {
 	// fmt.Println(EmitList)
 	// OrderMod.Debug = make(map[int]int)
 	for i := 0; i < 5000; i++ {
-		err := OrderMod.CreateNormalOrder(Lv, Emit, EnergyMul)
+		err := OrderMod.CreateNormalOrder(Lv, Emit, EnergyMul, order.Common_type)
 		log.Debug("OrderMod.CreateNormalOrder %d", i)
 		if err != nil {
 			return 0
@@ -289,7 +289,7 @@ func UnitPlayroomOrder(p *Player) error {
 }
 
 func UnitPetOrder(p *Player) error {
-	p.FormatOrderReward()
+	p.CreateNormalOrder()
 	return nil
 }
 

src/server/game/mod/item/Item.go

@@ -22,6 +22,9 @@ const (
 	ITEM_FIVE_STAR_CARD_PACK = 100008
 	ITEM_RACING_BATTERY_ID   = 100027
 	ITEM_LAUNCHER_ID         = 1602
+	ITEM_LAUNCHER_lOW_ID     = 1601
+	ITEM_ENERGY_GIFT_ID      = 562
+	ITEM_DIAMOND_LV2_ID      = 502
 )
 
 const (

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

@@ -2,7 +2,6 @@ package order
 
 import (
 	"fmt"
-	"log"
 	"server/GoUtil"
 	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mergeDataCfg "server/conf/mergeData"
@@ -31,6 +30,8 @@ type OrderMod struct {
 	IsCharge        bool           // 是否充值
 	AutoEmit        []string       // 自动发射器
 	LastChess       int            // 上次生成订单的棋子
+	NextDiff        int            // 下次订单难度
+	ComfortEndTime  int
 }
 
 type Order struct {
@@ -43,6 +44,12 @@ type Order struct {
 	Items     []*item.Item // 奖励物品
 }
 
+var PreheatItems = map[int][]*item.Item{
+	1: {item.NewItem(item.ITEM_ENERGY_GIFT_ID, 1)},
+	2: {item.NewItem(item.ITEM_DIAMOND_LV2_ID, 1)},
+	3: {item.NewItem(item.ITEM_LAUNCHER_lOW_ID, 1)},
+}
+
 const (
 	Common_type      = 1  // 普通订单
 	Extra_type       = 2  // 额外订单 弃用
@@ -228,9 +235,6 @@ func (o *OrderMod) TriggerOrder(lv int, Type string, Emit []int, EnergyMul int)
 			}
 		}
 	}
-	if lv >= 12 {
-		o.CreateOrder(lv, Emit, EnergyMul)
-	}
 	return nil
 }
 
@@ -290,7 +294,7 @@ func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, Fi
 }
 
 // 生成新订单
-func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
+func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul, OrderType int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
@@ -298,20 +302,8 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 	if o.CreatePriorityOrder(lv, Emit) {
 		return nil
 	}
-	MaxOrderNum := orderCfg.GetOrderNum(lv)
+	err := o.CreateNormalOrder(lv, Emit, EnergyMul, OrderType)
-	n := 0
+	return err
-	for _, v := range o.OrderList {
-		if v.Type == Common_type || v.Type == Clean_type || v.Type == Pet_type || v.Type == Part_type || v.Type == Fixed_type || v.Type == Preview_type {
-			n++
-		}
-	}
-	for i := n; i < MaxOrderNum; i++ {
-		err := o.CreateNormalOrder(lv, Emit, EnergyMul)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
 }
 
 func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
@@ -404,7 +396,7 @@ func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff
 }
 
 // 生成新订单
-func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
+func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul, OrderType int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
@@ -417,7 +409,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 			break
 		}
 		randNum++
-		mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul)
+		mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul, OrderType)
 		if err != nil {
 			continue
 		}
@@ -446,7 +438,6 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 	// 	}
 
 	// }
-	log.Printf("CreateNormalOrder: %v, %v, %v", mergeList, OrderDiff, err)
 	o.addOrder(mergeList, OrderDiff, Common_type)
 	return nil
 }
@@ -485,15 +476,6 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
 	o.addOrder(mergeList, OrderDiff, Super_type)
 	return nil
 }
-func (o *OrderMod) addFixOrder(Id int, ChessList []int, Type int, Items []*item.Item) {
-	Order := Order{
-		MergeId:   ChessList,
-		Type:      Type,
-		Timestamp: time.Now().Unix(),
-		Items:     Items,
-	}
-	o.OrderList[Id] = Order
-}
 func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) int {
 	o.Auto_id++
 	Star := GetOrderStar(ChessList)
@@ -515,6 +497,30 @@ func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) int {
 	o.LastDiff = Diff
 	return o.Auto_id
 }
+func (o *OrderMod) addFixOrder(Id int, ChessList []int, Type int, Items []*item.Item) {
+	Order := Order{
+		MergeId:   ChessList,
+		Type:      Type,
+		Timestamp: time.Now().Unix(),
+		Items:     Items,
+	}
+	o.OrderList[Id] = Order
+}
+func (o *OrderMod) AddPreheatOrder(ChessList []int, Diff int, Type int, Items []*item.Item) int {
+	return o.addPreheatOrder(ChessList, Diff, Type, Items)
+}
+func (o *OrderMod) addPreheatOrder(ChessList []int, Diff int, Type int, Items []*item.Item) int {
+	o.Auto_id++
+	Order := Order{
+		MergeId:   ChessList,
+		Diff:      Diff,
+		Type:      Type,
+		Timestamp: time.Now().Unix(),
+		Items:     Items,
+	}
+	o.OrderList[o.Auto_id] = Order
+	return o.Auto_id
+}
 
 func (o *OrderMod) CreateCleanOrder(ChessList []int) bool {
 	o.addOrder(ChessList, DIFF_LOW, Clean_type)
@@ -581,7 +587,8 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+1, ChessColor[0])
 		if ChessId != 0 {
 			o.PreheatStep[ChessColor[0]] = 1
-			o.addOrder([]int{ChessId}, DIFF_LOW, Preheat_type)
+			Items := PreheatItems[1]
+			o.addPreheatOrder([]int{ChessId}, DIFF_LOW, Preheat_type, Items)
 		}
 	}
 	return b1 || b3
@@ -626,7 +633,6 @@ func (o *OrderMod) CheckSuperOrder() bool {
 * 根据能量倍数 调整订单
  */
 func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList []int) {
-
 	for k, v := range o.OrderList {
 		if v.Type == Preheat_type { // 预热订单 修改倍数时修改棋子等级
 			ChessId := v.MergeId[0]
@@ -637,7 +643,11 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 				continue
 			}
 			delete(o.OrderList, k)
-			o.addOrder([]int{NewChessId}, DIFF_LOW, Preheat_type)
+			Items, ok := PreheatItems[PreheatStep]
+			if !ok {
+				Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, GetOrderStar(ChessList))}
+			}
+			o.addPreheatOrder([]int{NewChessId}, DIFF_LOW, Preheat_type, Items)
 		}
 	}
 
@@ -670,7 +680,7 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 		*/
 		if NeedTrigger {
 			delete(o.OrderList, k)
-			o.CreateNormalOrder(lv, Emit, EnergyMul)
+			o.CreateNormalOrder(lv, Emit, EnergyMul, v.Type)
 		}
 	}
 }

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

@@ -1,6 +1,8 @@
 package order
 
 import (
+	"log"
+	"math"
 	"server/GoUtil"
 	mergeDataCfg "server/conf/mergeData"
 	orderCfg "server/conf/order"
@@ -9,6 +11,84 @@ import (
 
 var reflectChess = map[int]int{} // 棋子难度映射表
 
+var orderCfgMap = map[int]orderConfig{
+	1: {
+		Min: 15,
+		Max: 150,
+		Pool: map[int]orderConfigInfo{
+			1: {lv: 5, energy: 16, t: 1},
+			2: {lv: 6, energy: 32, t: 1},
+			3: {lv: 7, energy: 64, t: 1},
+			4: {lv: 8, energy: 128, t: 1},
+		},
+	},
+	2: {
+		Min: 20,
+		Max: 300,
+		Pool: map[int]orderConfigInfo{
+			2: {lv: 6, energy: 32, t: 1},
+			3: {lv: 7, energy: 64, t: 1},
+			4: {lv: 8, energy: 128, t: 1},
+		},
+	},
+	3: {
+		Min: 40,
+		Max: 400,
+		Pool: map[int]orderConfigInfo{
+			1: {lv: 5, energy: 16, t: 1},
+			2: {lv: 6, energy: 32, t: 1},
+			3: {lv: 7, energy: 64, t: 1},
+			4: {lv: 8, energy: 128, t: 1},
+			5: {lv: 9, energy: 256, t: 1},
+		},
+	},
+	4: {
+		Min: 40,
+		Max: 200,
+		Pool: map[int]orderConfigInfo{
+			1: {lv: 5, energy: 16, t: 0},
+			2: {lv: 6, energy: 32, t: 0},
+			3: {lv: 7, energy: 64, t: 1},
+			4: {lv: 8, energy: 128, t: 1},
+		},
+	},
+	5: {
+		Min: 100,
+		Max: 600,
+		Pool: map[int]orderConfigInfo{
+			1: {lv: 6, energy: 32, t: 0},
+			2: {lv: 7, energy: 64, t: 0},
+			3: {lv: 8, energy: 128, t: 1},
+			4: {lv: 9, energy: 256, t: 1},
+			5: {lv: 10, energy: 512, t: 1},
+		},
+	},
+	6: {
+		Min: 500,
+		Max: 1200,
+		Pool: map[int]orderConfigInfo{
+			1: {lv: 6, energy: 32, t: 0},
+			2: {lv: 7, energy: 64, t: 0},
+			3: {lv: 8, energy: 128, t: 1},
+			4: {lv: 9, energy: 256, t: 1},
+			5: {lv: 10, energy: 512, t: 1},
+			6: {lv: 11, energy: 1024, t: 1},
+		},
+	},
+}
+
+type orderConfig struct {
+	Min  int
+	Max  int
+	Pool map[int]orderConfigInfo
+}
+
+type orderConfigInfo struct {
+	lv     int
+	energy int
+	t      int
+}
+
 // 订单棋子数量
 func getChessNumRand(OrderN int) map[int]int {
 	return map[int]int{
@@ -19,8 +99,23 @@ func getChessNumRand(OrderN int) map[int]int {
 }
 
 // 根据上一个订单难度和系数 生成订单难度
-func getOrderDiffRand(Diff, OrderN int) map[int]int {
+func getOrderDiffRand(Lv, Diff, OrderN int) map[int]int {
 	var d map[int]int
+	if Lv < 24 {
+		switch Diff {
+		case DIFF_MID:
+			d = map[int]int{
+				DIFF_LOW: 50,
+				DIFF_MID: 50,
+			}
+		default:
+			d = map[int]int{
+				DIFF_LOW: 30,
+				DIFF_MID: 70,
+			}
+		}
+		return d
+	}
 	switch Diff {
 	case DIFF_MID:
 		d = map[int]int{
@@ -44,6 +139,32 @@ func getOrderDiffRand(Diff, OrderN int) map[int]int {
 	return d
 }
 
+func getChessByDiff(Lv, Diff, Type int) (int, int, int) {
+	if Type == Common_type {
+		switch Diff {
+		case DIFF_MID:
+			return 100, 600, GoUtil.RandMap(map[int]int{1: 33, 2: 67})
+		case DIFF_HIGH:
+			return 500, 1200, GoUtil.RandMap(map[int]int{1: 67, 2: 33})
+		default:
+			if Lv < 23 {
+				return 15, 150, GoUtil.RandMap(map[int]int{1: 33, 2: 67})
+			}
+			return 30, 200, GoUtil.RandMap(map[int]int{1: 50, 2: 50})
+		}
+	}
+	if Type == Pet_type {
+		return 40, 200, GoUtil.RandMap(map[int]int{1: 50, 2: 50})
+	}
+	if Type == Part_type {
+		return 100, 600, GoUtil.RandMap(map[int]int{1: 50, 2: 50})
+	}
+	if Type == COMFORT_TYPE {
+		return 15, 150, GoUtil.RandMap(map[int]int{1: 33, 2: 67})
+	}
+	return 100, 600, GoUtil.RandMap(map[int]int{1: 50, 2: 50})
+}
+
 // 根据订单难度生成棋子难度
 func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 	var rs map[int]int
@@ -242,10 +363,6 @@ func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) {
 	RandEmitMinLv := mergeDataCfg.GetEmitMinLvById(EmitId)
 	Ratio := mergeDataCfg.GetEmitRatio(EmitId)
 	m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) / Ratio * 100)
-	EmitN := mergeDataCfg.GetEmitN(EmitId)
-	ProductList := mergeDataCfg.GetEmitProduceType(Emit)
-	m = m - (len(ProductList)-2)*10
-	m = m - EmitN*10
 	if IsCharge {
 		m += 10
 	}
@@ -341,7 +458,7 @@ func randOrderChessWithDiff(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDif
 }
 
 // 随机生成订单棋子
-func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int, error) {
+func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul, OrderType int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
 	filterPool(o)
 	OrderN, err := userCfg.GetOrderNByLv(lv)
@@ -351,29 +468,34 @@ func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int,
 	}
 	// 生成订单难度和棋子数量
 	ChessNum := GoUtil.RandMap(RandChessNum)
-	OrderDiffRand := getOrderDiffRand(o.LastDiff, OrderN)
+	OrderDiffRand := getOrderDiffRand(lv, o.LastDiff, OrderN)
 	OrderDiff := GoUtil.RandMap(OrderDiffRand)
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
+	if o.NextDiff != 0 {
-	mergeList := make([]int, 0, len(ChessDiff))
+		OrderDiff = o.NextDiff
-	// 根据订单棋子难度生成棋子
+		o.NextDiff = 0
-	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)
 	}
+	//获取订单体力范围和棋子数量
+	MinEnergy, MaxEnergy, ChessNum := getChessByDiff(lv, OrderDiff, OrderType)
+	mergeList := getChessFromPoolByEnergy(o, MinEnergy, MaxEnergy, ChessNum, Emit, EnergyMul, OrderDiff)
+	// // 根据订单棋子难度生成棋子
+	// 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
 }
 
@@ -532,6 +654,83 @@ func GetChessByDiff(EmitId, EnergyMul, Diff int, Color string) []int {
 	}
 	return GoUtil.UniqueInts(ChessIds)
 }
+func getChessLvFromConfig1(MinEnergy, MaxEnergy, MinLv, MaxLv, LastEnergy int) (int, bool) {
+	rand := []int{}
+	for _, v := range orderCfgMap {
+		if MinEnergy >= v.Min && MaxEnergy <= v.Max {
+			for _, info := range v.Pool {
+				if MinLv <= info.lv && MaxLv >= info.lv && LastEnergy+info.energy <= MaxEnergy && LastEnergy+info.energy >= MinEnergy && info.t == 1 {
+					rand = append(rand, info.lv)
+				}
+			}
+			if len(rand) > 0 {
+				return GoUtil.RandSlice(rand), true
+			}
+			return 6, false
+		}
+	}
+	return 6, false
+}
+
+func getChessLvFromConfig2(MinEnergy, MaxEnergy, MinLv, MaxLv, LastEnergy int) (int, bool) {
+	rand := []int{}
+	for _, v := range orderCfgMap {
+		if MinEnergy >= v.Min && MaxEnergy <= v.Max {
+			for _, info := range v.Pool {
+				if MinLv <= info.lv && MaxLv >= info.lv && LastEnergy+info.energy <= MaxEnergy && LastEnergy+info.energy >= MinEnergy {
+					rand = append(rand, info.lv)
+				}
+			}
+			if len(rand) > 0 {
+				return GoUtil.RandSlice(rand), true
+			}
+			return 0, false
+		}
+	}
+	return 0, false
+}
+func getChessFromPoolByEnergy(o *OrderMod, MinEnergy, MaxEnergy, ChessNum int, Emit []int, EnergyMul, OrderDiff int) []int {
+	ColorArr := make([]string, 0)
+	for i := 0; i < ChessNum; i++ {
+		ColorArr = append(ColorArr, getEmitSeries(o, Emit))
+	}
+	Break := 0
+	for {
+		LastEnergy := 0
+		ChessArr := make([]int, 0)
+		for k, Color := range ColorArr {
+			EmitChessId := getEmitBySeries(Emit, Color)
+			ChessMinLv, ChessMaxLv := getChesslvRange(EmitChessId, EnergyMul, o.IsCharge)
+			ChessLv := 0
+			ok := false
+			if len(ColorArr) == 1 {
+				ChessLv, ok = getChessLvFromConfig1(MinEnergy, MaxEnergy, ChessMinLv, ChessMaxLv, LastEnergy)
+			} else {
+				ChessLv, ok = getChessLvFromConfig2(MinEnergy, MaxEnergy, ChessMinLv, ChessMaxLv, LastEnergy)
+			}
+			LastEnergy += int(math.Pow(2, float64(ChessLv-1)))
+			if !ok && k == 0 && len(ColorArr) == 1 {
+				o.NextDiff = OrderDiff
+			}
+			NewLev := mergeDataCfg.DynamicLev(ChessLv, EmitChessId, Color)
+			MaxLev := mergeDataCfg.GetMaxLvByColor(Color)
+			NewLev = adjustLev(NewLev, EnergyMul)
+			NewLev = min(NewLev, MaxLev)
+			Chess := mergeDataCfg.GetChessIdByLvAndColor(NewLev, Color)
+			ChessArr = append(ChessArr, Chess)
+		}
+		if Break++; Break > 1000 {
+			return ChessArr
+		}
+		if LastEnergy < MinEnergy || LastEnergy > MaxEnergy {
+			continue
+		}
+		if len(ChessArr) > 0 {
+			log.Printf("订单棋子能量:%d,范围:%d-%d,棋子:%v", LastEnergy, MinEnergy, MaxEnergy, ChessArr)
+			return ChessArr
+		}
+	}
+}
 
 // 从棋子池中获取棋子
 func getChessFromPoolByDiff(o *OrderMod, Diff int, Emit []int, EnergyMul int) int {
@@ -647,7 +846,23 @@ func initReflectChess2(Color string, Start, End, Diff, adjust int) {
 
 // 调整棋子等级
 func adjustLev(Lev, EnergyMul int) int {
-	return max(min(Lev, EnergyMul+12), EnergyMul+1)
+	randMapList := map[int]map[int]int{
+		1:  {},
+		2:  {0: 30, 1: 70},
+		3:  {1: 90, 2: 10},
+		4:  {1: 30, 2: 70},
+		5:  {2: 40, 3: 60},
+		6:  {2: 10, 3: 50, 4: 40},
+		7:  {3: 20, 4: 40, 5: 40},
+		8:  {4: 40, 5: 60},
+		9:  {4: 20, 5: 40, 6: 40},
+		10: {5: 40, 6: 60},
+		11: {5: 20, 6: 70, 7: 10},
+	}
+	if v, ok := randMapList[EnergyMul]; ok {
+		Lev += GoUtil.RandMap(v)
+	}
+	return Lev
 }
 
 // 获取发射器系列