Merge branch 'sdk' into online

src/server/GoUtil/sliceUtil.go

@@ -234,3 +234,28 @@ func IntSliceToString(slice []int) string {
 	str = strings.Trim(str, "[]")
 	return str
 }
+
+func PopStringArray(s []string) (string, []string) {
+	if len(s) == 0 {
+		return "", s
+	}
+	return s[0], s[1:]
+}
+
+func ShuffleStringArray(s []string) []string {
+	r := make([]string, len(s))
+	perm := GetRand().Perm(len(s))
+	for i, v := range perm {
+		r[v] = s[i]
+	}
+	return r
+}
+
+func ShuffleArray(s []int) []int {
+	r := make([]int, len(s))
+	perm := GetRand().Perm(len(s))
+	for i, v := range perm {
+		r[v] = s[i]
+	}
+	return r
+}

src/server/conf/mergeData/MergeDataCfg.go

@@ -56,6 +56,15 @@ func GetEmitProduce(EmitType string) []string {
 	return strings.Split(gamedata.GetStringValue(data, "Product_Type"), ",")
 }
 
+func GetEmitOrderProduce(EmitType string) []string {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitType)
+	if err != nil {
+		log.Debug("GetEmitProduce GetOne EmitType:%s not found", EmitType)
+		return []string{}
+	}
+	return strings.Split(gamedata.GetStringValue(data, "Order_Type"), ",")
+}
+
 // 获取单个数据
 func GetOne(Id int) (*gamedata.MergeDataRecord, error) {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
@@ -228,6 +237,15 @@ func GetEmitId(Id int) string {
 	return gamedata.ParseString(data["Emit_ID"])
 }
 
+func GetEmitType(Id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetTypeById GetOne Id:%v not found", Id)
+		return ""
+	}
+	return gamedata.ParseString(data["Emit_Type"])
+}
+
 // 获取常量
 func GetConst(Key string) string {
 	data, err := gamedata.GetDataByKey(CONST_NAME, Key)
@@ -317,3 +335,85 @@ func GetHighSourceChestItem() []*item.Item {
 	r = append(r, item.NewItem(item.ITEM_ENERGY_ID, B4))
 	return r
 }
+
+func DynamicLev(Lv int, EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return Lv
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return Lv
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return Lv - NewLv
+		}
+	}
+	return Lv
+}
+func DynamicLev2(Lv int, EmitId int, Color1 string, Color2 string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return Lv
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return Lv
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	BaseLv := Lv
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color1 == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			BaseLv = Lv + NewLv
+		}
+	}
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color2 == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return BaseLv - NewLv
+		}
+	}
+	return Lv
+}
+
+func DynamicAdjust(EmitId int, Color string) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
+	if err != nil {
+		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
+		return 0
+	}
+	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
+	if DynamicLv == "" {
+		return 0
+	}
+	Arr := strings.Split(DynamicLv, ",")
+	for _, v := range Arr {
+		Arr2 := strings.Split(v, "=")
+		if len(Arr2) != 2 {
+			continue
+		}
+		if Color == Arr2[0] {
+			NewLv, _ := strconv.Atoi(Arr2[1])
+			return NewLv
+		}
+	}
+	return 0
+}

src/server/conf/order/orderCfg.go

@@ -7,11 +7,13 @@ import (
 const (
 	CFG_ORDER_DATA       = "OrderData"
 	CFG_ORDER_CHESS_DATA = "OrderChessData"
+	CFG_ORDER_NUM_DATA   = "OrderNumData"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_ORDER_DATA)
 	gamedata.InitCfg(CFG_ORDER_CHESS_DATA)
+	gamedata.InitCfg(CFG_ORDER_NUM_DATA)
 }
 
 func GetLvMin(EnergyMul int) int {
@@ -39,3 +41,18 @@ func GetLvMax(EnergyMul, N int) int {
 	}
 	return 0
 }
+
+func GetOrderNum(Level int) int {
+	data, err := gamedata.GetData(CFG_ORDER_NUM_DATA)
+	if err != nil {
+		return 0
+	}
+	for _, v := range data {
+		Min := gamedata.GetIntValue(v, "Min")
+		Max := gamedata.GetIntValue(v, "Max")
+		if Level >= Min && Level <= Max {
+			return gamedata.GetIntValue(v, "Num")
+		}
+	}
+	return 0
+}

