Merge branch 'sdk' into online

src/server/GoUtil/GoUtil.go

@@ -211,7 +211,7 @@ func GobUnmarshal(data []byte, obj interface{}) error {
 }
 
 func GetServerIdByUid(uid int) int {
-	return int(uid / 100000)
+	return int((uid % 100000000) / 100000)
 }
 
 func CreateOrderSn(uid int) string {

src/server/GoUtil/sliceUtil.go

@@ -66,7 +66,9 @@ func RandSliceNum(slice []int, num int) []int {
 	return r
 }
 
-func RandSliceNum2(slice []interface{}, num int) []interface{} {
+func RandSliceNum2(s []interface{}, num int) []interface{} {
+	slice := make([]interface{}, len(s))
+	copy(slice, s)
 	r := make([]interface{}, 0, num)
 	if num <= 0 || len(slice) < num {
 		return slice
@@ -259,3 +261,24 @@ func ShuffleArray(s []int) []int {
 	}
 	return r
 }
+
+func IsContain(s []int, s2 []int) bool {
+	for _, v := range s2 {
+		if !InArray(v, s) {
+			return false
+		}
+		s = SubSlices(s, []int{v})
+	}
+	return true
+}
+
+func IsSameElem(s []int) bool {
+	r := make(map[int]struct{})
+	for _, v := range s {
+		if _, ok := r[v]; ok {
+			return true
+		}
+		r[v] = struct{}{}
+	}
+	return false
+}

src/server/cluster/ClusterFunc.go

@@ -120,6 +120,7 @@ func SendServerMsg(m *msg.Msg, serverId int) error {
 			return err
 		}
 		v.(network.Agent).WriteMsg(data)
+		return nil
 	}
 	return fmt.Errorf("server %d not online", serverId)
 }

src/server/conf/card/CardCfg.go

@@ -200,3 +200,11 @@ func GetItemIdByCardId(CardId int) int {
 	}
 	return gamedata.GetIntValue(data, "ItemId")
 }
+
+func GetSeasonFirstReward() []*item.Item {
+	data, err := gamedata.GetDataByKey(CARD_CONST_CFG_NAME, "season_first")
+	if err != nil {
+		log.Debug("GetSeasonFirstReward data not found")
+	}
+	return item.ParseItem(data["Value"])
+}

src/server/conf/limitedTimeEvent/LimitedTimeEventCfg.go

@@ -51,47 +51,22 @@ func GetMeteorAdd(ChessLv int) int {
 }
 
 // 获取宝箱雨奖励