src/server/game/GameLogic.go

@@ -107,6 +107,7 @@ func (gl *GameLogic) ZeroFlush() {
 	gl.VarMgrSend(MsgMod.MSG_ZERO_UPDATE)       // 零点更新变量
 	gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
 	gl.CreateDailyLogFile()
+	log.Debug("Server ZeroFlush")
 }
 
 // 中午更新
@@ -634,6 +635,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag)           // 从背包中取出棋子
 	RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid)           // 解锁背包格子
 	RegisterMsgProcessFunc("ReqSourceChest", ReqSourceChest)                   // 开宝箱
+	RegisterMsgProcessFunc("ReqSeparateChess", ReqSeparateChess)               // 分解棋子
 
 	RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy) //购买能量
 
@@ -804,6 +806,8 @@ func (ad *GameLogic) InitActivity() {
 }
 
 func (ad *GameLogic) AddLog(Log *Log) {
+	Log.ServerId = conf.Server.ServerID
+	Log.AppId = conf.Server.AppID
 	Log.TimeStamp = time.Now().Unix()
 	go func() {
 		ad.MLogManager.AddLog(Log)

src/server/game/Gm.go

@@ -100,7 +100,9 @@ func ReqGmCommand(args []interface{}) error {
 		Lv := player.GetPlayerBaseMod().GetLevel()
 		EmitList := player.PlayMod.getChessMod().GetEmitList()
 		EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
-		player.PlayMod.getOrderMod().CreateOrder(Lv, EmitList, EnergyMul)
+		OrderMod := player.PlayMod.getOrderMod()
+		OrderMod.LastOrder.Type = 1
+		OrderMod.CreateOrder(Lv, EmitList, EnergyMul)
 		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 	case "resetCardReq":
 		CardMod := player.PlayMod.getCardMod()
@@ -123,10 +125,13 @@ func ReqGmCommand(args []interface{}) error {
 		num, _ := strconv.Atoi(arg[1])
 		player.PlayMod.getLimitedTimeEventMod().Progress = num
 	case "setProgressReward":
+		BaseMod := player.PlayMod.getBaseMod()
+		LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
+		LimitedTimeEventMod.Progress = 5
 		for i := 1; i < 5; i++ {
-			player.PlayMod.getLimitedTimeEventMod().AddProgress(6)
+			LimitedTimeEventMod.AddProgress(BaseMod.GetLevel())
 		}
-		player.PushClientRes(player.PlayMod.getLimitedTimeEventMod().ProgressBackData())
+		player.PushClientRes(LimitedTimeEventMod.ProgressBackData())
 	case "champshipGroup":
 		G_GameLogicPtr.ChampshipMgrSend(&MsgMod.Msg{
 			Type: MsgMod.HANDLE_TYPE_CHAMPSHIP_GROUP,

src/server/game/LogMgr.go

@@ -26,6 +26,8 @@ type LogMgr struct {
 
 type Log struct {
 	Uid       int64
+	AppId     int
+	ServerId  int
 	EventName string
 	Param     map[string]interface{}
 	TimeStamp int64

src/server/game/PlayerFunc.go

@@ -454,8 +454,8 @@ func CancelOrder(p *Player, OrderSn string) error {
 	if err != nil {
 		return err
 	}
-	if Order.PayStatus != MergeConst.ORDER_STATUS_PAY {
+	if Order.PayStatus != MergeConst.ORDER_STATUS_IDLE {
-		return fmt.Errorf("订单未支付")
+		return fmt.Errorf("订单已支付")
 	}
 	Order.PayStatus = MergeConst.ORDER_STATUS_CANCEL
 	err = db.UpdatePlayerChargeData(Order)
@@ -737,6 +737,8 @@ func EmitRetireTrigger1(p *Player) {
 	sort.Slice(EmitId1, func(i, j int) bool {
 		return EmitId1[i] < EmitId1[j]
 	})
+	OrderMod := p.PlayMod.getOrderMod()
+	OrderMod.Retire(EmitId1[0])
 	ChessMod.BeginRetire(EmitId1[0])
 }
 

src/server/game/RegisterNetworkFunc.go

@@ -616,6 +616,37 @@ func ReqBuyChessBagGrid(args []interface{}) error {
 	return nil
 }
 
+func ReqSeparateChess(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqSeparateChess{}
+	proto.Unmarshal(buf, req)
+	ChessMod := player.PlayMod.getChessMod()
+	err := ChessMod.SeparateChess(int(req.ChessId))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResSeparateChess{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	data := &PlayerChessData{}
+	err = data.UpdateChessData(player, req.MChessData)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResSeparateChess{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(ChessMod.BackData())
+	player.PushClientRes(&msg.ResSeparateChess{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	player.UpdateUserInfo()
+	return nil
+}
+
 // 棋子转换
 func ReqChessEx(args []interface{}) error {
 	_, player, buf := ParseArgs(args)
@@ -2193,10 +2224,11 @@ func ReqShippingOrder(args []interface{}) error {
 	proto.Unmarshal(buf, req)
 	OrderSn := req.OrderSn
 	Status := int(req.Status)
-	if Status != MergeConst.ORDER_STATUS_CANCEL { // 取消支付
+	if Status == MergeConst.ORDER_STATUS_CANCEL { // 取消支付
 		CancelOrder(player, OrderSn)
 		player.PushClientRes(&msg.ResShippingOrder{
 			Code: msg.RES_CODE_SUCCESS,
+			Msg:  "cancel success",
 		})
 		return nil
 	}
@@ -2204,6 +2236,13 @@ func ReqShippingOrder(args []interface{}) error {
 	if err != nil {
 		return err
 	}
+	if OrderData.PayStatus != MergeConst.ORDER_STATUS_PAY {
+		player.PushClientRes(&msg.ResShippingOrder{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "order status error",
+		})
+		return errors.New("order status error")
+	}
 	if OrderData.PayStatus == MergeConst.ORDER_STATUS_PAY {
 		Charge(player, int(OrderData.ProductId))
 		OrderData.PayStatus = MergeConst.ORDER_STATUS_SHIP

src/server/game/UnitTest.go

@@ -54,9 +54,10 @@ func UnitChessShop(p *Player) error {
 func UnitOrder(p *Player) error {
 	OrderMod := p.PlayMod.getOrderMod()
 	ChessMod := p.PlayMod.getChessMod()
+	BaseMod := p.PlayMod.getBaseMod()
 	OrderMod.OrderList = make(map[int]order.Order)
-	for i := 0; i < 150; i++ {
+	for i := 0; i < 1000; i++ {
-		err := OrderMod.CreateNormalOrder(7, ChessMod.GetEmitList(), 3)
+		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetEmitList(), BaseMod.EnergyMul)
 		if err != nil {
 			return err
 		}

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

@@ -18,6 +18,7 @@ const (
 	ChessBoradMaxNum        = 63
 	CHESS_SOURCE_CHEST      = 705
 	CHESS_HIGH_SOURCE_CHEST = 706
+	CHESS_SEPARATE          = 707 // 分解器
 )
 
 type ChessBorad struct {
@@ -110,17 +111,9 @@ func (cb *ChessBorad) ComposeChess(id int) (int, error) {
 	}
 	ChessType := mergeDataCfg.GetTypeById(id)
 	if ChessType == "Emitter" {
-		_, ok := cb.EmitList[id+1]
+		cb.EmitList[id+1]++
-		if ok {
+		cb.EmitList[id]--
-			cb.EmitList[id+1]++
+		cb.EmitList[id]--
-		} else {
-			cb.EmitList[id+1] = 1
-		}
-		if cb.EmitList[id] > 2 {
-			cb.EmitList[id] -= 2
-		} else {
-			delete(cb.EmitList, id)
-		}
 	}
 	id++
 	newList = append(newList, id)
@@ -146,12 +139,7 @@ func (cb *ChessBorad) AddChess(id int) error {
 	}
 	ChessType := mergeDataCfg.GetTypeById(id)
 	if ChessType == "Emitter" {
-		_, ok := cb.EmitList[id]
+		cb.EmitList[id]++
-		if ok {
-			cb.EmitList[id]++
-		} else {
-			cb.EmitList[id] = 1
-		}
 	}
 	cb.ChessList = append(cb.ChessList, id)
 	return nil
@@ -166,12 +154,7 @@ func (cb *ChessBorad) BuyChess(id int) (int, error) {
 	cb.ChessList = append(cb.ChessList, id)
 	ChessType := mergeDataCfg.GetTypeById(id)
 	if ChessType == "Emitter" {
-		_, ok := cb.EmitList[id]
+		cb.EmitList[id]++
-		if ok {
-			cb.EmitList[id]++
-		} else {
-			cb.EmitList[id] = 1
-		}
 	}
 	return CfgRecord.SellNum, nil
 }
@@ -234,6 +217,7 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
 
 func (cb *ChessBorad) GetEmitList() []int {
 	result := make([]int, 0, len(cb.EmitList))
+	EM := make(map[string]int)
 	for k, v := range cb.EmitList {
 		EmitID := mergeDataCfg.GetEmitId(k)
 		if EmitID == "" {
@@ -242,9 +226,16 @@ func (cb *ChessBorad) GetEmitList() []int {
 		if cb.Retire[EmitID] == 2 {
 			continue
 		}
-		if v > 0 {
+		EmitType := mergeDataCfg.GetEmitType(k)
-			result = append(result, k)
+		if EmitType == "sub" {
+			continue
 		}
+		if v > 0 {
+			EM[EmitID] = max(EM[EmitID], k)
+		}
+	}
+	for _, v := range EM {
+		result = append(result, v)
 	}
 	return result
 }
@@ -509,3 +500,27 @@ func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) {
 
 	return nil, nil
 }
+
+func (cb *ChessBorad) SeparateChess(ChessId int) error {
+	ChessLv := mergeDataCfg.GetLvById(ChessId)
+	if ChessLv == 1 {
+		return errors.New("chess lv is 1")
+	}
+	ChessType := mergeDataCfg.GetTypeById(ChessId)
+	if ChessType != "Product" {
+		return errors.New("chess type is not product")
+	}
+	err := cb.RemoveChess(ChessId)
+	if err != nil {
+		return err
+	}
+	err = cb.RemoveChess(CHESS_SEPARATE)
+	if err != nil {
+		return err
+	}
+	ChessColor := mergeDataCfg.GetColorById(ChessId)
+	NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv-1, ChessColor)
+	cb.AddChess(NewChess)
+	cb.AddChess(NewChess)
+	return nil
+}

src/server/game/mod/limitedTimeEvent/LimitedTimeEvent.go

@@ -236,8 +236,8 @@ func (l *LimitedTimeEventMod) AddProgress(Lv int) {
 	}
 	l.Progress++
 	if l.Progress == l.ProgressMax {
-		SelectNum := limitedTimeEventCfg.GetProgressSelectNum(l.Lv)
+		SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
-		BonusLv := limitedTimeEventCfg.GetBonusLv(l.Lv)
+		BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
 		RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
 		n := 0
 		r := make([]int, 0)

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

@@ -2,10 +2,12 @@ package order
 
 import (
 	"fmt"
+	"log"
 	"server/GoUtil"
 	startOrderCfg "server/conf/StartOrder"
 	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mergeDataCfg "server/conf/mergeData"
+	orderCfg "server/conf/order"
 	playroomCfg "server/conf/playroom"
 	"server/game/mod/item"
 	"server/msg"
@@ -22,6 +24,8 @@ type OrderMod struct {
 	LastNormalOrder Order         // 上一个普通订单
 	EimtOrder       map[string]struct{}
 	PreheatStep     map[string]int // 预热订单步骤
+	EmitShuffle     []string       // 发射器乱序
+	ChessPool       []int          // 棋子池
 }
 
 type Order struct {
@@ -107,7 +111,7 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 		ChessColor := mergeDataCfg.GetColorById(ChessId)
 		PreheatStep := o.PreheatStep[ChessColor]
 		if PreheatStep < 4 {
-			NewChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+PreheatStep, ChessColor)
+			NewChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+PreheatStep+1, ChessColor)
 			o.addOrder([]int{NewChessId}, diff_low, Preheat_type)
 			o.PreheatStep[ChessColor]++
 		}
@@ -133,7 +137,7 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 			if o.CreatePriorityOrder(lv, Emit) {
 				return nil
 			}
-			MaxOrderNum := min(lv/4+2, 6)
+			MaxOrderNum := orderCfg.GetOrderNum(lv)
 			n := 0
 			for _, v := range o.OrderList {
 				if v.Type == Common_type || v.Type == Clean_type {
@@ -235,7 +239,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 		}
 		break
 	}
-
+	log.Printf("CreateNormalOrder: %v, %v, %v", mergeList, OrderDiff, err)
 	o.addOrder(mergeList, OrderDiff, Common_type)
 	return nil
 }
@@ -386,6 +390,7 @@ func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) {
 	if Type == Common_type {
 		o.LastNormalOrder = Order
 	}
+	o.LastDiff = Diff
 }
 
 func (o *OrderMod) CreateCleanOrder(ChessList []int) bool {
@@ -475,6 +480,9 @@ func (o *OrderMod) CheckSuperOrder() bool {
 	return false
 }
 
+/*
+* 根据能量倍数 调整订单
+ */
 func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList []int) {
 	for k, v := range o.OrderList {
 		if v.Type == Preheat_type { // 预热订单 修改倍数时修改棋子等级
@@ -489,15 +497,20 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 			continue
 		}
 		NeedTrigger := false
+		HasOne := false
 		for _, vv := range v.MergeId {
 			Lv := mergeDataCfg.GetLvById(vv)
 			if Lv >= EnergyMul+1 && Lv <= EnergyMul+12 {
 				continue
 			}
 			if GoUtil.InArray(vv, ChessList) {
-				NeedTrigger = true
+				HasOne = true
 				break
 			}
+			NeedTrigger = true
+		}
+		if HasOne { // 棋盘上有订单中的棋子，不进行修改
+			continue
 		}
 		/**
 		当每次倍数调整（玩家主动调整或因为体力不足跌落）时，在普通订单中（即不包括偷猫订单、超级订单），如果出现超出上下阈值：
@@ -511,3 +524,17 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 		}
 	}
 }
+
+func (o *OrderMod) Retire(EmitId string) {
+	ChessPool := make([]int, 0)
+	Product := mergeDataCfg.GetEmitProduce(EmitId)
+	for _, v := range o.ChessPool {
+		Color := mergeDataCfg.GetColorById(v)
+		if GoUtil.InStringArray(Color, Product) {
+			continue
+		}
+		ChessPool = append(ChessPool, v)
+	}
+	o.ChessPool = ChessPool
+	o.EmitShuffle = nil
+}

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

@@ -7,10 +7,12 @@ import (
 	userCfg "server/conf/user"
 )
 
+var reflectChess = map[int]int{}
+
 func getChessNumRand(OrderN int) map[int]int {
 	return map[int]int{
-		1: int(25 - 4*OrderN),
+		1: int(15 - 3*OrderN),
-		2: int(40 + 2*OrderN),
+		2: int(50 + OrderN),
 		3: int(35 + 2*OrderN),
 	}
 }
@@ -134,37 +136,40 @@ func getChessLv(Min, Max, Diff int) int {
 	case diff_high:
 		Start = Min + (Max-Min+1)/3*2
 	}
+	Start = max(Min, Start)
+	End = max(Start, End)
+	End = min(Max, End)
 	return GoUtil.RandNum(Start, End)
 }
 
-func getRandChessColorList(o *OrderMod, Emit []int, EnergyMul int) map[string]int {
+// func getRandChessColorList(o *OrderMod, Emit []int, EnergyMul int) map[string]int {
-	r := make(map[string]int)
+// 	r := make(map[string]int)
-	ChessList := make([]int, 0)
+// 	ChessList := make([]int, 0)
-	for _, v := range o.OrderList {
+// 	for _, v := range o.OrderList {
-		if v.Type == Common_type {
+// 		if v.Type == Common_type {
-			ChessList = append(ChessList, v.MergeId...)
+// 			ChessList = append(ChessList, v.MergeId...)
-		}
+// 		}
-	}
+// 	}
-	for _, v := range Emit {
+// 	for _, v := range Emit {
-		Produce := mergeDataCfg.GetEmitProduceType(v)
+// 		Produce := mergeDataCfg.GetEmitProduceType(v)
-		if len(Produce) == 0 {
+// 		if len(Produce) == 0 {
-			continue
+// 			continue
-		}
+// 		}
-		if len(Produce) == 1 {
+// 		if len(Produce) == 1 {
-			if Produce[0] == "" {
+// 			if Produce[0] == "" {
-				continue
+// 				continue
-			}
+// 			}
-			r[Produce[0]] = 100
+// 			r[Produce[0]] = 100
-			continue
+// 			continue
-		}
+// 		}
-		r[Produce[0]] = 80
+// 		r[Produce[0]] = 80
-		r[Produce[1]] = 20
+// 		r[Produce[1]] = 20
-		if checkA1High(ChessList, v, EnergyMul) {
+// 		if checkA1High(ChessList, v, EnergyMul) {
-			r[Produce[1]] += 20
+// 			r[Produce[1]] += 20
-		}
+// 		}
-	}
+// 	}
-	return r
+// 	return r
-}
+// }
 
 func RandChessColor(Emit []int) string {
 	r := make(map[string]int)
@@ -186,21 +191,21 @@ func RandChessColor(Emit []int) string {
 	return GoUtil.RandStringMap(r)
 }
 
-func checkA1High(ChessList []int, Emit int, EnergyMul int) bool {
+// func checkA1High(ChessList []int, Emit int, EnergyMul int) bool {
-	ChessMinLev, ChessMaxLev := getChesslvRange(Emit, EnergyMul)
+// 	ChessMinLev, ChessMaxLev := getChesslvRange(Emit, EnergyMul)
-	HighLv := ChessMinLev + ((ChessMaxLev-ChessMinLev)/3)*2
+// 	HighLv := ChessMinLev + ((ChessMaxLev-ChessMinLev)/3)*2
-	Produce := mergeDataCfg.GetEmitProduceChessType(Emit)
+// 	Produce := mergeDataCfg.GetEmitProduceChessType(Emit)
-	for _, v := range ChessList {
+// 	for _, v := range ChessList {
-		ChessColor := mergeDataCfg.GetColorById(v)
+// 		ChessColor := mergeDataCfg.GetColorById(v)
-		if ChessColor == Produce[0] {
+// 		if ChessColor == Produce[0] {
-			ChessLv := mergeDataCfg.GetLvById(v)
+// 			ChessLv := mergeDataCfg.GetLvById(v)
-			if ChessLv >= HighLv {
+// 			if ChessLv >= HighLv {
-				return true
+// 				return true
-			}
+// 			}
-		}
+// 		}
-	}
+// 	}
-	return false
+// 	return false
-}
+// }
 
 func getChesslvRange(Emit int, EnergyMul int) (int, int) {
 	RandEmitLv := mergeDataCfg.GetLvById(Emit)
@@ -226,40 +231,76 @@ func getEmitByColor(Emit []int, color string) int {
 	return 0
 }
 
+// 生成订单
 func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int, error) {
+	initReflectChess(Emit, EnergyMul)
 	OrderN, err := userCfg.GetOrderNByLv(lv)
 	RandChessNum := getChessNumRand(OrderN)
 	if err != nil {
 		return nil, diff_low, err
 	}
+	// 生成订单难度和棋子数量
 	ChessNum := GoUtil.RandMap(RandChessNum)
 	OrderDiffRand := getOrderDiffRand(o.LastDiff, OrderN)
 	OrderDiff := GoUtil.RandMap(OrderDiffRand)
 	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
 	mergeList := make([]int, 0, len(ChessDiff))
-	ColorRand := getRandChessColorList(o, Emit, EnergyMul)
+	// 根据订单棋子难度生成棋子
-	var Color string
 	for _, v := range ChessDiff {
-		Color = GoUtil.RandStringMap(ColorRand)
+		ChessId := 0
-		delete(ColorRand, Color)
+		for {
-		Emit := getEmitByColor(Emit, Color)
+			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
-		ChessMinLv, ChessMaxLv := getChesslvRange(Emit, EnergyMul)
+			if !GoUtil.InArray(ChessId, mergeList) {
-		NewLev := getChessLv(ChessMinLv, ChessMaxLv, v)
+				break
-		ColorMaxLv := mergeDataCfg.GetMaxLvByColor(Color)
+			}
-		NewLev = min(NewLev, ColorMaxLv)
-		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev, Color)
-		Type := mergeDataCfg.GetTypeById(ChessId)
-		if Type != "Product" {
-			continue
-		}
-		if ChessId == 0 {
-			continue
 		}
 		mergeList = append(mergeList, ChessId)
 	}
 	return mergeList, OrderDiff, nil
 }
 
+func getEmitId(o *OrderMod, Emit []int) string {
+	if o.EmitShuffle == nil {
+		o.EmitShuffle = make([]string, 0)
+		for _, v := range Emit {
+			EmitProduct := mergeDataCfg.GetEmitProduceType(v)
+			if len(EmitProduct) == 0 || EmitProduct[0] == "" {
+				continue
+			}
+			EmitId := mergeDataCfg.GetEmitId(v)
+			if GoUtil.InStringArray(EmitId, o.EmitShuffle) {
+				continue
+			}
+			o.EmitShuffle = append(o.EmitShuffle, EmitId)
+		}
+		GoUtil.ShuffleStringArray(o.EmitShuffle)
+	}
+	PopEmitId, NewSlice := GoUtil.PopStringArray(o.EmitShuffle)
+	o.EmitShuffle = NewSlice
+	if len(o.EmitShuffle) == 0 {
+		o.EmitShuffle = make([]string, 0)
+		for _, v := range Emit {
+			EmitId := mergeDataCfg.GetEmitId(v)
+			if GoUtil.InStringArray(EmitId, o.EmitShuffle) {
+				continue
+			}
+			o.EmitShuffle = append(o.EmitShuffle, EmitId)
+		}
+		Num := 1
+		for {
+			GoUtil.ShuffleStringArray(o.EmitShuffle)
+			if o.EmitShuffle[0] != PopEmitId {
+				break
+			}
+			Num++
+			if Num > 100 {
+				break
+			}
+		}
+	}
+	return PopEmitId
+}
+
 func getOrderStar(ChessList []int) int {
 	Star := 0
 	for _, v := range ChessList {
@@ -267,3 +308,124 @@ func getOrderStar(ChessList []int) int {
 	}
 	return Star
 }
+
+func getChessFromPoolByDiff(o *OrderMod, Diff int, Emit []int, EnergyMul int) int {
+	EmitId := getEmitId(o, Emit)
+	EmitChessId := getEmitBySeries(Emit, EmitId)
+	ColorRand := mergeDataCfg.GetEmitProduceType(EmitChessId)
+	// 从棋子池中获取棋子
+	MinChessId := 0
+	for i, chess := range o.ChessPool {
+		chessColor := mergeDataCfg.GetColorById(chess)
+		if reflectChess[chess] > Diff {
+			MinChessId = chess
+		}
+		if !GoUtil.InStringArray(chessColor, ColorRand) {
+			continue
+		}
+		ChessLv := mergeDataCfg.GetLvById(chess)
+		if reflectChess[chess] == Diff && ChessLv >= EnergyMul+1 && ChessLv <= EnergyMul+12 {
+			o.ChessPool = append(o.ChessPool[:i], o.ChessPool[i+1:]...)
+			return chess
+		}
+	}
+	/** 获取不到时选最接近的棋子
+	 * 1. 选取最接近的棋子
+	 */
+	if MinChessId != 0 {
+		MinChessColor := mergeDataCfg.GetColorById(MinChessId)
+		NewEmitChessId := getEmitByColor(Emit, MinChessColor)
+		ColorRand := mergeDataCfg.GetEmitProduceType(NewEmitChessId)
+		ChessMinLv, ChessMaxLv := getChesslvRange(NewEmitChessId, EnergyMul)
+		NewLev := getChessLv(ChessMinLv, ChessMaxLv, Diff)
+		MinChessLv := mergeDataCfg.GetLvById(MinChessId)
+		NewLev2 := mergeDataCfg.DynamicLev2(NewLev, NewEmitChessId, ColorRand[0], MinChessColor)
+		NewLev3 := adjustLev(NewLev2, EnergyMul)
+		o.ChessPool = GoUtil.DeleteEleByValue(o.ChessPool, MinChessId)
+		for i := NewLev3; i < MinChessLv; i++ {
+			ChessId2 := mergeDataCfg.GetChessIdByLvAndColor(i, MinChessColor)
+			if ChessId2 != 0 {
+				o.ChessPool = append(o.ChessPool, ChessId2)
+			}
+		}
+		Chess := mergeDataCfg.GetChessIdByLvAndColor(NewLev2, MinChessColor)
+		return Chess
+	}
+	Color := GoUtil.RandStringSlice(ColorRand)
+	ChessMinLv, ChessMaxLv := getChesslvRange(EmitChessId, EnergyMul)
+	NewLev := getChessLv(ChessMinLv, ChessMaxLv, Diff)
+	NewLev1 := mergeDataCfg.DynamicLev(NewLev, EmitChessId, Color)
+	ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev1, Color)
+	ProductColor := mergeDataCfg.GetEmitProduceType(EmitChessId)
+	for _, i := range ProductColor {
+		if i == Color {
+			continue
+		}
+		NewLev2 := mergeDataCfg.DynamicLev2(NewLev1, EmitChessId, Color, i)
+		NewLev2 = adjustLev(NewLev2, EnergyMul)
+		ChessId2 := mergeDataCfg.GetChessIdByLvAndColor(NewLev2, i)
+		if ChessId2 != 0 {
+			o.ChessPool = append(o.ChessPool, ChessId2)
+		}
+	}
+	o.ChessPool = GoUtil.ShuffleArray(o.ChessPool)
+	if len(o.ChessPool) > 200 {
+		o.ChessPool = o.ChessPool[:200]
+	}
+	return ChessId
+}
+
+func initReflectChess(Emits []int, EnergyMul int) {
+	Start, End := 0, 0
+	for _, Emit := range Emits {
+		ProduceColor := mergeDataCfg.GetEmitProduceType(Emit)
+		if len(ProduceColor) == 0 || ProduceColor[0] == "" {
+			continue
+		}
+		ChessMinLv, ChessMaxLv := getChesslvRange(Emit, EnergyMul)
+		Product := mergeDataCfg.GetEmitProduceChessType(Emit)
+		Start = ChessMinLv
+		End = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3 - 1
+		for _, v := range Product {
+			Adjust := mergeDataCfg.DynamicAdjust(Emit, v)
+			initReflectChess2(v, Start, End, diff_low, Adjust)
+		}
+		Start = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3
+		End = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3*2 - 1
+		for _, v := range Product {
+			Adjust := mergeDataCfg.DynamicAdjust(Emit, v)
+			initReflectChess2(v, Start, End, diff_mid, Adjust)
+		}
+		Start = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3*2
+		End = ChessMaxLv
+		for _, v := range Product {
+			Adjust := mergeDataCfg.DynamicAdjust(Emit, v)
+			initReflectChess2(v, Start, End, diff_high, Adjust)
+		}
+	}
+}
+
+func initReflectChess2(Color string, Start, End, Diff, adjust int) {
+	for i := Start; i <= End; i++ {
+		Lv := max(i-adjust, 1)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(Lv, Color)
+		reflectChess[ChessId] = Diff
+	}
+}
+
+func adjustLev(Lev, EnergyMul int) int {
+	return max(min(Lev, EnergyMul+12), EnergyMul+1)
+}
+
+func getEmitBySeries(EmitList []int, EmitId string) int {
+	for _, v := range EmitList {
+		ProduceColor := mergeDataCfg.GetEmitProduceType(v)
+		if len(ProduceColor) == 0 || ProduceColor[0] == "" {
+			continue
+		}
+		if mergeDataCfg.GetEmitId(v) == EmitId {
+			return v
+		}
+	}
+	return 0
+}