-func GetChestReward(Star int) ([]*item.Item, int, int, int) {
+func GetChestReward(Star int) []*item.Item {
 	data, err := gamedata.GetData(CFG_LIMITED_TIME_EVENT_CHEST)
 	if err != nil {
 		log.Debug("GetChestReward err:%v", err)
-		return nil, 0, 0, 0
+		return nil
 	}
-	Grade := 0
-	for k, v := range data {
+
+	for _, v := range data {
 		Min := gamedata.GetIntValue(v, "Min")
 		Max := gamedata.GetIntValue(v, "Max")
 		if Star >= Min && Star <= Max {
-			Grade = GoUtil.Int(k)
-			break
+			return gamedata.GetItemList(v, "Items")
 		}
 	}
+	return nil
 
-	data, err = gamedata.GetData(CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT)
-	if err != nil {
-		log.Debug("GetChestReward err:%v", err)
-		return nil, 0, 0, 0
-	}
-	RandMap := make(map[int]int)
-	for k, v := range data {
-		Prob := gamedata.GetIntValue(v, "Prob")
-		if Grade == gamedata.GetIntValue(v, "Grade") {
-			Id := GoUtil.Int(k)
-			RandMap[Id] = Prob
-		}
-	}
-	Id := GoUtil.RandMap(RandMap)
-	data, err = gamedata.GetDataByIntKey(CFG_LIMITED_TIME_EVENT_CHEST_JACKPOT, Id)
-	if err != nil {
-		log.Debug("GetChestReward err:%v", err)
-		return nil, 0, 0, 0
-	}
-	Items := gamedata.GetItemList(data, "Items")
-
-	CardLv := gamedata.GetIntValue(data, "CardLv")
-	Lv := gamedata.GetIntValue(data, "Lv")
-	Jackpot := gamedata.GetIntValue(data, "Jackpot")
-	return Items, CardLv, Lv, Jackpot
 }
 
 // 获取超级订单奖励
@@ -273,3 +248,12 @@ func GetUnlockLv() int {
 	}
 	return gamedata.GetIntValue(data, "Value")
 }
+
+func GetFirstEvent() int {
+	data, err := gamedata.GetDataByKey(CFG_LIMITED_TIME_EVENT_CONST, "First_Event")
+	if err != nil {
+		log.Debug("GetFirstEvent err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}

src/server/conf/mergeData/MergeDataCfg.go

@@ -15,11 +15,12 @@ const (
 	CONST_NAME          = "MergeDataConst"
 	CFG_MERGE_EMIT      = "MergeDataEmit"
 	CFG_MERGE_EMIT_TYPE = "MergeDataEmitType"
+	CFG_MERGE_COLOR     = "MergeDataColor"
 
 	// 棋子类型
 	CHESS_PRODUCT_MAIN_TYPE      = 1 // 主产物
-	CHESS_PRODUCT_SUB_TYPE      = 2 // 次产物
-	CHESS_PRODUCT_SUB_EMIT_TYPE = 3 // 次发射器产物
+	CHESS_PRODUCT_SECONDARY_TYPE = 2 // 次产物
+	CHESS_PRODUCT_SUB_TYPE       = 3 // 子发射器产物
 )
 
 func init() {
@@ -27,6 +28,7 @@ func init() {
 	gamedata.InitCfg(CONST_NAME)
 	gamedata.InitCfg(CFG_MERGE_EMIT)
 	gamedata.InitCfg(CFG_MERGE_EMIT_TYPE)
+	gamedata.InitCfg(CFG_MERGE_COLOR)
 }
 
 func GetEmitTypeProduce(EmitType string) []string {
@@ -475,3 +477,21 @@ func getColorProb(Emit_List string, Color string) float64 {
 	}
 	return Prob
 }
+
+func GetColorType(Color string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_COLOR, Color)
+	if err != nil {
+		log.Debug("GetColorType GetOne Color:%s not found", Color)
+		return 0
+	}
+	Type := gamedata.GetStringValue(data, "Type")
+	switch Type {
+	case "main":
+		return CHESS_PRODUCT_MAIN_TYPE
+	case "secondary":
+		return CHESS_PRODUCT_SECONDARY_TYPE
+	case "sub":
+		return CHESS_PRODUCT_SUB_TYPE
+	}
+	return CHESS_PRODUCT_MAIN_TYPE
+}

src/server/game/ChampshipMgr.go

@@ -7,6 +7,7 @@ import (
 	randnameCfg "server/conf/randname"
 	"server/game/mod/msg"
 	proto "server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
 	"sort"
 	"time"
 )
@@ -29,6 +30,7 @@ type ChampshipData struct {
 	PreGroupInfo map[int]int              // 锦标赛分组信息 备份
 	Robot        map[int]*ChampshipRobot  // 机器人
 	PreRobot     map[int]*ChampshipRobot  // 机器人 备份
+	ZeroTime     int64
 }
 
 type ChampshipRank struct {
@@ -87,6 +89,9 @@ func (c *ChampshipMgr) Init() {
 
 	Now := GoUtil.Now()
 	ZeroTime := GoUtil.ZeroTimestamp()
+	if c.getData().ZeroTime != ZeroTime {
+		c.ZeroUpdate(&msg.Msg{})
+	}
 	Remain := Now - ZeroTime
 	Remain1 := 1800 - Remain%1800
 
@@ -101,6 +106,7 @@ func (c *ChampshipMgr) Init() {
 			Type: msg.HANDLE_TYPE_CHAMPSHIP_AI,
 		})
 	})
+
 	c.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
 		c.Send(&msg.Msg{
 			Type: msg.SERVER_ZERO_UPDATE,
@@ -116,6 +122,8 @@ func (c *ChampshipMgr) NotifyAll(m *msg.Msg) (interface{}, error) {
 }
 
 func (c *ChampshipMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
+	log.Debug("ChampshipMgr ZeroUpdate")
+	c.getData().ZeroTime = GoUtil.ZeroTimestamp()
 	c.getData().PreRank = c.getData().Rank
 	c.getData().PreRobot = c.getData().Robot
 	c.getData().PreGroupInfo = c.getData().GroupInfo

src/server/game/FriendMgr.go

@@ -111,10 +111,12 @@ func FriendMgrSend(m *msg.Msg) error {
 		err := mergeCluster.SendServerMsg(m, ToServer)
 		if err != nil { // 区服不在线
 			G_GameLogicPtr.FriendMgrSend(m)
+			log.Debug("send to server %d error : %s\n", ToServer, err)
 			return err
 		}
 		return nil
 	}
+	log.Debug("send to server %d success, %d", ToServer, conf.Server.ServerID)
 	G_GameLogicPtr.FriendMgrSend(m)
 	return nil
 }

src/server/game/GameLogic.go

@@ -102,9 +102,9 @@ func (gl *GameLogic) ZeroFlush() {
 	})
 	var a1 = []interface{}{gl.DailyTaskTimestamp}
 	GoUtil.CallEvent(MergeConst.Notify_Daily_Renew, a1)
-	gl.RankMgrSend(MsgMod.MSG_ZERO_UPDATE)      // 零点更新排行榜
-	gl.ChampshipMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新锦标赛
-	gl.VarMgrSend(MsgMod.MSG_ZERO_UPDATE)       // 零点更新变量
+	// gl.RankMgrSend(MsgMod.MSG_ZERO_UPDATE)      // 零点更新排行榜
+	// gl.ChampshipMgrSend(MsgMod.MSG_ZERO_UPDATE) // 零点更新锦标赛
+	// gl.VarMgrSend(MsgMod.MSG_ZERO_UPDATE)       // 零点更新变量
 	gl.NotifyAll(MsgMod.MSG_ZERO_UPDATE)
 	gl.CreateDailyLogFile()
 	log.Debug("Server ZeroFlush")
@@ -686,6 +686,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 
 	// #region 卡牌
 	RegisterMsgProcessFunc("ReqCardInfo", ReqCardInfo)                           // 请求卡牌信息
+	RegisterMsgProcessFunc("ReqCardSeasonFirstReward", ReqCardSeasonFirstReward) // 领取赛季首次奖励
 	RegisterMsgProcessFunc("ReqCardCollectReward", ReqCardCollectReward)         //领取卡牌系列收集奖励
 	RegisterMsgProcessFunc("ReqExStarReward", ReqExStarReward)                   // 兑换收集星星奖励
 	RegisterMsgProcessFunc("ReqAllCollectReward", ReqAllCollectReward)           // 领取全收集奖励

src/server/game/Gm.go

@@ -233,12 +233,20 @@ func ReqGmCommand(args []interface{}) error {
 	case "addFriendStar":
 		FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
 		FriendTreasureMod.AddStar(200)
+	case "comfortOrder":
+		BaseMod := player.PlayMod.getBaseMod()
+		BaseMod.LogoutTime = GoUtil.Now() - 7*86400
+		TriggerComfortOrder(player)
+		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 	case "setDecorateArea":
 		S, _ := strconv.Atoi(arg[1])
 		DecorateMod := player.PlayMod.getDecorateMod()
 		DecorateMod.AreaId = S
 		DecorateMod.FinishList = make(map[int]struct{})
 		DecorateMod.Progress = 0
+	case "resetCardSeasonFirst":
+		CardMod := player.PlayMod.getCardMod()
+		CardMod.SeasonFirst = false
 	}
 	player.PlayMod.save()
 	return nil

src/server/game/PlayerChessMod.go

@@ -88,7 +88,7 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
 		for _, v := range update.MChessHandle {
 			HandleStr += fmt.Sprintf("%v-%v-%v,", v.Id, v.ChessId, v.Type)
 		}
-		log.Debug("棋子数据不一致, %v===%v===%v===%v", HandleStr, LastMap, p.Data.MChessData, player.PlayMod.getChessMod().GetChessList())
+		log.Debug("棋子数据不一致, %v===%v===%v===%v", HandleStr, LastMap, update.MChessData, player.PlayMod.getChessMod().GetChessList())
 		player.SendErrClienRes(res)
 		return fmt.Errorf("棋子数据不一致")
 	}

src/server/game/PlayerFunc.go

@@ -694,7 +694,7 @@ func GetRecommendPlayer(p *Player, Num int) []int {
 		if v.Uid == int(p.M_DwUin) {
 			continue
 		}
-		if FriendMod.CheckApply(v.Uid) {
+		if FriendMod.CheckSendApply(v.Uid) {
 			continue
 		}
 		if FriendMod.CheckFriend(v.Uid) {
@@ -704,6 +704,9 @@ func GetRecommendPlayer(p *Player, Num int) []int {
 		if GoUtil.Now()-PlayerSimpleData.Loginout > 86400 {
 			continue
 		}
+		if PlayerSimpleData.Level < 4 {
+			continue
+		}
 		PlayerList1 = append(PlayerList1, v.Uid)
 	}
 	if len(PlayerList1) == 0 {

src/server/game/RegisterNetworkFunc.go

@@ -6,7 +6,6 @@ import (
 	"math"
 	"server/GoUtil"
 	cardCfg "server/conf/card"
-	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mergeDataCfg "server/conf/mergeData"
 	miningCfg "server/conf/mining"
 	"server/db"
@@ -183,7 +182,6 @@ func ReqRewardOrder(args []interface{}) error {
 	proto.Unmarshal(buf, req)
 	OrderMod := player.PlayMod.getOrderMod()
 	ChessMod := player.PlayMod.getChessMod()
-	CardMod := player.PlayMod.getCardMod()
 	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
 	Item, mergeList, OrderType, Star, err := OrderMod.RewardOrder(int(req.OrderId))
 	if OrderType == order.Trigger_type { // playroom触发式订单获取额外道具
@@ -237,32 +235,8 @@ func ReqRewardOrder(args []interface{}) error {
 	}
 
 	if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CHEST_RAIN) { //宝箱雨活动
-		AddItem, CardLv, ProductLv, Jackpot := LimitedTimeEventMod.GetChestReward(mergeList)
-		ChestRainItems := make([]*item.Item, 0)
-		if len(AddItem) > 0 {
-			ChestRainItems = AddItem
-		}
-		JackpotId := 0
-		if CardLv > 0 {
-			CardId := CardMod.RandCard(CardLv)
-			ItemId := cardCfg.GetItemIdByCardId(CardId)
-			ChestRainItems = []*item.Item{{Id: ItemId, Num: 1}}
-		}
-		if ProductLv > 0 {
-			Color := order.RandChessColor(ChessMod.GetEmitList())
-			ChessId := mergeDataCfg.GetChessIdByLvAndColor(ProductLv, Color)
-			if ChessId == 0 {
-				log.Error("GetChessIdByLvAndColor error color:%d, lv:%d", Color, ProductLv)
-				return errors.New("GetChessIdByLvAndColor error")
-			}
-			ChestRainItems = append(ChestRainItems, &item.Item{Id: ChessId, Num: 1})
-		}
-		if Jackpot > 0 {
-			ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
-			JackpotId = GoUtil.RandMap(ProbList)
-			ChestRainItems = limitedTimeEventCfg.GetSenceJackpotReward(JackpotId)
-		}
-		player.args["ResItemPopId"] = JackpotId
+		ChestRainItems := LimitedTimeEventMod.GetChestReward(mergeList)
+		player.args["ResItemPopId"] = 0
 		err = player.HandleItem(ChestRainItems, msg.ITEM_POP_LABEL_LimitEventChestRain.String())
 		if err != nil {
 			player.SendErrClienRes(&msg.ResRewardOrder{
@@ -275,7 +249,7 @@ func ReqRewardOrder(args []interface{}) error {
 		if len(ChestRainItems) > 0 {
 			player.PushClientRes(&msg.ResChessRainReward{
 				Items: item.ItemToMsg(ChestRainItems),
-				Id:    int32(JackpotId),
+				Id:    0,
 			})
 			player.TeLog("time_limited_event_action", map[string]interface{}{
 				"event_type": "chest_rain",
@@ -768,6 +742,34 @@ func ReqCardInfo(args []interface{}) error {
 	return nil
 }
 
+func ReqCardSeasonFirstReward(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqCardSeasonFirstReward{}
+	proto.Unmarshal(buf, req)
+	CardMod := player.PlayMod.getCardMod()
+	itemList, err := CardMod.SeasonFirstReward()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCardSeasonFirstReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(itemList, msg.ITEM_POP_LABEL_CardSeasonFirstReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCardSeasonFirstReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCardSeasonFirstReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
 // 领取卡牌系列收集奖励
 func ReqCardCollectReward(args []interface{}) error {
 	_, player, buf := ParseArgs(args)
@@ -1279,13 +1281,28 @@ func ReqApplyFriend(args []interface{}) error {
 	req := &msg.ReqApplyFriend{}
 	proto.Unmarshal(buf, req)
 	Uid := int(req.Uid)
+	FriendMod := player.PlayMod.getFriendMod()
+	if FriendMod.CheckFriend(Uid) {
+		player.SendErrClienRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "already friend",
+		})
+		return fmt.Errorf("already friend")
+	}
+	if FriendMod.AddSendApply(Uid) {
+		player.SendErrClienRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "already apply",
+		})
+		return fmt.Errorf("already apply")
+	}
 	m := &MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_APPLY,
 		From:  int(player.M_DwUin),
 		To:    Uid,
 		SendT: GoUtil.Now(),
 	}
-	G_GameLogicPtr.FriendMgrSend(m)
+	FriendMgrSend(m)
 	player.PushClientRes(&msg.ResApplyFriend{
 		Code: msg.RES_CODE_SUCCESS,
 	})
@@ -1316,7 +1333,7 @@ func ReqAgreeFriend(args []interface{}) error {
 		To:    Uid,
 		SendT: GoUtil.Now(),
 	}
-	G_GameLogicPtr.FriendMgrSend(m)
+	FriendMgrSend(m)
 	FriendMod.AddFriend(Uid)
 	player.PlayMod.save()
 	player.PushClientRes(&msg.ResAgreeFriend{
@@ -1341,7 +1358,7 @@ func ReqDelFriend(args []interface{}) error {
 		To:    Uid,
 		SendT: GoUtil.Now(),
 	}
-	G_GameLogicPtr.FriendMgrSend(m)
+	FriendMgrSend(m)
 	FriendMod := player.PlayMod.getFriendMod()
 	FriendMod.DelFriend(Uid)
 	player.PlayMod.save()
@@ -1376,7 +1393,7 @@ func ReqRefuseFriend(args []interface{}) error {
 		To:    Uid,
 		SendT: GoUtil.Now(),
 	}
-	G_GameLogicPtr.FriendMgrSend(m)
+	FriendMgrSend(m)
 	FriendApplyBackData(player)
 	return nil
 }

src/server/game/Trigger.go

@@ -1,9 +1,11 @@
 package game
 
 import (
+	"server/GoUtil"
 	"server/MergeConst"
 	"server/conf"
 	"server/db"
+	"server/game/mod/order"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"time"
@@ -67,3 +69,38 @@ func TriggerShippingOrder(player *Player, req *msg.ReqShippingOrder) {
 	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 < 6 {
+		return
+	}
+	OrderMod := p.PlayMod.getOrderMod()
+	ChessMod := p.PlayMod.getChessMod()
+	ChessList := ChessMod.GetUnlockChessList()
+	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.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)
+	}
+}

src/server/game/UnitTest.go

@@ -2,11 +2,6 @@ package game
 
 import (
 	"fmt"
-	"server/GoUtil"
-	cardCfg "server/conf/card"
-	limitedTimeEventCfg "server/conf/limitedTimeEvent"
-	mergeDataCfg "server/conf/mergeData"
-	"server/game/mod/item"
 	"server/game/mod/order"
 	"server/game/mod/sevenLogin"
 	"server/msg"
@@ -33,21 +28,9 @@ func UnitEndlessReward(p *Player) error {
 
 func UnitChessShop(p *Player) error {
 	ChessMod := p.PlayMod.getChessMod()
-	if ChessMod == nil {
-		return fmt.Errorf("ChessMod is nil")
-	}
-	ChessMod.EmitList = make(map[int]int)
-	ChessMod.EmitList[83] = 1
-	ChessMod.EmitList[125] = 1
+
 	ChargeMod := p.PlayMod.getChargeMod()
-	if ChargeMod == nil {
-		return fmt.Errorf("ChargeMod is nil")
-	}
-	p.PlayMod.save()
-	p.PlayMod.ClearData(p)
-	ChargeMod.TriggerChargeUnlock(4, ChessMod.GetEmitList())
-	b := ChargeMod.BackData()
-	fmt.Println(b)
+	ChargeMod.InitChessShop(ChessMod.GetEmitList())
 	return nil
 }
 
@@ -108,30 +91,17 @@ func UnitLimitProgress(p *Player) error {
 
 func UnitLimitedTimeEvent(p *Player) error {
 	LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
-	CardMod := p.PlayMod.getCardMod()
-	ChessMod := p.PlayMod.getChessMod()
-	mergeList := []int{1, 2, 30}
-	ChestRainItems := make([]*item.Item, 0)
-	AddItem, CardLv, ProductLv, Jackpot := LimitedTimeEventMod.GetChestReward(mergeList)
-	if len(AddItem) > 0 {
-		ChestRainItems = AddItem
-	}
-	JackpotId := 0
-	if CardLv > 0 {
-		CardId := CardMod.RandCard(CardLv)
-		ItemId := cardCfg.GetItemIdByCardId(CardId)
-		ChestRainItems = []*item.Item{{Id: ItemId, Num: 1}}
-	}
-	if ProductLv > 0 {
-		Color := order.RandChessColor(ChessMod.GetOrderEmit())
-		ChessId := mergeDataCfg.GetChessIdByLvAndColor(ProductLv, Color)
-		ChestRainItems = append(ChestRainItems, &item.Item{Id: ChessId, Num: 1})
-	}
-	if Jackpot > 0 {
-		ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
-		JackpotId = GoUtil.RandMap(ProbList)
-		ChestRainItems = limitedTimeEventCfg.GetSenceJackpotReward(JackpotId)
-	}
-	fmt.Print(ChestRainItems, JackpotId)
+
+	mergeList := []int{246, 15}
+	AddItem := LimitedTimeEventMod.GetChestReward(mergeList)
+	fmt.Print(AddItem)
+	return nil
+}
+
+func UnitCard(p *Player) error {
+	CardMod := p.PlayMod.getCardMod()
+	for i := 0; i < 1000; i++ {
+		CardMod.OpenCardPack(4)
+	}
 	return nil
 }

src/server/game/VarMgr.go

@@ -2,8 +2,10 @@ package game
 
 import (
 	"encoding/gob"
+	"server/GoUtil"
 	"server/game/mod/card"
 	"server/game/mod/msg"
+	"time"
 )
 
 type VarMgr struct {
@@ -12,6 +14,7 @@ type VarMgr struct {
 
 type VarData struct {
 	Var      map[string]interface{}
+	ZeroTime int64
 }
 
 const (
@@ -26,25 +29,22 @@ func (f *VarMgr) Init() {
 	}
 	// 注册处理函数
 	f.init()
-	f.initData()
-	f.RegisterHandler(msg.SERVER_ZERO_UPDATE, f.ZeroUpdate)
-}
-
-func (f *VarMgr) initData() {
 	if f.getData().Var == nil {
 		f.getData().Var = make(map[string]interface{})
 	}
-	GoldCard := f.GetVar(VAR_GOLD_CARD)
-	if GoldCard == nil { // 随机生成两个金卡
-		Card1, Card2 := card.RankGoldCard()
-		f.SetVar(VAR_GOLD_CARD, &VarGoldCard{
-			Four: Card1,
-			Five: Card2,
-		})
+	if f.getData().ZeroTime == GoUtil.ZeroTimestamp() {
+		f.ZeroUpdate(&msg.Msg{})
 	}
+	f.RegisterHandler(msg.SERVER_ZERO_UPDATE, f.ZeroUpdate)
+	f.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
+		f.Send(&msg.Msg{
+			Type: msg.SERVER_ZERO_UPDATE,
+		})
+	})
 }
 
 func (f *VarMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
+	f.getData().ZeroTime = GoUtil.ZeroTimestamp()
 	// 随机生成两个金卡
 	Card1, Card2 := card.RankGoldCard()
 	f.SetVar(VAR_GOLD_CARD, &VarGoldCard{

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

@@ -47,7 +47,7 @@ func (b *Base) InitData(Uid int) {
 
 func (b *Base) Login() {
 	b.LoginTime = GoUtil.Now()
-	b.LogoutTime = 0
+	// b.LogoutTime = 0
 }
 
 func (b *Base) GetNickName() string {
@@ -118,6 +118,10 @@ func (b *Base) GetLoginTime() int64 {
 	return b.LoginTime
 }
 
+func (b *Base) GetLogoutTime() int64 {
+	return b.LogoutTime
+}
+
 func (b *Base) GetRecoverTime() int64 {
 	return b.RecoverTime
 }
@@ -176,9 +180,7 @@ func (b *Base) BuyEnergy(Energy int) ([]*item.Item, int, int) {
 
 // HighRoller 结束时重置能量倍数
 func (b *Base) ResetEnergyMul(Mul int) {
-	if Mul < b.EnergyMul {
-		b.EnergyMul = 0
-	}
+	b.EnergyMul = Mul
 }
 
 func (b *Base) BackData() *msg.BaseInfo {

src/server/game/mod/card/Card.go

@@ -15,6 +15,7 @@ type CardMod struct {
 	AllCollect    int               // 总共收集 0未领取， 1已领取
 	CardLimit     bool              //卡牌节 限时活动
 	EndTime       int64             //周期结束时间
+	SeasonFirst   bool              //赛季首次奖励
 	AllCard       map[int]int       //
 	ExTimes       int               //置换次数
 	ReqTimes      int               //请求次数
@@ -156,9 +157,8 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
 	}
 
 	mustHaveStar := cardCfg.GetPackMustHave(Star)
-
 	if mustHaveStar != 0 {
-		cardId = randCard(c.Round, mustHaveStar, 0)
+		cardId = randCard(c.Round, mustHaveStar, 0, newCard)
 		if cardId == 0 {
 			return newCard, fmt.Errorf("OpenCardPack card id err")
 		}
@@ -176,11 +176,11 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
 		CardStar := GoUtil.RandMap(randList)
 		switch CardStar {
 		case 5:
-			cardId = randCard(c.Round, 4, 1)
+			cardId = randCard(c.Round, 4, 1, newCard)
 		case 6:
-			cardId = randCard(c.Round, 5, 1)
+			cardId = randCard(c.Round, 5, 1, newCard)
 		default:
-			cardId = randCard(c.Round, CardStar, 0)
+			cardId = randCard(c.Round, CardStar, 0, newCard)
 		}
 		if cardId == 0 {
 			return newCard, fmt.Errorf("OpenCardPack card id err")
@@ -230,6 +230,7 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
 		ExUid:       ExUid,
 		Round:       int32(c.Round),
 		Handbook:    GoUtil.MapIntToInt32(c.Handbook),
+		SeasonFirst: c.SeasonFirst,
 	}
 }
 
@@ -537,5 +538,13 @@ func (c *CardMod) GetHandbookReward(CardId int) ([]*item.Item, error) {
 }
 
 func (c *CardMod) RandCard(Star int) int {
-	return randCard(c.Round, Star, 0)
+	return randCard(c.Round, Star, 0, []int{})
+}
+
+func (c *CardMod) SeasonFirstReward() ([]*item.Item, error) {
+	if c.SeasonFirst {
+		return nil, fmt.Errorf("SeasonFirstReward already get")
+	}
+	c.SeasonFirst = true
+	return cardCfg.GetSeasonFirstReward(), nil
 }

src/server/game/mod/card/CardFunc.go

@@ -5,12 +5,15 @@ import (
 	cardCfg "server/conf/card"
 )
 
-func randCard(Round, Star, IsGold int) int {
+func randCard(Round, Star, IsGold int, Except []int) int {
 	cardList := cardCfg.GetCardListByStar(Round, Star, IsGold)
+	cardList = GoUtil.SubSlices(cardList, Except)
 	cardId := GoUtil.RandSlice(cardList)
 	return cardId
 }
 
 func RankGoldCard() (int, int) {
-	return randCard(0, 4, 1), randCard(0, 5, 1)
+	Card1 := randCard(0, 4, 1, []int{})
+	Card2 := randCard(0, 5, 1, []int{Card1})
+	return Card1, Card2
 }

src/server/game/mod/charge/Charge.go

@@ -6,7 +6,6 @@ import (
 	chargeCfg "server/conf/charge"
 	mergeDataCfg "server/conf/mergeData"
 	"server/game/mod/item"
-	"server/game/mod/order"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 )
@@ -29,7 +28,10 @@ type ChargeMod struct {
 
 	Ad bool // 是否购买免广告
 }
-
+type Rand struct {
+	ChessId int
+	Diamond int
+}
 type ChessShop struct {
 	Diamond int
 	Count   int
@@ -236,54 +238,33 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 		return
 	}
 	c.ChessShop = make(map[int]*ChessShop)
-	EmitColor := make(map[string]int)
+	ColorList := make([]string, 0)
 	for _, v := range Emit {
-		Color := mergeDataCfg.GetColorById(v)
-		ProduceList := mergeDataCfg.GetEmitTypeProduce(Color)
-		Type2 := mergeDataCfg.GetEmitType2(Color)
-		for _, Produce := range ProduceList {
-			if _, ok := EmitColor[Produce]; ok {
-				continue
-			}
-			EmitColor[Produce] = Type2
-		}
-	}
-	type Rand struct {
-		ChessId int
-		Diamond int
-	}
-	RandList := make([]interface{}, 0)
-	for k, v := range EmitColor {
-		for i := 1; i <= 99; i++ {
-			ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, k)
-			if ChessId == 0 {
-				break
-			}
-			ChessType := mergeDataCfg.GetTypeById(ChessId)
-			if ChessType == "Emitter" {
-				RandList = append(RandList, Rand{
-					ChessId: ChessId,
-					Diamond: ChessDiamondCfg[i],
-				})
-				if i >= 4 {
-					break
-				}
-			} else {
-				EmitId := order.GetEmitByColor(Emit, k)
-				Mul := mergeDataCfg.GetSellDiamondMul(EmitId, k)
-				Diamond := GetChessDiamond(i, v) * Mul
-				RandList = append(RandList, Rand{
-					ChessId: ChessId,
-					Diamond: Diamond,
-				})
-			}
-		}
+		ProduceList := mergeDataCfg.GetEmitProduceType(v)
+		ColorList = append(ColorList, ProduceList...)
 	}
 
-	L := GoUtil.RandSliceNum2(RandList, 5)
+	RandList := make([]*Rand, 0)
+	for _, v := range ColorList {
+		ColorType := mergeDataCfg.GetColorType(v)
+		r := make([]*Rand, 0)
+		if ColorType == mergeDataCfg.CHESS_PRODUCT_MAIN_TYPE {
+			r = getChessMainRand(v)
+		} else if ColorType == mergeDataCfg.CHESS_PRODUCT_SECONDARY_TYPE {
+			r = getChessSecondaryRand(v)
+		} else if ColorType == mergeDataCfg.CHESS_PRODUCT_SUB_TYPE {
+			r = getChessSubRand(v)
+		}
+		RandList = append(RandList, r...)
+	}
+	randList := make([]interface{}, len(RandList))
+	for k, v := range RandList {
+		randList[k] = v
+	}
+	L := GoUtil.RandSliceNum2(randList, 5)
 	for k, v := range L {
-		Diamond := v.(Rand).Diamond
-		ChessId := v.(Rand).ChessId
+		Diamond := v.(*Rand).Diamond
+		ChessId := v.(*Rand).ChessId
 		c.ChessShop[k+1] = &ChessShop{Diamond: Diamond, Count: 5, Id: ChessId}
 	}
 }

src/server/game/mod/charge/ChargeFunc.go

@@ -1,6 +1,9 @@
 package charge
 
-import "math"
+import (
+	"math"
+	mergeDataCfg "server/conf/mergeData"
+)
 
 func GetChessDiamond(Lv, Type int) int {
 	Diamond := 0.0
@@ -18,3 +21,33 @@ func GetChessDiamond(Lv, Type int) int {
 	}
 	return max(1, d)
 }
+
+func getChessMainRand(Color string) []*Rand {
+	r := make([]*Rand, 0)
+	for i := 6; i <= 10; i++ {
+		Diamond := int(math.Pow(2, float64(i-1)) / 2.5)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
+	}
+	return r
+}
+
+func getChessSecondaryRand(Color string) []*Rand {
+	r := make([]*Rand, 0)
+	for i := 5; i <= 9; i++ {
+		Diamond := int((math.Pow(2, float64(i-1)) / 2.5) * 2)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
+	}
+	return r
+}
+
+func getChessSubRand(Color string) []*Rand {
+	r := make([]*Rand, 0)
+	for i := 5; i <= 9; i++ {
+		Diamond := int(math.Pow(2, float64(i-1))/2.5 + 6.4)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
+	}
+	return r
+}

src/server/game/mod/dailyTask/DailyTask.go

@@ -100,7 +100,7 @@ func (dt *DailyTaskMod) WeekUpdate() {
 		i++
 	}
 	weekReward[6] = WeekReward{
-		Id:    9,
+		Id:    0,
 		Items: []*item.Item{{Id: item.ITEM_FIVE_STAR_CARD_PACK, Num: 1}},
 	}
 	dt.Active = 0

src/server/game/mod/friend/Friend.go

@@ -9,6 +9,7 @@ import (
 type FriendMod struct {
 	FriendList map[int]struct{}          // 好友列表
 	ApplyList  map[int]int64             // 请求列表
+	SendApply  map[int]int64             // 发送的申请
 	Card       map[string]*card.CardInfo // 收到的申请交换
 	Log        []*LogInfo                // 日志
 	AutoId     int
@@ -55,6 +56,9 @@ func (f *FriendMod) InitData() {
 	if f.Card == nil {
 		f.Card = make(map[string]*card.CardInfo)
 	}
+	if f.SendApply == nil {
+		f.SendApply = make(map[int]int64)
+	}
 }
 
 func (f *FriendMod) AddFriend(id int) {
@@ -106,12 +110,28 @@ func (f *FriendMod) GetFriendList() []int {
 	return list
 }
 
+// 收到申请
 func (f *FriendMod) AddFriendApply(Uid int) {
 	f.ApplyList[Uid] = GoUtil.Now()
 }
 
+// 发送申请
+func (f *FriendMod) AddSendApply(Uid int) bool {
+	if _, ok := f.SendApply[Uid]; ok {
+		return true
+	}
+	f.SendApply[Uid] = GoUtil.Now()
+	return false
+}
+
+func (f *FriendMod) CheckSendApply(Id int) bool {
+	_, ok := f.SendApply[Id]
+	return ok
+}
+
 func (f *FriendMod) AgreeApply(UId int) {
 	f.AddFriend(UId)
+	delete(f.SendApply, UId)
 	delete(f.ApplyList, UId)
 }
 

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

@@ -38,6 +38,7 @@ type LimitedTimeEventMod struct {
 	ProgressMax    int
 	LastOption     []int
 	BonusNum       int
+	First          bool
 }
 
 type LTEInfo struct {
@@ -193,11 +194,12 @@ func (l *LimitedTimeEventMod) GetMeteorReward(MergeList []int) []*item.Item {
 }
 
 // 获取宝箱雨奖励
-func (l *LimitedTimeEventMod) GetChestReward(MergeList []int) ([]*item.Item, int, int, int) {
+func (l *LimitedTimeEventMod) GetChestReward(MergeList []int) []*item.Item {
 	Star := 0
 	for _, v := range MergeList {
 		Star += mergeDataCfg.GetStarById(v)
 	}
+
 	return limitedTimeEventCfg.GetChestReward(Star)
 }
 
@@ -236,6 +238,15 @@ func (l *LimitedTimeEventMod) AddProgress(Lv int) {
 	}
 	l.Progress++
 	if l.Progress == l.ProgressMax {
+		if !l.First {
+			l.First = true
+			EventId := limitedTimeEventCfg.GetFirstEvent()
+			l.ProgressReward = map[int]int{
+				1: EventId,
+			}
+			l.LastOption = []int{EventId}
+			return
+		}
 		SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
 		BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
 		RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)

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

@@ -40,12 +40,14 @@ const (
 	Super_type       = 3 // 超级订单
 	Preheat_type     = 4 // 预热订单
 	Trigger_type     = 5 // 触发订单
-	Clean_type       = 6 // 清理订单
+	Clean_type       = 6 // 退役发射器清理订单
 	Clean_Order_type = 7 // 清理无法生成订单的棋子
+	Clean_type2      = 8 // 棋盘空格不足清理棋子的订单
+	COMFORT_TYPE     = 9 // 安慰订单
 
-	diff_low  = 1 // 低难度
-	diff_mid  = 2 // 中难度
-	diff_high = 3 // 高难度
+	DIFF_LOW  = 1 // 低难度
+	DIFF_MID  = 2 // 中难度
+	DIFF_HIGH = 3 // 高难度
 )
 
 func (o *OrderMod) InitData() {
@@ -60,7 +62,7 @@ func (o *OrderMod) InitData() {
 		Cfg := startOrderCfg.GetStartOrderByStep(o.Step + 1)
 		o.Step = 1
 		o.Auto_id = 0
-		o.LastDiff = diff_low
+		o.LastDiff = DIFF_LOW
 		for _, v := range Cfg {
 			o.Auto_id++
 			o.OrderList[o.Auto_id] = Order{
@@ -120,7 +122,7 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 			if NewChessId == 0 {
 				return fmt.Errorf("CreateOrder: NewChessId is 0, EnergyMul: %d, PreheatStep: %d, ChessColor: %s", EnergyMul, PreheatStep, ChessColor)
 			}
-			o.addOrder([]int{NewChessId}, diff_low, Preheat_type)
+			o.addOrder([]int{NewChessId}, DIFF_LOW, Preheat_type)
 			o.PreheatStep[ChessColor]++
 		}
 	default:
@@ -137,7 +139,7 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 			Cfg := startOrderCfg.GetStartOrderByStep(o.Step + 1)
 			o.Step++
 			for _, v := range Cfg {
-				o.addOrder(v.MergeList, diff_low, Common_type)
+				o.addOrder(v.MergeList, DIFF_LOW, Common_type)
 			}
 			return nil
 		} else {
@@ -196,13 +198,13 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
 					B := GoUtil.RandMap(map[int]int{0: 80, 1: 20})
 					if B == 1 {
 						NewColor := GoUtil.RandStringSlice(Produce[1:])
-						DiffLv := GoUtil.RandMap(map[int]int{diff_low: 70, diff_mid: 30})
+						DiffLv := GoUtil.RandMap(map[int]int{DIFF_LOW: 70, DIFF_MID: 30})
 						NewChessId := 0
 						switch DiffLv {
-						case diff_low:
+						case DIFF_LOW:
 							NewLv := GoUtil.RandNum(4, 3+DurLv)
 							NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor)
-						case diff_mid:
+						case DIFF_MID:
 							NewLv := GoUtil.RandNum(4+DurLv, 3+DurLv*2)
 							NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor)
 						}
@@ -223,7 +225,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 	}
 	randNum := 0
 	mergeList := make([]int, 0)
-	OrderDiff := diff_low
+	OrderDiff := DIFF_LOW
 	var err error
 	for {
 		if randNum > 50 {
@@ -259,14 +261,14 @@ func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
 	}
 	randNum := 0
 	mergeList := make([]int, 0)
-	OrderDiff := diff_low
+	OrderDiff := DIFF_LOW
 	var err error
 	for {
 		if randNum > 50 {
 			break
 		}
 		randNum++
-		mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul)
+		mergeList, OrderDiff, err = randSuperOrderChess(o, lv, Emit, EnergyMul)
 		if err != nil {
 			continue
 		}
@@ -364,7 +366,7 @@ func (o *OrderMod) CreateTriggerOrder(lv int, Emit []int, EnergyMul int) (int, e
 		}
 	}
 	if len(mergeList) > 0 {
-		o.addOrder(mergeList, diff_low, Trigger_type)
+		o.addOrder(mergeList, DIFF_LOW, Trigger_type)
 		return getOrderStar(mergeList), nil
 	} else {
 		for k, v := range o.OrderList {
@@ -402,12 +404,12 @@ func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) {
 }
 
 func (o *OrderMod) CreateCleanOrder(ChessList []int) bool {
-	o.addOrder(ChessList, diff_low, Clean_type)
+	o.addOrder(ChessList, DIFF_LOW, Clean_type)
 	return true
 }
 
 func (o *OrderMod) CreateCleanOrder2(ChessList []int) bool {
-	o.addOrder(ChessList, diff_low, Clean_Order_type)
+	o.addOrder(ChessList, DIFF_LOW, Clean_Order_type)
 	return true
 }
 
@@ -445,7 +447,7 @@ 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)
+			o.addOrder([]int{ChessId}, DIFF_LOW, Preheat_type)
 		}
 	}
 	//额外订单补充2；当玩家的棋盘中出现三个相同的满级产物时，立刻生成一个对应的收购订单；
@@ -453,7 +455,7 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
 		ChessNum := GoUtil.GetElemNum(ChessList, k)
 		if ChessNum == 3 {
 			b1 = true
-			o.addOrder([]int{k, k, k}, diff_low, Extra_type)
+			o.addOrder([]int{k, k, k}, DIFF_LOW, Extra_type)
 		}
 	}
 	return b1
@@ -523,7 +525,7 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 				continue
 			}
 			delete(o.OrderList, k)
-			o.addOrder([]int{NewChessId}, diff_low, Preheat_type)
+			o.addOrder([]int{NewChessId}, DIFF_LOW, Preheat_type)
 		}
 		if v.Type != Common_type {
 			continue
@@ -566,3 +568,26 @@ func (o *OrderMod) DelOrder(OrderId int) error {
 	delete(o.OrderList, OrderId)
 	return nil
 }
+
+func (o *OrderMod) CreateComfortOrder(lv int, Emit []int, EnergyMul, Diff, ChessNum int) error {
+	if len(Emit) == 0 {
+		return nil
+	}
+	randNum := 0
+	mergeList := make([]int, 0)
+	var err error
+	for {
+		if randNum > 50 {
+			break
+		}
+		randNum++
+		mergeList, _, err = randOrderChessWithDiff(o, lv, Emit, EnergyMul, Diff, ChessNum)
+		if err != nil {
+			continue
+		}
+
+		break
+	}
+	o.addOrder(mergeList, Diff, COMFORT_TYPE)
+	return nil
+}

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

@@ -22,23 +22,23 @@ func getChessNumRand(OrderN int) map[int]int {
 func getOrderDiffRand(Diff, OrderN int) map[int]int {
 	var d map[int]int
 	switch Diff {
-	case diff_low:
+	case DIFF_LOW:
 		d = map[int]int{
-			diff_low:  int(10 - OrderN),
-			diff_mid:  int(30),
-			diff_high: int(60 + OrderN),
+			DIFF_LOW:  int(10 - OrderN),
+			DIFF_MID:  int(30),
+			DIFF_HIGH: int(60 + OrderN),
 		}
-	case diff_mid:
+	case DIFF_MID:
 		d = map[int]int{
-			diff_low:  int(21 - 3*OrderN),
-			diff_mid:  int(49 + 1.5*float64(OrderN)),
-			diff_high: int(30 + 1.5*float64(OrderN)),
+			DIFF_LOW:  int(21 - 3*OrderN),
+			DIFF_MID:  int(49 + 1.5*float64(OrderN)),
+			DIFF_HIGH: int(30 + 1.5*float64(OrderN)),
 		}
-	case diff_high:
+	case DIFF_HIGH:
 		d = map[int]int{
-			diff_low:  int(60 - 5*OrderN),
-			diff_mid:  int(30 + 3*float64(OrderN)),
-			diff_high: int(10 + 2*float64(OrderN)),
+			DIFF_LOW:  int(60 - 5*OrderN),
+			DIFF_MID:  int(30 + 3*float64(OrderN)),
+			DIFF_HIGH: int(10 + 2*float64(OrderN)),
 		}
 	}
 	return d
@@ -54,85 +54,85 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 		}
 	case 2:
 		switch OrderDiff {
-		case diff_low:
+		case DIFF_LOW:
 			rand := map[int]int{
-				diff_low: 99 - OrderN,
-				diff_mid: 1 + OrderN,
+				DIFF_LOW: 99 - OrderN,
+				DIFF_MID: 1 + OrderN,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 			}
-		case diff_mid:
+		case DIFF_MID:
 			rand := map[int]int{
-				diff_low: 5 + OrderN,
-				diff_mid: 95 - OrderN,
+				DIFF_LOW: 5 + OrderN,
+				DIFF_MID: 95 - OrderN,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 			}
-		case diff_high:
+		case DIFF_HIGH:
 			rand := map[int]int{
-				diff_low:  int(95 - 10*OrderN),
-				diff_mid:  int(4 + 6*OrderN),
-				diff_high: int(1 + 4*OrderN),
+				DIFF_LOW:  int(95 - 10*OrderN),
+				DIFF_MID:  int(4 + 6*OrderN),
+				DIFF_HIGH: int(1 + 4*OrderN),
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 			}
 		}
 	case 3:
 		switch OrderDiff {
-		case diff_low:
+		case DIFF_LOW:
 			rand := map[int]int{
-				diff_low: 95 - OrderN,
-				diff_mid: 5 + OrderN,
+				DIFF_LOW: 95 - OrderN,
+				DIFF_MID: 5 + OrderN,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				diff_low: 60 - 4*OrderN,
-				diff_mid: 40 + 4*OrderN,
+				DIFF_LOW: 60 - 4*OrderN,
+				DIFF_MID: 40 + 4*OrderN,
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 				3: thirdDiff,
 			}
-		case diff_mid:
+		case DIFF_MID:
 			rand := map[int]int{
-				diff_low: 50 - 3*OrderN,
-				diff_mid: 50 + 3*OrderN,
+				DIFF_LOW: 50 - 3*OrderN,
+				DIFF_MID: 50 + 3*OrderN,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				diff_mid:  95 - 4*OrderN,
-				diff_high: 5 + 4*OrderN,
+				DIFF_MID:  95 - 4*OrderN,
+				DIFF_HIGH: 5 + 4*OrderN,
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 				3: thirdDiff,
 			}
-		case diff_high:
+		case DIFF_HIGH:
 			rand := map[int]int{
-				diff_low: int(95 - 10*OrderN),
-				diff_mid: int(5 + 10*OrderN),
+				DIFF_LOW: int(95 - 10*OrderN),
+				DIFF_MID: int(5 + 10*OrderN),
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				diff_mid:  int(95 - 8*OrderN),
-				diff_high: int(5 + 8*OrderN),
+				DIFF_MID:  int(95 - 8*OrderN),
+				DIFF_HIGH: int(5 + 8*OrderN),
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: diff_low,
+				1: DIFF_LOW,
 				2: secondDiff,
 				3: thirdDiff,
 			}
@@ -146,12 +146,12 @@ func getChessLv(Min, Max, Diff int) int {
 	Start := Min
 	End := Max
 	switch Diff {
-	case diff_low:
+	case DIFF_LOW:
 		End = Min + (Max-Min+1)/3 - 1
-	case diff_mid:
+	case DIFF_MID:
 		Start = Min + (Max-Min+1)/3
 		End = Min + (Max-Min+1)/3*2 - 1
-	case diff_high:
+	case DIFF_HIGH:
 		Start = Min + (Max-Min+1)/3*2
 	}
 	Start = max(Min, Start)
@@ -207,6 +207,77 @@ func GetEmitByColor(Emit []int, color string) int {
 	return 0
 }
 
+// 随机生成超级订单棋子
+func randSuperOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int, error) {
+	initReflectChess(Emit, EnergyMul)
+	filterPool(o)
+	OrderN, err := userCfg.GetOrderNByLv(lv)
+	RandChessNum := map[int]int{
+		2: 70 - OrderN,
+		3: 30 + OrderN,
+	}
+	if err != nil {
+		return nil, DIFF_LOW, err
+	}
+	// 生成订单难度和棋子数量
+	ChessNum := GoUtil.RandMap(RandChessNum)
+	OrderDiff := DIFF_HIGH
+	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 randOrderChessWithDiff(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff, ChessNum int) ([]int, int, error) {
+	initReflectChess(Emit, EnergyMul)
+	filterPool(o)
+	OrderN, err := userCfg.GetOrderNByLv(lv)
+	if err != nil {
+		return nil, DIFF_LOW, err
+	}
+	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 randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
@@ -214,7 +285,7 @@ func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int,
 	OrderN, err := userCfg.GetOrderNByLv(lv)
 	RandChessNum := getChessNumRand(OrderN)
 	if err != nil {
-		return nil, diff_low, err
+		return nil, DIFF_LOW, err
 	}
 	// 生成订单难度和棋子数量
 	ChessNum := GoUtil.RandMap(RandChessNum)
@@ -225,7 +296,12 @@ func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int,
 	// 根据订单棋子难度生成棋子
 	for _, v := range ChessDiff {
 		ChessId := 0
+		Num := 0
 		for {
+			Num++
+			if Num > 50 {
+				break
+			}
 			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
 			if ChessId == 0 {
 				continue
@@ -388,19 +464,19 @@ func initReflectChess(Emits []int, EnergyMul int) {
 		End = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3 - 1
 		for _, v := range Product {
 			Adjust := mergeDataCfg.DynamicAdjust(Emit, v)
-			initReflectChess2(v, Start, End, diff_low, Adjust)
+			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)
+			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)
+			initReflectChess2(v, Start, End, DIFF_HIGH, Adjust)
 		}
 	}
 }