Merge branch 'develop' into sdk

src/server/GoUtil/sliceUtil.go

@@ -2,6 +2,7 @@ package GoUtil
 
 import (
 	"fmt"
+	"reflect"
 	"server/game/mod/item"
 	"sort"
 	"strconv"
@@ -232,18 +233,43 @@ func PopSlice(s []int) (int, []int) {
 	return s[0], s[1:]
 }
 
+// 判断两个切片的元素是否一致
 func SliceEqual(a, b []int) bool {
 	if len(a) != len(b) {
 		return false
 	}
-	sort.Ints(a)
+
-	sort.Ints(b)
+	// 创建副本以避免修改原始切片
-	for k, v := range a {
+	aCopy := make([]int, len(a))
-		if v != b[k] {
+	bCopy := make([]int, len(b))
-			return false
+	copy(aCopy, a)
-		}
+	copy(bCopy, b)
+
+	// 对切片进行排序
+	sort.Ints(aCopy)
+	sort.Ints(bCopy)
+
+	// 比较排序后的切片
+	return reflect.DeepEqual(aCopy, bCopy)
+}
+
+func SlicesEqualString(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
 	}
-	return true
+
+	// 创建副本以避免修改原始切片
+	aCopy := make([]string, len(a))
+	bCopy := make([]string, len(b))
+	copy(aCopy, a)
+	copy(bCopy, b)
+
+	// 对切片进行排序
+	sort.Strings(aCopy)
+	sort.Strings(bCopy)
+
+	// 比较排序后的切片
+	return reflect.DeepEqual(aCopy, bCopy)
 }
 
 // IsContainSlice checks if all elements of s2 are contained in s.

src/server/conf/decorate/DecorateCfg.go

@@ -5,6 +5,7 @@ import (
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
+	"strings"
 )
 
 const (
@@ -88,21 +89,21 @@ func GetProgressReward(Scene, Lv int) []*item.Item {
 	}
 	for _, v := range value {
 		if gamedata.GetIntValue(v, "Scene") == Scene && gamedata.GetIntValue(v, "Lv") == Lv {
-			return gamedata.GetItemList(v, "Item")
+			return gamedata.GetItemList(v, "AreaReward")
 		}
 	}
 	return nil
 }
 
-func GetDecoarteReward(Scene int) []*item.Item {
+func GetDecoarteReward(Scene int, Lv int) []*item.Item {
 	value, err := gamedata.GetData(INDOOR_PROGRESS)
 	if err != nil {
 		log.Debug("IndoorProgress GetDecoarteReward not found")
 		return nil
 	}
 	for _, v := range value {
-		if gamedata.GetIntValue(v, "Scene") == Scene && gamedata.GetIntValue(v, "Lv") == 1 {
+		if gamedata.GetIntValue(v, "Scene") == Scene && gamedata.GetIntValue(v, "Lv") == Lv {
-			return gamedata.GetItemList(v, "AreaReward")
+			return gamedata.GetItemList(v, "Item")
 		}
 	}
 	return nil
@@ -150,3 +151,56 @@ func GetDecoratePExp(AreaId, SortId int) int {
 	}
 	return 0
 }
+
+func GetAllPartId() []int {
+	data, err := gamedata.GetDataByKey(DECORATE_CONST, "AllPartId")
+	if err != nil {
+		log.Debug("DecorateCost GetAllPartId not found")
+		return []int{1505, 1515, 1525, 1535}
+	}
+	var PartIdList []int
+	str := gamedata.GetStringValue(data, "Value")
+	r1 := strings.Split(str, "|")
+	for _, v := range r1 {
+		id, _ := strconv.Atoi(v)
+		PartIdList = append(PartIdList, id)
+	}
+	return PartIdList
+}
+
+func GetIdBySenceAndLv(Sence, Lv int) int {
+	data, err := gamedata.GetData(INDOOR_PROGRESS)
+	if err != nil {
+		log.Debug("DecorateArea GetIdBySenceAndLv not found")
+		return 0
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Scene") == Sence && gamedata.GetIntValue(v, "Lv") == Lv {
+			id, _ := strconv.Atoi(k)
+			return id
+		}
+	}
+	return 0
+}
+
+func GetPartNumByAreaId(AreaId int) map[int]int {
+	data, err := gamedata.GetData(INDOOR_PROGRESS)
+	if err != nil {
+		log.Debug("DecorateArea GetPartNumByAreaId not found AreaId:%v", AreaId)
+		return nil
+	}
+	res := make(map[int]int)
+	for k, v := range data {
+		Sence := gamedata.GetIntValue(v, "Scene")
+		if Sence != AreaId {
+			continue
+		}
+		id, _ := strconv.Atoi(k)
+		PartNum := gamedata.GetIntValue(v, "Part")
+		if PartNum == 0 {
+			continue
+		}
+		res[id] = PartNum
+	}
+	return res
+}

src/server/conf/guideTask/GuideTaskCfg.go

@@ -0,0 +1,82 @@
+package GuideTaskCfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/pkg/github.com/name5566/leaf/log"
+	"strconv"
+)
+
+const (
+	GUIDE_TASK_CONST  = "GuideTaskConst"
+	GUIDE_TASK_TASK   = "GuideTaskTask"
+	GUIDE_TASK_ACTIVE = "GuideTaskActive"
+)
+
+func init() {
+	gamedata.InitCfg(GUIDE_TASK_CONST)
+	gamedata.InitCfg(GUIDE_TASK_TASK)
+	gamedata.InitCfg(GUIDE_TASK_ACTIVE)
+}
+
+func GetTaskRewardById(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetTaskById(Id int) string {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Task")
+}
+
+func GetTaskActive(Id int) int {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_TASK, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Active")
+}
+
+func GetActiveReward(Id int) ([]*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(GUIDE_TASK_ACTIVE, Id)
+	if err != nil {
+		return nil, 0
+	}
+	return gamedata.GetItemList(data, "Items"), gamedata.GetIntValue(data, "Active")
+}
+
+func GetUnlockLv() int {
+	data, err := gamedata.GetDataByKey(GUIDE_TASK_CONST, "UnlockLv")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetDays() int {
+	data, err := gamedata.GetDataByKey(GUIDE_TASK_CONST, "Days")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetTaskList(Lv int) map[int]string {
+	r := make(map[int]string)
+	data, err := gamedata.GetData(GUIDE_TASK_TASK)
+	if err != nil {
+		log.Debug("GetTaskList get data nil")
+		return r
+	}
+	for k, v := range data {
+		k1, _ := strconv.Atoi(k)
+		r[k1] = gamedata.GetStringValue(v, "Task")
+	}
+	return r
+}

src/server/conf/guideTask/GuideTaskCfg_test.go

@@ -0,0 +1,51 @@
+package GuideTaskCfg
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGuideTaskCfg_NoPanic(t *testing.T) {
+	ids := []int{-1, 0, 1, 999999}
+	for _, id := range ids {
+		t.Run(fmt.Sprintf("Id=%d", id), func(t *testing.T) {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Fatalf("unexpected panic: %v", r)
+				}
+			}()
+			_ = GetTaskRewardById(id)
+			_ = GetTaskActive(id)
+			_, _ = GetActiveReward(id)
+		})
+	}
+	_ = GetUnlockLv()
+	_ = GetDays()
+}
+
+// 以下 Example 用于文档与编译校验（无固定输出校验）
+
+func ExampleGetTaskRewardById() {
+	_ = GetTaskRewardById(1)
+	// Output:
+}
+
+func ExampleGetTaskActive() {
+	_ = GetTaskActive(1)
+	// Output:
+}
+
+func ExampleGetActiveReward() {
+	_, _ = GetActiveReward(1)
+	// Output:
+}
+
+func ExampleGetUnlockLv() {
+	_ = GetUnlockLv()
+	// Output:
+}
+
+func ExampleGetDays() {
+	_ = GetDays()
+	// Output:
+}

src/server/conf/mergeData/MergeDataCfg.go

@@ -131,7 +131,7 @@ func GetChessIdByLvAndColor(Lv int, Color string) int {
 			return Id
 		}
 	}
-	log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
+	// log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
 	return 0
 }
 
@@ -169,7 +169,7 @@ func GetMaxLvByColor(Color string) int {
 func GetEmitMinLvById(Id string) int {
 	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
 	if err != nil {
-		log.Debug("GetMaxLvById GetOne Id:%v not found", Id)
+		log.Debug("GetEmitMinLvById GetOne Id:%v not found", Id)
 		return 0
 	}
 	return gamedata.GetIntValue(data, "Emit_Min_Lv")
@@ -179,12 +179,21 @@ func GetEmitMinLvById(Id string) int {
 func GetEmitRatio(Id string) float64 {
 	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
 	if err != nil {
-		log.Debug("GetMaxLvById GetOne Id:%v not found", Id)
+		log.Debug("GetEmitRatio GetOne Id:%v not found", Id)
 		return 0
 	}
 	return gamedata.GetFloatValue(data, "Ratio")
 }
 
+func GetEmitRetire(Id string) int {
+	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
+	if err != nil {
+		log.Debug("GetEmitRetire GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Retire")
+}
+
 // 根据Id获取棋子类型
 func GetTypeById(Id int) string {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
@@ -209,7 +218,7 @@ func GetColorById(Id int) string {
 func GetSellNumById(Id int) int {
 	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
 	if err != nil {
-		log.Debug("GetColorById GetOne Id:%v not found", Id)
+		log.Debug("GetSellNumById GetOne Id:%v not found", Id)
 		return 0
 	}
 	return gamedata.GetIntValue(data, "SellNum")

src/server/conf/order/orderCfg.go

@@ -11,6 +11,8 @@ const (
 	CFG_ORDER_CHESS_DATA = "OrderChessData"
 	CFG_ORDER_NUM_DATA   = "OrderNumData"
 	CFG_START_ORDER      = "StartOrder"
+	CFG_CONST            = "OrderConst"
+	CFG_ORDER_SCENE      = "OrderScene"
 )
 
 func init() {
@@ -18,6 +20,24 @@ func init() {
 	gamedata.InitCfg(CFG_ORDER_CHESS_DATA)
 	gamedata.InitCfg(CFG_ORDER_NUM_DATA)
 	gamedata.InitCfg(CFG_START_ORDER)
+	gamedata.InitCfg(CFG_CONST)
+	gamedata.InitCfg(CFG_ORDER_SCENE)
+}
+
+func GetOrderFactor(Scene int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_ORDER_SCENE, Scene)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Factor")
+}
+
+func GetEmitExtraOrder() string {
+	data, err := gamedata.GetDataByKey(CFG_CONST, "EmitId_Extra_Order")
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Value")
 }
 
 func GetLvMin(EnergyMul int) int {
@@ -61,6 +81,28 @@ func GetOrderNum(Level int) int {
 	return 0
 }
 
+func GetStartOrderList() []*gamedata.StartOrderData {
+	ret := make([]*gamedata.StartOrderData, 0)
+	data, err := gamedata.GetData(CFG_START_ORDER)
+	if err != nil {
+		return ret
+	}
+	for k, v := range data {
+		OrderId, _ := strconv.Atoi(k)
+		ret = append(ret, &gamedata.StartOrderData{
+			Id:        OrderId,
+			MergeList: gamedata.GetIntSliceValue(v, "merge_id_list"),
+			Appear:    gamedata.GetStringValue(v, "appear"),
+			Preview:   gamedata.GetStringValue(v, "preview"),
+			Items:     gamedata.GetItemList(v, "reward"),
+		})
+	}
+	sort.Slice(ret, func(i, j int) bool {
+		return ret[i].Id < ret[j].Id
+	})
+	return ret
+}
+
 func GetStartOrderByStep(id int) []*gamedata.StartOrderData {
 	ret := make([]*gamedata.StartOrderData, 0)
 	data, err := gamedata.GetData(CFG_START_ORDER)
@@ -115,3 +157,11 @@ func GetMaxStep() int {
 	}
 	return max
 }
+
+func GetOrderType(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_START_ORDER, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "type")
+}

src/server/conf/playroom/playroomCfg.go

@@ -190,6 +190,14 @@ func GetInteractNum() int {
 	return gamedata.GetIntValue(data, "Value")
 }
 
+func GetInteractUnlock() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "InteractUnlock")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
 func GetVisitorItem() int {
 	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "VisitorItem")
 	if err != nil {

src/server/game/ChargeFunc.go

@@ -6,6 +6,7 @@ import (
 	"server/game/mod/item"
 	MsgMod "server/game/mod/msg"
 	"server/game/mod/piggyBank"
+	"server/game/mod/quest"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 )
@@ -16,6 +17,9 @@ func Charge(p *Player, ChargeId int) {
 	PiggyBankFire(p, ChargeId) // 猪猪银行
 	PlayroomFire(p, ChargeId)  // 游乐场
 	ActivityFire(p, ChargeId)  // 活动礼包
+	OrderMod := p.PlayMod.getOrderMod()
+	OrderMod.SetIsCharge() // 设置订单模块为充值状态
+	p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_PURCHASE, A: []interface{}{}})
 }
 
 func SendCharge(p *Player, d *ChargeExtra) {

src/server/game/GameLogic.go

@@ -690,6 +690,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqSetEnergyMul", RegSetEneryFunc)                 //设置能量倍数
 	RegisterMsgProcessFunc("ReqChessEx", ReqChessEx)                           // 转换棋子
 	RegisterMsgProcessFunc("ReqGetChessFromBuff", ReqGetChessFromBuff)         // 从buff中获取棋子
+	RegisterMsgProcessFunc("ReqPutPartInBag", ReqPutPartInBag)                 // 把零件放入背包
 	RegisterMsgProcessFunc("ReqPutChessInBag", ReqPutChessInBag)               // 把棋子放入背包
 	RegisterMsgProcessFunc("ReqTakeChessOutBag", ReqTakeChessOutBag)           // 从背包中取出棋子
 	RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid)           // 解锁背包格子
@@ -736,6 +737,9 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqGetDailyTaskReward", ReqGetDailyTaskReward) // 领取日常任务奖励
 	RegisterMsgProcessFunc("ReqGetDailyWeekReward", ReqGetDailyWeekReward) // 领取周活跃奖励
 	RegisterMsgProcessFunc("ReqDailyUnlock", ReqDailyUnlock)               // 日常任务解锁
+	// 新手任务
+	RegisterMsgProcessFunc("ReqGetGuideTaskReward", ReqGetGuideTaskReward)     // 领取日新手任务奖励
+	RegisterMsgProcessFunc("ReqGetGuideActiveReward", ReqGetGuideActiveReward) // 领取活跃奖励
 
 	// 引导奖励
 	RegisterMsgProcessFunc("ReqGuideReward", ReqGuideReward)     // 领取引导奖励
@@ -759,7 +763,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqFastProduceReward", ReqFastProduceReward)   // 连击快手奖励
 	RegisterMsgProcessFunc("ReqFastProduceInfo", ReqFastProduceInfo)       // 请求连击快手数据
 	RegisterMsgProcessFunc("ReqLimitSenceReward", ReqLimitSenceReward)     // 获取场景转盘奖励
-	RegisterMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent)     //领取限时事件进度奖励
+	RegisterMsgProcessFunc("ReqSelectLimitEvent", ReqSelectLimitEvent)     //领取Bouns限时事件进度奖励
 	RegisterMsgProcessFunc("ReqGetGoldCard", ReqGetGoldCard)               //请求金卡交换信息
 	RegisterMsgProcessFunc("ReqLimitEventLuckyCat", ReqLimitEventLuckyCat) //幸运猫获取奖励
 	RegisterMsgProcessFunc("ReqCatTrickReward", ReqCatTrickReward)         //小猫戏法获取奖励

src/server/game/Gm.go

@@ -17,11 +17,13 @@ import (
 	"server/game/mod/activity"
 	"server/game/mod/avatar"
 	"server/game/mod/card"
+	"server/game/mod/decorate"
 	"server/game/mod/emoji"
 	"server/game/mod/face"
 	"server/game/mod/friend"
 	"server/game/mod/item"
 	MsgMod "server/game/mod/msg"
+	"server/game/mod/order"
 	"server/game/mod/playroom"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -42,7 +44,7 @@ func ReqGmCommand_(player *Player, Command string) error {
 	// 		log.Error("ReqGmCommand panic: %v", err)
 	// 	}
 	// }()
-	if conf.Server.GameName != "pet_home" && conf.Server.GameName != "merge_pet_sdk" {
+	if conf.Server.GameName != "pet_home" && conf.Server.GameName != "merge_pet_sdk" && conf.Server.GameName != "Merge_Pet_Local" {
 		return fmt.Errorf("Player %d ReqGmCommand not support in game %s, command %s", player.M_DwUin, conf.Server.GameName, Command)
 	}
 	player.TeLog("gm", map[string]interface{}{
@@ -83,12 +85,20 @@ func ReqGmCommand_(player *Player, Command string) error {
 		DailyMod := player.PlayMod.getDailyTaskMod()
 		DailyMod.Active = num
 		player.PushClientRes(DailyMod.BackData())
+	case "triggerOrder":
+		OrderMod := player.PlayMod.getOrderMod()
+		ChessMod := player.PlayMod.getChessMod()
+		OrderMod.TriggerOrder(player.GetPlayerBaseMod().GetLevel(), order.TRIGGER_TYPE_ORDER, ChessMod.GetEmitList(), 1)
+		player.PushClientRes(OrderMod.BackData())
 	case "setlv":
 		num, _ := strconv.Atoi(arg[1])
 		player.PlayMod.getBaseMod().Level = num
 		player.PlayMod.getBaseMod().Exp = 0
 		player.PushClientRes(player.PlayerBaseMod.BackAsset())
 		player.initAcitivity()
+		player.PlayMod.getGuideTaskMod().Unlock(num)
+		player.PlayMod.getOrderMod().TriggerOrder(num, order.TRIGGER_TYPE_LV, nil, 1)
+		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 		player.BackDataActivity()
 	case "zeroUpdate":
 		VarMod := player.PlayMod.getVarMod()
@@ -286,7 +296,7 @@ func ReqGmCommand_(player *Player, Command string) error {
 		PlayroomMod := player.PlayMod.getPlayroomMod()
 		PlayroomMod.NewCollect = make(map[int]*playroom.CollectInfo, 0)
 		for _, v := range CollectList {
-			PlayroomMod.AddCollect(v)
+			PlayroomMod.AddCollect(v, "Gm")
 		}
 	case "playroomDress":
 		PlayroomMod := player.PlayMod.getPlayroomMod()
@@ -376,12 +386,27 @@ func ReqGmCommand_(player *Player, Command string) error {
 		GuildMod := player.PlayMod.getGuideMod()
 		GuildMod.Reward = make(map[int]int)
 		player.PushClientRes(GuildMod.BackData())
+	case "resetDecoratePart":
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
+		DecorateMod.PartClassPool = []int{}
+		DecorateMod.PartPool = make(map[int]int)
+		DecorateMod.InitData()
+		player.PushClientRes(DecorateMod.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 "setDecorateProgress":
+		S, _ := strconv.Atoi(arg[1])
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.FinishList = make(map[int]struct{})
+		for i := 1; i <= S; i++ {
+			DecorateMod.FinishList[i] = struct{}{}
+		}
+		DecorateMod.Progress = S
 	case "resetCardSeasonFirst":
 		CardMod := player.PlayMod.getCardMod()
 		CardMod.SeasonFirst = false
@@ -449,7 +474,10 @@ func ReqGmCommand_(player *Player, Command string) error {
 		BaseMod.Uid = Uid
 	case "copyUser":
 		p1 := new(Player)
-		p1.InitPlayer(arg[1])
+		err := p1.InitPlayer(arg[1])
+		if err != nil {
+			return err
+		}
 		BaseMod := p1.PlayMod.getBaseMod()
 		BaseMod.Uid = player.M_DwUin
 		BaseMod.NickName = player.PlayMod.getBaseMod().NickName

src/server/game/LimitedTimeTrigger.go

@@ -267,3 +267,22 @@ func LimitedTimeEnergyAdd(p *Player) {
 	BaseMod.SetRecoverTime(curtime)
 	p.SendErrClienRes(PlayerBaseMod.BackAsset())
 }
+
+func GuideTaskTrigger(p *Player) {
+	GuideTaskMod := p.PlayMod.getGuideTaskMod()
+	UnlockTime := GuideTaskMod.UnlockTime
+	if UnlockTime == 0 {
+		return
+	}
+	Now := GoUtil.Now()
+	NextSecond := 86400 - (Now-UnlockTime)%86400
+	if NextSecond > 0 {
+		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
+			p.lock.Lock()
+			defer p.lock.Unlock()
+			GuideTaskMod.Login()
+			p.PushClientRes(GuideTaskMod.BackData())
+			p.SendClientRes()
+		}, "PlayroomWork")
+	}
+}

src/server/game/Player.go

@@ -23,7 +23,6 @@ import (
 	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
 	MsgMod "server/game/mod/msg"
-	"server/game/mod/order"
 	"server/game/mod/playroom"
 	"server/game/mod/quest"
 	"server/msg"
@@ -155,8 +154,10 @@ func (p *Player) ProcessTrigger() {
 	DailyTaskMod := p.PlayMod.getDailyTaskMod()
 	MailMod := p.PlayMod.getMailMod()
 	PlayroomMod := p.PlayMod.getPlayroomMod()
+	GuideTaskMod := p.PlayMod.getGuideTaskMod()
 	IsPlayroomBack := false
 	IsMailBack := false
+	IsGuideTask := false
 	for _, tr := range p.Trigger {
 		if DailyTaskMod.Trigger(tr) {
 			IsDailyBack = true
@@ -167,6 +168,9 @@ func (p *Player) ProcessTrigger() {
 		if PlayroomMod.QuestTrigger(tr) {
 			IsPlayroomBack = true
 		}
+		if GuideTaskMod.Trigger(tr) {
+			IsGuideTask = true
+		}
 	}
 
 	if IsDailyBack {
@@ -178,6 +182,9 @@ func (p *Player) ProcessTrigger() {
 	if IsPlayroomBack {
 		p.NotifyPlayroomTask()
 	}
+	if IsGuideTask {
+		p.PushClientRes(GuideTaskMod.BackData())
+	}
 	p.Trigger = make([]*quest.Trigger, 0)
 }
 
@@ -367,26 +374,7 @@ func (p *Player) Login() {
 	FaceMod := p.PlayMod.getFaceMod()
 	AvatarMod := p.PlayMod.getAvatarMod()
 	PlayBaseMod := p.GetPlayerBaseMod()
-	OrderMod := p.PlayMod.getOrderMod()
+	GuideTaskMod := p.PlayMod.getGuideTaskMod()
-	PlayroomUnlockLv := playroomCfg.GetUnLockLv()
-	// TODO ： 优化数据
-	if BaseMod.GetLevel() < PlayroomUnlockLv {
-		for k, v := range OrderMod.GetOrderList() {
-			if v.Type == order.Trigger_type {
-				v.Type = order.Common_type
-				OrderMod.OrderList[k] = v
-			}
-		}
-		ItemMod := p.PlayMod.getItemMod()
-		ItemMod.Data = make(map[int]int)
-	}
-	// TODO : 优化数据
-	GuideMod := p.PlayMod.getGuideMod()
-	if GuideMod.Reward[4] > 0 {
-		if AvatarMod.List[10] == nil {
-			AvatarMod.Unlock(10, 0)
-		}
-	}
 	// playroom触发
 	LimitedTimePlayroomTrigger(p)     // playroom数值变化
 	LimitedTimePlayroomWorkTrigger(p) // playroom打工
@@ -395,6 +383,7 @@ func (p *Player) Login() {
 	LoignBack(p)                      // 登录返回数据
 	SyncMailMsg(p)                    // 同步邮件
 	BaseMod.Login()
+	GuideTaskMod.Login()
 	FaceMod.Login(PlayBaseMod.GetRegisterTime())
 	AvatarMod.Login(PlayBaseMod.GetRegisterTime())
 	HandbookItem := p.PlayMod.getCardMod().Login(G_GameLogicPtr.SeverInfo.OpenTime)
@@ -512,6 +501,9 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 			change_type = "gain"
 		}
 		IType := itemCfg.GetItemType(v.Id)
+		if IType == 0 {
+			return errors.New("item type error, item id :" + strconv.Itoa(v.Id))
+		}
 		switch IType {
 		case item.ITEM_TYPE_ENERGY: // 能量
 			err := p.GetPlayerBaseMod().AddEnergy(p, v.Num)
@@ -545,6 +537,9 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 			if err != nil {
 				return err
 			}
+			if v.Num < 0 {
+				p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_DIAMOND, A: []interface{}{-v.Num}})
+			}
 			p.TeLog("asset_change", map[string]interface{}{
 				"item_id":       v.Id,
 				"change_type":   change_type,
@@ -605,6 +600,20 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 
 		case item.ITEM_TYPE_CHESS: // 棋子
 			ChessMod := p.PlayMod.getChessMod()
+			if v.Num < 0 {
+				err := ChessMod.LosePart(v.Id, -v.Num)
+				if err != nil {
+					return err
+				}
+				p.TeLog("chess_part_consume", map[string]interface{}{
+					"chess_id":     v.Id,
+					"chess_name":   mergeDataCfg.GetNameById(v.Id),
+					"consume_num":  -v.Num,
+					"remain_num":   ChessMod.PartBag.List[v.Id].Num,
+					"consume_from": Label,
+				})
+				continue
+			}
 			for i := 0; i < v.Num; i++ {
 				ChessMod.AddChessBuff(v.Id)
 			}
@@ -693,7 +702,7 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 		case item.ITEM_TYPE_PLAYROOM_DECORATION: // playroom装饰
 			Effect := itemCfg.GetItemEffect(v.Id)
 			PlayroomMod := p.PlayMod.getPlayroomMod()
-			PlayroomMod.AddCollect(Effect)
+			PlayroomMod.AddCollect(Effect, Label)
 			BackDataType[item.ITEM_TYPE_PLAYROOM_DECORATION] = struct{}{}
 			Type, Name := playroomCfg.GetDecoInfo(Effect)
 			p.TeLog("room_deco_get", map[string]interface{}{
@@ -704,7 +713,7 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 		case item.ITEM_TYPE_PLAYROOM_DRESS: // playroom服饰
 			Effect := itemCfg.GetItemEffect(v.Id)
 			PlayroomMod := p.PlayMod.getPlayroomMod()
-			PlayroomMod.AddDress(Effect)
+			PlayroomMod.AddDress(Effect, Label)
 			BackDataType[item.ITEM_TYPE_PLAYROOM_DRESS] = struct{}{}
 			Type := playroomCfg.GetDressPart(Effect)
 			Name := playroomCfg.GetDressName(Effect)
@@ -720,7 +729,7 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 				if v == 0 {
 					continue
 				}
-				PlayroomMod.AddCollect(v)
+				PlayroomMod.AddCollect(v, Label)
 				Type, Name := playroomCfg.GetDecoInfo(v)
 				p.TeLog("room_deco_get", map[string]interface{}{
 					"room_deco_type":     Type,
@@ -800,7 +809,9 @@ func (p *Player) LoginBackData() {
 	p.PushClientRes(p.PlayMod.mod_list.Item.BackData())
 	p.PushClientRes(p.GetPlayerBaseMod().BackAsset())
 	p.PushClientRes(p.PlayMod.mod_list.Kv.BackData())
+	p.PushClientRes(p.PlayMod.mod_list.GuideTask.BackData())
 	p.PushClientRes(p.PlayMod.mod_list.Friend.BubbleBackData())
+	p.PushClientRes(p.PlayMod.mod_list.Guide.BackData())
 	p.BackDataActivity()
 	BackChampship(p)
 	BackUserInfo(p)

src/server/game/PlayerBaseMod.go

@@ -11,6 +11,7 @@ import (
 	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
 	Msg "server/game/mod/msg"
+	"server/game/mod/order"
 	"server/game/mod/quest"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -467,6 +468,9 @@ func (p *PlayerBaseData) AddStar(player *Player, cnt int) error {
 	if NewStar < 0 {
 		return errors.New("星星不足")
 	}
+	if cnt > 0 {
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STAR, A: []interface{}{cnt}})
+	}
 	BaseMod.Star = NewStar
 	player.UpdateUserInfo()
 	return nil
@@ -516,10 +520,16 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
 		if ChessMod.TriggerChessBagUnlock(int(BaseMod.Level)) {
 			player.PushClientRes(ChessMod.BackData())
 		}
-
+		GuideTaskMod := player.PlayMod.getGuideTaskMod()
+		if GuideTaskMod.Unlock(BaseMod.Level) {
+			player.PushClientRes(GuideTaskMod.BackData())
+		}
 		ChargeMod := player.PlayMod.getChargeMod()
 		ChargeMod.TriggerChargeUnlock(int(BaseMod.Level), ChessMod.GetEmitList())
 		player.PushClientRes(ChargeMod.BackData())
+		OrderMod := player.PlayMod.getOrderMod()
+		OrderMod.TriggerOrder(BaseMod.Level, order.TRIGGER_TYPE_LV, ChessMod.GetOrderEmit(), player.PlayMod.getBaseMod().GetEnergyMul())
+		player.PushClientRes(OrderMod.BackData())
 		// 重载活动
 		player.initAcitivity()
 		player.BackDataActivity()

src/server/game/PlayerChessMod.go

@@ -57,8 +57,9 @@ func (p *PlayerChessData) ResChessColorData(player *Player) {
 func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) error {
 	update := &msg.UpdatePlayerChessData{}
 	proto.Unmarshal(buf, update)
-	err := p.HandleChess(player, update.MChessHandle)
 	LastMap := player.PlayMod.getChessMod().ChessMap
+	AddChessList, AddNewEmit, err := p.HandleChess(player, update.MChessHandle)
+
 	if err != nil {
 		res := &msg.ResUpdatePlayerChessData{
 			Code: msg.RES_CODE_FAIL,
@@ -98,7 +99,14 @@ func (p *PlayerChessData) UpdatePlayerChessData(player *Player, buf []byte) erro
 		})
 		return fmt.Errorf("棋子数据不一致")
 	}
-	player.PlayMod.getChessMod().ChessMap = update.MChessData
+	ChessMod := player.PlayMod.getChessMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	OrderMod := player.PlayMod.getOrderMod()
+	ChessMod.ChessMap = update.MChessData
+	Update := OrderMod.CreateExtraOrder(AddChessList, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
+	if Update {
+		player.PushClientRes(OrderMod.BackData())
+	}
 	return nil
 }
 
@@ -142,7 +150,7 @@ func (p *PlayerChessData) checkChessEqual(player *Player) bool {
 }
 
 // 棋子操作
-func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHandle) error {
+func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHandle) ([]int, []int, error) {
 	sort.Slice(handle_list, func(i, j int) bool {
 		return handle_list[i].Id < handle_list[j].Id
 	})
@@ -156,6 +164,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 	itemList := make([]*item.Item, 0)
 	AddChessList := make([]int, 0)
 	AddNewEmit := make([]int, 0)
+	EmitList := ChessMod.GetEmitList()
 	for _, v := range handle_list {
 		ChessId := int(v.ChessId)
 		EmitId := int(v.Emit)
@@ -163,7 +172,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 		case msg.HANDLE_TYPE_ADD: //增加棋子
 			err := ChessMod.AddChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
 			Type := mergeDataCfg.GetTypeById(ChessId)
 			AddChessList = append(AddChessList, ChessId)
@@ -183,7 +192,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 		case msg.HANDLE_TYPE_COMPOSE: //合成棋子
 			NewChessId, err := ChessMod.ComposeChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
 			HandbookMod := player.PlayMod.getHandbookMod() // 添加图鉴
 			b := HandbookMod.SetHandbook(NewChessId)
@@ -202,8 +211,9 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 		case msg.HANDLE_TYPE_BUY: //购买棋子
 			loseGold, err := ChessMod.BuyChess(ChessId)
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
+			AddChessList = append(AddChessList, ChessId)
 			buyChess += loseGold
 			itemList = append(itemList, &item.Item{Id: item.ITEM_STAR_ID, Num: int(-loseGold)})
 		case msg.HANDLE_TYPE_SELL: //出售棋子
@@ -221,7 +231,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 				LimitPush = true
 			}
 			if err != nil {
-				return err
+				return nil, nil, err
 			}
 			player.TeLog("sell_item", map[string]interface{}{
 				"merge_item_id": ChessId,
@@ -233,7 +243,6 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 		}
 
 	}
-
 	//扣除体力
 	EnergyPow := BaseMod.GetEnergyMul()
 	ReduceEneny := 0
@@ -243,13 +252,25 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 	}
 	err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandleChess.String())
 	if err != nil {
-		return err
+		return nil, nil, err
+	}
+	NewEmitList := ChessMod.GetEmitList()
+	EmitProductList := make([]string, 0)
+	for _, v := range EmitList {
+		ColorList := mergeDataCfg.GetEmitProduceType(v)
+		EmitProductList = append(EmitProductList, ColorList...)
+	}
+	NewEmitProductList := make([]string, 0)
+	for _, v := range NewEmitList {
+		ColorList := mergeDataCfg.GetEmitProduceType(v)
+		NewEmitProductList = append(NewEmitProductList, ColorList...)
 	}
 	OrderMod := player.PlayMod.getOrderMod()
-	Update := OrderMod.CreateExtraOrder(AddChessList, AddNewEmit, ChessMod.GetUnlockChessList(), EnergyPow)
+	if !GoUtil.SlicesEqualString(EmitProductList, NewEmitProductList) {
-	if Update {
+		// 发射器系列变化，重新洗牌
-		player.PushClientRes(OrderMod.BackData())
+		OrderMod.ResetChessPool()
 	}
+
 	// 限时事件 小猫戏法
 	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
 	if LimitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_TRICK) {
@@ -263,7 +284,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 	EmitRetireTrigger1(player)
 	player.PushClientRes(ChessMod.BackData())
 	player.PlayMod.save()
-	return nil
+	return AddChessList, AddNewEmit, nil
 }
 
 func (p *PlayerChessData) ClearData() bool {

src/server/game/PlayerFunc.go

@@ -14,6 +14,7 @@ import (
 	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mailCfg "server/conf/mail"
 	mergeDataCfg "server/conf/mergeData"
+	orderCfg "server/conf/order"
 	playroomCfg "server/conf/playroom"
 	userCfg "server/conf/user"
 	"server/db"
@@ -774,7 +775,7 @@ func GetVisitorPlayer(p *Player) int {
 			continue
 		}
 		PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
-		if PlayerSimpleData.Level < 6 {
+		if PlayerSimpleData.Level < 15 {
 			continue
 		}
 		PlayerList4 = append(PlayerList4, v.Uid)
@@ -854,6 +855,7 @@ func EmitRetireTrigger1(p *Player) {
 func EmitRetireTrigger2(p *Player) {
 	ChessMod := p.PlayMod.getChessMod()
 	OrderMod := p.PlayMod.getOrderMod()
+	BaseMod := p.PlayMod.getBaseMod()
 	OrderList := OrderMod.GetOrderList()
 	AllChess := make(map[string]struct{}, 0)
 	for _, v := range OrderList {
@@ -870,6 +872,11 @@ func EmitRetireTrigger2(p *Player) {
 		if v != 1 {
 			continue
 		}
+		RetireLv := mergeDataCfg.GetEmitRetire(k)
+		if RetireLv > BaseMod.GetLevel() {
+			continue
+		}
+
 		NeedFinishOrder := false
 		Produce := mergeDataCfg.GetEmitProduce(k)
 		for _, v1 := range Produce {
@@ -982,6 +989,8 @@ func (player *Player) FormatOrderReward() {
 	Exp, PExp := userCfg.GetLevUpExp(player.GetPlayerBaseMod().GetLevel())
 	BaseMod := player.PlayMod.getBaseMod()
 	DecorateMod := player.PlayMod.getDecorateMod()
+	ChessMod := player.PlayMod.getChessMod()
+	OrderFactor := orderCfg.GetOrderFactor(DecorateMod.GetAreaId())
 	ExpCoin := (Exp-BaseMod.GetExp())*decorateCfg.GetAreaPerPExp(DecorateMod.GetAreaId()) - BaseMod.GetStar()
 	PExpCoin := (PExp-BaseMod.GetPExp())*50 - player.GetPetOrderItemExp()
 	OrderMod := player.PlayMod.getOrderMod()
@@ -994,6 +1003,7 @@ func (player *Player) FormatOrderReward() {
 				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,
@@ -1011,6 +1021,7 @@ func (player *Player) FormatOrderReward() {
 		}
 		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
@@ -1020,6 +1031,35 @@ func (player *Player) FormatOrderReward() {
 		v.Items = Items
 		OrderMod.OrderList[k] = v
 	}
+	// 触发式订单 满足条件生成零件订单
+	PartCost := DecorateMod.GetPartCost()
+	PartBag := ChessMod.GetPartBag()
+	Trigger := true
+	for _, v := range OrderMod.GetOrderList() {
+		if v.Type == order.Trigger_type {
+			Trigger = false
+		}
+	}
+	Trigger2 := false
+	for k, v := range PartCost {
+		if v > PartBag[k] {
+			Trigger2 = true
+		}
+	}
+	if Trigger && Trigger2 {
+		for k, v := range OrderMod.GetOrderList() {
+			if v.Type != order.Common_type {
+				continue
+			}
+			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
+		}
+	}
 }
 
 func (player *Player) GetPetOrderReward(Star int, Items []*item.Item) []*item.Item {

src/server/game/PlayerMod.go

@@ -25,6 +25,7 @@ import (
 	"server/game/mod/friendTreasure.go"
 	guesscolor "server/game/mod/guessColor"
 	"server/game/mod/guide"
+	"server/game/mod/guideTask"
 	"server/game/mod/handbook"
 	"server/game/mod/invite"
 	"server/game/mod/item"
@@ -82,6 +83,7 @@ type PlayerModList struct {
 	Activity         activity.Activity                    // 活动
 	Compensation     compensation.Compensation            // 补偿
 	Catnip           catnip.CatnipMod                     // 猫草大作战
+	GuideTask        guideTask.GuideTaskMod               // 引导任务
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -180,6 +182,8 @@ func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	p.ModList.Collect.InitData()
 	p.ModList.Activity.InitData()
 	p.ModList.Catnip.InitData()
+	p.ModList.Compensation.InitData()
+	p.ModList.GuideTask.InitData()
 	return is_update, nil
 }
 
@@ -378,3 +382,6 @@ func (p *PlayerMod) getCompensationMod() *compensation.Compensation {
 func (p *PlayerMod) getCatnipMod() *catnip.CatnipMod {
 	return &p.mod_list.Catnip
 }
+func (p *PlayerMod) getGuideTaskMod() *guideTask.GuideTaskMod {
+	return &p.mod_list.GuideTask
+}

src/server/game/RegisterNetworkFunc.go

@@ -230,26 +230,10 @@ func ReqRewardOrder(player *Player, buf []byte) error {
 	proto.Unmarshal(buf, req)
 	OrderMod := player.PlayMod.getOrderMod()
 	ChessMod := player.PlayMod.getChessMod()
-	PlayroomMod := player.PlayMod.getPlayroomMod()
 	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
 	Item, mergeList, OrderType, Star, err := OrderMod.RewardOrder(int(req.OrderId))
 	ActItem := GetActivityItem(player, GoUtil.Int32ToInt(req.ActType))
 	Item = item.Merge(Item, ActItem)
-	if OrderType == order.Trigger_type { // playroom触发式订单获取额外道具
-		Item1 := PlayroomMod.GetReward()
-		Item = item.Merge(Item, Item1)
-		IdList := playroomCfg.GetPremiumItem()
-		if GoUtil.InArray(Item[0].Id, IdList) {
-			Star = int(math.Ceil(float64(Star) * 0.8))
-		} else {
-			Star = int(math.Ceil(float64(Star) * 0.6))
-		}
-		Target := GetVisitorPlayer(player)
-		PlayroomMod.Target = Target
-		PlayroomMod.Status = playroom.STATUS_VISIT
-		PlayroomBackData(player)
-	}
-
 	if !OrderMod.CheckSuperOrder() {
 		if LimitedTimeEventMod.RemoveSuperOrder() {
 			player.PushClientRes(&msg.LimitEventNotify{
@@ -353,19 +337,20 @@ func ReqRewardOrder(player *Player, buf []byte) error {
 	EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
 	Emit := ChessMod.GetOrderEmit()
 	TriggerSeedSource(player)
-	NewOrder := TriggerSeedOrder(player)
+	//NewOrder := TriggerSeedOrder(player)
-	if NewOrder == nil || len(NewOrder.MergeId) == 0 {
+	// if NewOrder == nil || len(NewOrder.MergeId) == 0 {
-		OrderMod.CreateOrder(Lv, Emit, EnergyMul)
+	// 	OrderMod.CreateOrder(Lv, Emit, EnergyMul)
-	} else {
+	// } else {
-		OrderMod.CreateOrderSeed(NewOrder)
+	// 	OrderMod.CreateOrderSeed(NewOrder)
-	}
+	// }
+	OrderMod.TriggerOrder(Lv, order.TRIGGER_TYPE_ORDER, Emit, EnergyMul)
 	player.FormatOrderReward()
 	// 存钱罐增加钻石
 	PiggyBankMod := player.PlayMod.getPiggyBankMod()
 	PiggyBankMod.Trigger()
 
 	// 锦标赛增加积分
-	if player.GetPlayerBaseMod().GetLevel() >= 6 {
+	if player.GetPlayerBaseMod().GetLevel() >= 17 {
 		ChampshipMod := player.PlayMod.getChampshipMod()
 		ChampshipMod.AddScore(mergeList)
 		player.HandleInChampshipRank()
@@ -419,7 +404,7 @@ func ReqDecorate(player *Player, buf []byte) error {
 	DecorateId := int(req.DecorateId)
 	AreaId := int(req.AreaId)
 	CostItem, PetExp := DecorateMod.GetDecorateCostItem(AreaId, DecorateId)
-	err := player.HandleItem(CostItem, msg.ITEM_POP_LABEL_DecorateCost.String()) // 扣除道具
+	err := player.HandleLoseItem(CostItem, msg.ITEM_POP_LABEL_DecorateCost.String()) // 扣除道具
 	if err != nil {
 		player.SendErrClienRes(&msg.ResDecorate{
 			Code: msg.RES_CODE_FAIL,
@@ -435,7 +420,7 @@ func ReqDecorate(player *Player, buf []byte) error {
 		})
 		return err
 	}
-
+	player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_DECORATE, A: []interface{}{1}})
 	EnergyItem := DecorateMod.GetDecorateAddEnergy(1)
 	AddItem = item.Merge(AddItem, EnergyItem)
 	err = player.HandleItem(AddItem, msg.ITEM_POP_LABEL_DecorateAdd.String()) // 增加道具
@@ -496,7 +481,7 @@ func ReqDecorateAll(player *Player, buf []byte) error {
 	}
 	PlayerBaseMod := player.GetPlayerBaseMod()
 	CostItem, AddItem, DecorateNum, DecorateList, Log, PetExp := DecorateMod.DecorateAll(PlayerBaseMod.GetStar())
-	err := player.HandleItem(CostItem, msg.ITEM_POP_LABEL_DecorateCost.String()) // 扣除道具
+	err := player.HandleLoseItem(CostItem, msg.ITEM_POP_LABEL_DecorateCost.String()) // 扣除道具
 	if err != nil {
 		player.SendErrClienRes(&msg.ResDecorateAll{
 			Code: msg.RES_CODE_FAIL,
@@ -504,6 +489,7 @@ func ReqDecorateAll(player *Player, buf []byte) error {
 		})
 		return err
 	}
+	player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_DECORATE, A: []interface{}{DecorateNum}})
 	EnergyItem := DecorateMod.GetDecorateAddEnergy(DecorateNum)
 	AddItem = item.Merge(AddItem, EnergyItem)
 	err = player.HandleItem(AddItem, msg.ITEM_POP_LABEL_DecorateAdd.String()) // 增加道具
@@ -514,7 +500,6 @@ func ReqDecorateAll(player *Player, buf []byte) error {
 		})
 		return err
 	}
-
 	_, err = player.GetPlayerBaseMod().AddExp(player, 10*DecorateNum, PetExp)
 	if err != nil {
 		player.SendErrClienRes(&msg.ResDecorateAll{
@@ -625,7 +610,7 @@ func ReqGetChessFromBuff(player *Player, buf []byte) error {
 	player.TeLog("ReqGetChessFromBuff", map[string]interface{}{
 		"chess_id": ChessId,
 	})
-	Update = OrderMod.CreateExtraOrder([]int{ChessId}, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul())
+	Update = OrderMod.CreateExtraOrder([]int{ChessId}, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
 	if Update {
 		player.PushClientRes(OrderMod.BackData())
 	}
@@ -640,6 +625,40 @@ func ReqGetChessFromBuff(player *Player, buf []byte) error {
 	return nil
 }
 
+// 放置棋子进背包
+func ReqPutPartInBag(player *Player, buf []byte) error {
+	req := &msg.ReqPutPartInBag{}
+	proto.Unmarshal(buf, req)
+	ChessMod := player.PlayMod.getChessMod()
+	err := ChessMod.PutPartInBag(int(req.ChessId))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPutPartInBag{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	data := &PlayerChessData{}
+	err = data.UpdateChessData(player, req.MChessData)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPutPartInBag{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("ReqPutPartInBag", map[string]interface{}{
+		"chess_id": req.ChessId,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(ChessMod.BackData())
+	player.PushClientRes(&msg.ResPutPartInBag{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	player.UpdateUserInfo()
+	return nil
+}
+
 // 放置棋子进背包
 func ReqPutChessInBag(player *Player, buf []byte) error {
 	req := &msg.ReqPutChessInBag{}
@@ -697,6 +716,12 @@ func ReqTakeChessOutBag(player *Player, buf []byte) error {
 		})
 		return err
 	}
+	OrderMod := player.PlayMod.getOrderMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	Update := OrderMod.CreateExtraOrder([]int{ChessId}, nil, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
+	if Update {
+		player.PushClientRes(OrderMod.BackData())
+	}
 	player.TeLog("ReqTakeChessOutBag", map[string]interface{}{
 		"bag_id":   req.BagId,
 		"chess_id": ChessId,
@@ -841,6 +866,7 @@ func ReqChessEx(player *Player, buf []byte) error {
 			})
 			return err
 		}
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_BUBBLE, A: []interface{}{}})
 	}
 
 	err := ChessMod.ExChess(int(req.OldChessId), int(req.NewChessId))
@@ -1223,6 +1249,74 @@ func ReqDailyUnlock(player *Player, buf []byte) error {
 	return nil
 }
 
+func ReqGetGuideTaskReward(player *Player, buf []byte) error {
+	req := &msg.ReqGetGuideTaskReward{}
+	proto.Unmarshal(buf, req)
+	GuideTaskMod := player.PlayMod.getGuideTaskMod()
+	itemList, err := GuideTaskMod.GetTaskReward(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResGetGuideTaskReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.args["ResItemPopId"] = int(req.Id)
+	err = player.HandleItem(itemList, msg.ITEM_POP_LABEL_GuideTaskReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResGetGuideTaskReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("ReqGetGuideTaskReward", map[string]interface{}{
+		"task_id":   int(req.Id),
+		"item_list": itemList,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(GuideTaskMod.BackData())
+	player.PushClientRes(&msg.ResGetGuideTaskReward{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   req.Id,
+	})
+	return nil
+}
+
+func ReqGetGuideActiveReward(player *Player, buf []byte) error {
+	req := &msg.ReqGetGuideActiveReward{}
+	proto.Unmarshal(buf, req)
+	GuideTaskMod := player.PlayMod.getGuideTaskMod()
+	itemList, err := GuideTaskMod.GetActiveReward(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResGetGuideActiveReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.args["ResItemPopId"] = int(req.Id)
+	err = player.HandleItem(itemList, msg.ITEM_POP_LABEL_GuideActiveReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResGetGuideActiveReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("ReqGetGuideActiveReward", map[string]interface{}{
+		"active_id": int(req.Id),
+		"item_list": itemList,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(GuideTaskMod.BackData())
+	player.PushClientRes(&msg.ResGetGuideActiveReward{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   req.Id,
+	})
+	return nil
+}
+
 // 头像框
 func ReqSetAvatar(player *Player, buf []byte) error {
 	req := &msg.ReqSetAvatar{}
@@ -3318,6 +3412,8 @@ func ReqPlayroomInteract(player *Player, buf []byte) error {
 			Msg:  err.Error(),
 		})
 	}
+	BaseMod := player.PlayMod.getBaseMod()
+	PlayroomMod.AddInteractNum(BaseMod.GetLevel())
 	player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_INTERACT, A: []interface{}{int(req.Id)}})
 	player.PlayMod.save()
 	G_GameLogicPtr.SetUserData(int(player.M_DwUin), VAR_OP_KISS, 0)
@@ -4232,12 +4328,10 @@ func ReqCollect(player *Player, buf []byte) error {
 func ReqSellChessNum(player *Player, buf []byte) error {
 	req := &msg.ReqSellChessNum{}
 	proto.Unmarshal(buf, req)
-	BaseMod := player.PlayMod.getBaseMod()
-	ChessMod := player.PlayMod.getChessMod()
 	data, _ := mergeDataCfg.GetOne(int(req.ChessId))
 	Num := data.SellNum
 	limitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
-	if checkChess(int(req.ChessId), BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) || limitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) {
+	if limitedTimeEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_PAYBACK_DAY) {
 		Num = data.Star
 	}
 	player.PushClientRes(&msg.ResSellChessNum{

src/server/game/Trigger.go

@@ -154,7 +154,7 @@ func TriggerComfortOrder(p *Player) {
 	Now := GoUtil.Now()
 	Lv := BaseMod.GetLevel()
 
-	if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 6 {
+	if Now-BaseMod.GetLogoutTime() < 7*86400 || Lv < 17 {
 		return
 	}
 	OrderMod := p.PlayMod.getOrderMod()

src/server/game/UnitTest.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"math"
 	mergeDataCfg "server/conf/mergeData"
+	"server/game/mod/decorate"
 	"server/game/mod/order"
 	"server/game/mod/quest"
-	"server/game/mod/sevenLogin"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"time"
@@ -41,15 +41,16 @@ func UnitChessShop(p *Player) error {
 
 func UnitOrder(p *Player) error {
 	OrderMod := p.PlayMod.getOrderMod()
-	ChessMod := p.PlayMod.getChessMod()
+	// ChessMod := p.PlayMod.getChessMod()
-	BaseMod := p.PlayMod.getBaseMod()
+	// BaseMod := p.PlayMod.getBaseMod()
 	OrderMod.OrderList = make(map[int]order.Order)
 	for i := 0; i < 1000; i++ {
-		err := OrderMod.CreateNormalOrder(BaseMod.GetLevel(), ChessMod.GetEmitList(), BaseMod.EnergyMul)
+		err := OrderMod.CreateNormalOrder(17, []int{87, 109, 145, 170, 189}, 2)
 		if err != nil {
 			return err
 		}
 	}
+	p.FormatOrderReward()
 	return nil
 }
 
@@ -77,16 +78,14 @@ func UnitChess(p *Player) error {
 }
 
 func UnitDecorate(p *Player) error {
-	PlayerBaseMod := p.GetPlayerBaseMod()
-	PlayerBaseMod.Data.Level = 6
-	PlayerBaseMod.Data.Exp = 50
-	PlayerBaseMod.AddExp(p, 100, 0)
 	return nil
 }
 
 func UnitSevenMonthReward(p *Player) error {
-	i := sevenLogin.F()
+	ChargeMod := p.PlayMod.getChargeMod()
-	fmt.Print(i)
+	BaseMod := p.PlayMod.getBaseMod()
+	ChessMod := p.PlayMod.getChessMod()
+	ChargeMod.TriggerChargeUnlock(int(BaseMod.Level), ChessMod.GetEmitList())
 	return nil
 }
 
@@ -207,8 +206,8 @@ func UnitChess1(p *Player) error {
 }
 
 func UnitPlayroom(p *Player) error {
-	PlayroomMod := p.PlayMod.getPlayroomMod()
+	//PlayroomMod := p.PlayMod.getPlayroomMod()
-	PlayroomMod.UnLock(15)
+	//PlayroomMod.UnLock(15)
 	PlayroomBackData(p)
 	return nil
 }
@@ -235,3 +234,42 @@ func UnitPetOrder(p *Player) error {
 	p.FormatOrderReward()
 	return nil
 }
+
+func UnitDecoratePartCost(p *Player) error {
+	p.LoginBackData()
+	DecorateMod := p.PlayMod.getDecorateMod()
+	DecorateMod.AreaId = 3
+	DecorateMod.PartCost = make(map[int]*decorate.PartCostInfo)
+	DecorateMod.PartClassPool = []int{}
+	DecorateMod.PartPool = make(map[int]int)
+	DecorateMod.InitData()
+	Items, _ := DecorateMod.GetDecorateCostItem(1, 33)
+	err := p.HandleLoseItem(Items, "")
+	if err != nil {
+		fmt.Print(err)
+	}
+	return nil
+	ChessMod := p.PlayMod.getChessMod()
+	return ChessMod.PutPartInBag(1515)
+}
+
+func UnitOrderTrigger(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	Lv := int(BaseMod.Level)
+	ChessMod := p.PlayMod.getChessMod()
+	Emit := ChessMod.GetEmitList()
+	EnergyMul := BaseMod.GetEnergyMul()
+	OrderMod.TriggerOrder(Lv, order.TRIGGER_TYPE_ORDER, Emit, EnergyMul)
+
+	return nil
+}
+
+func UnitOrderExtra(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	BaseMod := p.PlayMod.getBaseMod()
+	ChessMod := p.PlayMod.getChessMod()
+	Update := OrderMod.CreateExtraOrder([]int{25}, nil, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
+	fmt.Print(Update)
+	return nil
+}

src/server/game/external.go

@@ -191,6 +191,7 @@ func HandleClientReq(args []interface{}) {
 				EventName: "Login_log",
 			})
 		}
+		p.(*Player).ProcessTrigger()
 	case "ReqServerTime": // 获取服务器时间
 		detail := &msg.ReqServerTime{}
 		proto.Unmarshal(buf, detail)

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

@@ -221,10 +221,10 @@ func (b *Base) SetLang(lang msg.LANG_TYPE) {
 }
 
 func (b *Base) BuyEnergy(Energy int) ([]*item.Item, int, int) {
-	if !b.IsFirstBuy {
+	// if !b.IsFirstBuy {
-		b.IsFirstBuy = true
+	// 	b.IsFirstBuy = true
-		return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 100}}, 100, 0
+	// 	return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 100}}, 100, 0
-	}
+	// }
 	b.EnergyBuy += 1
 	Mul := baseCfg.GetEnergyByMul(b.EnergyBuy)
 	Diamond := int(float64(Energy) / Mul)

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

@@ -2,11 +2,13 @@ package charge
 
 import (
 	"fmt"
+	"math"
 	"server/GoUtil"
 	chargeCfg "server/conf/charge"
 	mergeDataCfg "server/conf/mergeData"
 	playroomCfg "server/conf/playroom"
 	"server/game/mod/item"
+	"server/game/mod/order"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 )
@@ -262,7 +264,14 @@ func (c *ChargeMod) BackData() *msg.ResCharge {
 			ChessId: int32(v.Id),
 		}
 	}
-
+	resWish := &msg.WishList{}
+	if c.WishList != nil {
+		resWish = &msg.WishList{
+			Id:    int32(c.WishList.ItemId),
+			Count: int32(c.WishList.Count),
+			Uid:   c.WishList.SendList,
+		}
+	}
 	return &msg.ResCharge{
 		Charge:            float32(c.Charge),
 		Total:             int32(c.Total),
@@ -276,11 +285,7 @@ func (c *ChargeMod) BackData() *msg.ResCharge {
 		SpecialChargeWeek: int32(GoUtil.FullWeeksSince(c.LastSpecialCharge)),
 		TodayCharge:       float32(c.TodayCharge),
 		MonthCharge:       float32(c.MonthCharge),
-		Wish: &msg.WishList{
+		Wish:              resWish,
-			Id:    int32(c.WishList.ItemId),
-			Count: int32(c.WishList.Count),
-			Uid:   c.WishList.SendList,
-		},
 	}
 }
 
@@ -289,26 +294,44 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 		return
 	}
 	c.ChessShop = make(map[int]*ChessShop)
-	ColorList := make([]string, 0)
+	//ColorList := make([]string, 0)
+	RandList := make([]*Rand, 0)
+
 	for _, v := range Emit {
 		ProduceList := mergeDataCfg.GetEmitProduceType(v)
-		ColorList = append(ColorList, ProduceList...)
+		for _, p := range ProduceList {
-	}
+			ChessList := order.GetChessByDiff(v, 1, order.DIFF_MID, p)
-
+			ColorType := mergeDataCfg.GetColorType(p)
-	RandList := make([]*Rand, 0)
+			for _, c := range ChessList {
-	for _, v := range ColorList {
+				if c == 0 {
-		ColorType := mergeDataCfg.GetColorType(v)
+					continue
-		r := make([]*Rand, 0)
+				}
-		switch ColorType {
+				ChessLv := mergeDataCfg.GetLvById(c)
-		case mergeDataCfg.CHESS_PRODUCT_MAIN_TYPE:
+				Diamond := int(math.Pow(2, float64(ChessLv-1)) / 2.5)
-			r = getChessMainRand(v)
+				if ColorType == mergeDataCfg.CHESS_PRODUCT_SUB_TYPE {
-		case mergeDataCfg.CHESS_PRODUCT_SECONDARY_TYPE:
+					Diamond = int(math.Pow(2, float64(ChessLv-1))/2.5 + 6.4)
-			r = getChessSecondaryRand(v)
+				}
-		case mergeDataCfg.CHESS_PRODUCT_SUB_TYPE:
+				if ColorType == mergeDataCfg.CHESS_PRODUCT_SECONDARY_TYPE {
-			r = getChessSubRand(v)
+					Diamond *= 2
+				}
+				RandList = append(RandList, &Rand{ChessId: c, Diamond: Diamond})
+			}
 		}
-		RandList = append(RandList, r...)
+		//ColorList = append(ColorList, ProduceList...)
 	}
+	// for _, v := range ColorList {
+	// 	ColorType := mergeDataCfg.GetColorType(v)
+	// 	r := make([]*Rand, 0)
+	// 	switch ColorType {
+	// 	case mergeDataCfg.CHESS_PRODUCT_MAIN_TYPE:
+	// 		r = getChessMainRand(v)
+	// 	case mergeDataCfg.CHESS_PRODUCT_SECONDARY_TYPE:
+	// 		r = getChessSecondaryRand(v)
+	// 	case 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
@@ -317,6 +340,9 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 	for k, v := range L {
 		Diamond := v.(*Rand).Diamond
 		ChessId := v.(*Rand).ChessId
+		if ChessId == 0 {
+			continue
+		}
 		c.ChessShop[k+1] = &ChessShop{Diamond: Diamond, Count: 5, Id: ChessId}
 	}
 }
@@ -339,10 +365,10 @@ func (c *ChargeMod) BuyChess(Chess int) ([]*item.Item, []*item.Item, int, error)
 }
 
 func (c *ChargeMod) TriggerChargeUnlock(Lv int, Emit []int) {
-	UnlockLv := chargeCfg.GetUnlockShopLv()
+	//UnlockLv := chargeCfg.GetUnlockShopLv()
-	if Lv != UnlockLv {
+	// if Lv != UnlockLv {
-		return
+	// 	return
-	}
+	// }
 	c.InitChessShop(Emit)
 }
 

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

@@ -27,6 +27,9 @@ func getChessMainRand(Color string) []*Rand {
 	for i := 6; i <= 10; i++ {
 		Diamond := int(math.Pow(2, float64(i-1)) / 2.5)
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		if ChessId == 0 {
+			continue
+		}
 		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
 	}
 	return r
@@ -37,6 +40,9 @@ func getChessSecondaryRand(Color string) []*Rand {
 	for i := 5; i <= 9; i++ {
 		Diamond := int((math.Pow(2, float64(i-1)) / 2.5) * 2)
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		if ChessId == 0 {
+			continue
+		}
 		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
 	}
 	return r
@@ -47,6 +53,9 @@ func getChessSubRand(Color string) []*Rand {
 	for i := 5; i <= 9; i++ {
 		Diamond := int(math.Pow(2, float64(i-1))/2.5 + 6.4)
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(i, Color)
+		if ChessId == 0 {
+			continue
+		}
 		r = append(r, &Rand{ChessId: ChessId, Diamond: Diamond})
 	}
 	return r

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

@@ -40,12 +40,16 @@ type ChessBorad struct {
 	EmitList       map[int]int
 	ChessBuff      []int
 	ChessBag       ChessBag
+	PartBag        PartBag
 	ChessMap       map[string]int32
 	Honor          map[int]int    // 荣誉室
 	Retire         map[string]int // 退役发射器系列
 	RetireChessMap map[string][]int
 }
 
+type PartBag struct {
+	List map[int]PartBagGrid // 零件背包
+}
 type ChessBag struct {
 	List map[int]ChessBagGrid
 	Buy  int
@@ -57,6 +61,11 @@ type ChessBagGrid struct {
 	EmitId  int // 发射器id
 }
 
+type PartBagGrid struct {
+	PartId int // 零件id
+	Num    int // 零件数量
+}
+
 func (cb *ChessBorad) IsEmpty() bool {
 	cb.ver()
 	return len(cb.ChessList) == 0
@@ -87,6 +96,9 @@ func (cb *ChessBorad) ver() {
 			cb.ChessBag.List[i] = ChessBagGrid{}
 		}
 	}
+	if cb.PartBag.List == nil {
+		cb.PartBag.List = make(map[int]PartBagGrid)
+	}
 	if cb.ChessMap == nil {
 		cb.ChessMap = make(map[string]int32)
 	}
@@ -335,12 +347,26 @@ func (cb *ChessBorad) GetChessFromBuff(Chess int) error {
 		if v == Chess {
 			cb.ChessBuff = append(cb.ChessBuff[:i], cb.ChessBuff[i+1:]...)
 			cb.AddChess(Chess)
+			ChessType := mergeDataCfg.GetTypeById(Chess)
+			if ChessType == "Emitter" {
+				cb.EmitList[Chess]++
+			}
 			return nil
 		}
 	}
 	return errors.New("chess id not exist")
 }
 
+func (cb *ChessBorad) LosePart(PartId int, Num int) error {
+	v, ok := cb.PartBag.List[PartId]
+	if !ok || v.Num < Num {
+		return errors.New("part id not exist or num not enough" + fmt.Sprintf("PartId: %d, Num: %d, ok: %v", PartId, Num, ok))
+	}
+	v.Num -= Num
+	cb.PartBag.List[PartId] = v
+	return nil
+}
+
 // 返回数据
 func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
 	var ChessBagGrids []*msg.ChessBagGrid
@@ -351,6 +377,13 @@ func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
 			EmitId:  int32(v.EmitId),
 		})
 	}
+	var PartBagGrids []*msg.PartBagGrid
+	for k, v := range cb.PartBag.List {
+		PartBagGrids = append(PartBagGrids, &msg.PartBagGrid{
+			PartId: int32(k),
+			Count:  int32(v.Num),
+		})
+	}
 	Re := make([]string, 0)
 	for k, v := range cb.Retire {
 		if v == 3 {
@@ -371,6 +404,9 @@ func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
 			ChessBuyCnt:   int32(cb.ChessBag.Buy),
 			ChessFreeCnt:  int32(cb.ChessBag.Free),
 		},
+		PartBag: &msg.PartBag{
+			PartBagGrids: PartBagGrids,
+		},
 	}
 }
 
@@ -435,6 +471,31 @@ func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error {
 	return nil
 }
 
+func (cb *ChessBorad) PutPartInBag(ChessId int) error {
+	err := cb.RemoveChess(ChessId)
+	if err != nil {
+		return err
+	}
+	ChessLv := mergeDataCfg.GetLvById(ChessId)
+	ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId)
+	if ChessLv != ChessMaxLv { // 零件只能放入满级棋子
+		return errors.New("part Lv is not max")
+	}
+	Num := 0
+	v, ok := cb.PartBag.List[ChessId]
+	if ok {
+		Num = v.Num
+	}
+	if cb.PartBag.List == nil {
+		cb.PartBag.List = make(map[int]PartBagGrid)
+	}
+	cb.PartBag.List[ChessId] = PartBagGrid{
+		PartId: ChessId,
+		Num:    Num + 1,
+	}
+	return nil
+}
+
 func (cb *ChessBorad) TakeChessOutBag(Grid int) (int, error) {
 	if Grid < 0 {
 		cb.RemoveHonor(-Grid)
@@ -575,3 +636,11 @@ func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) {
 	cb.AddChess(NewChess)
 	return NewChess, nil
 }
+
+func (cb *ChessBorad) GetPartBag() map[int]int {
+	res := make(map[int]int)
+	for k, v := range cb.PartBag.List {
+		res[k] = v.Num
+	}
+	return res
+}

src/server/game/mod/decorate/Decorate.go

@@ -10,11 +10,19 @@ import (
 )
 
 type Decorate struct {
-	AreaId      int
+	AreaId        int
-	FinishList  map[int]struct{}
+	FinishList    map[int]struct{}
-	Progress    int
+	Progress      int
-	DecorateNum int
+	DecorateNum   int
-	AreaReward  []int
+	AreaReward    []int
+	PartPool      map[int]int
+	PartClassPool []int
+	PartCost      map[int]*PartCostInfo
+	LastPart      []int
+}
+
+type PartCostInfo struct {
+	Items []*item.Item
 }
 
 func (d *Decorate) InitData() {
@@ -22,6 +30,15 @@ func (d *Decorate) InitData() {
 		d.AreaId = 1
 		d.FinishList = make(map[int]struct{})
 	}
+	if d.PartCost == nil {
+		d.PartCost = make(map[int]*PartCostInfo)
+	}
+	if d.PartPool == nil {
+		d.PartPool = make(map[int]int)
+	}
+	if len(d.PartCost) == 0 {
+		d.initPartCost(d.AreaId)
+	}
 }
 
 // 装饰
@@ -39,11 +56,14 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
 	d.FinishList[decorateId] = struct{}{}
 	d.Progress += 1
 	Item := decorateCfg.GetProgressReward(areaId, d.Progress)
+	Item1 := decorateCfg.GetDecoarteReward(areaId, decorateId)
+	Item = append(Item, Item1...)
 	if d.Progress >= len(SortList) {
 		d.AreaId++
 		d.Progress = 0
 		d.FinishList = make(map[int]struct{})
 	}
+
 	d.DecorateNum++
 	return Item, nil
 }
@@ -58,7 +78,17 @@ func (d *Decorate) GetDecorateAddEnergy(cnt int) []*item.Item {
 func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int) ([]*item.Item, int) {
 	Item := decorateCfg.GetStarCost(AreaId, DecorateId)
 	PetExp := decorateCfg.GetDecoratePExp(AreaId, DecorateId)
-	return []*item.Item{item.NewItem(item.ITEM_STAR_ID, -Item)}, PetExp
+	Id := decorateCfg.GetIdBySenceAndLv(AreaId, DecorateId)
+	Items := []*item.Item{item.NewItem(item.ITEM_STAR_ID, Item)}
+	PartItem := d.PartCost[Id]
+	if PartItem != nil {
+		Items = append(Items, PartItem.Items...)
+		delete(d.PartCost, Id)
+	}
+	if len(d.PartCost) == 0 {
+		d.initPartCost(d.AreaId + 1)
+	}
+	return Items, PetExp
 }
 
 func (d *Decorate) DecorateAll(Star int) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
@@ -66,6 +96,7 @@ func (d *Decorate) DecorateAll(Star int) ([]*item.Item, []*item.Item, int, []int
 	SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
 	sort.Ints(SubAlice)
 	SubItem := 0
+	SubItems := make([]*item.Item, 0)
 	AddItem := make([]*item.Item, 0)
 	DecorateList := make([]int, 0)
 	Log := make([]interface{}, 0)
@@ -79,10 +110,17 @@ func (d *Decorate) DecorateAll(Star int) ([]*item.Item, []*item.Item, int, []int
 		Star -= NeedStar
 		SubItem += NeedStar
 		d.FinishList[v] = struct{}{}
+		Id := decorateCfg.GetIdBySenceAndLv(d.AreaId, d.Progress)
+		PartItem := d.PartCost[Id]
+		if PartItem != nil {
+			SubItems = append(SubItems, PartItem.Items...)
+			delete(d.PartCost, Id)
+		}
 		d.Progress++
 		d.DecorateNum++
 		Num++
 		Item := decorateCfg.GetProgressReward(d.AreaId, d.Progress)
+		Item = append(Item, decorateCfg.GetDecoarteReward(d.AreaId, v)...)
 		if len(Item) > 0 {
 			if d.Progress >= len(DecorateAll) {
 				Log = append(Log, map[string]interface{}{
@@ -107,16 +145,27 @@ func (d *Decorate) DecorateAll(Star int) ([]*item.Item, []*item.Item, int, []int
 		d.Progress = 0
 		d.FinishList = make(map[int]struct{})
 	}
-
+	if len(d.PartCost) == 0 {
-	return []*item.Item{item.NewItem(item.ITEM_STAR_ID, -SubItem)}, AddItem, Num, DecorateList, Log, PetExp
+		d.initPartCost(d.AreaId)
+	}
+	SubItems = append(SubItems, item.NewItem(item.ITEM_STAR_ID, SubItem))
+	return SubItems, AddItem, Num, DecorateList, Log, PetExp
 }
 
 // 获取装饰信息
 func (d *Decorate) BackData() *msg.ResDecorateInfo {
+	PartRes := []*msg.DecoratePart{}
+	for k, v := range d.PartCost {
+		PartRes = append(PartRes, &msg.DecoratePart{
+			Id:    int32(k),
+			Items: item.ItemToMsg(v.Items),
+		})
+	}
 	return &msg.ResDecorateInfo{
 		AreaId:      int32(d.AreaId),
 		MFinishList: GoUtil.MapIntToSlice(d.FinishList),
 		RewardArea:  GoUtil.IntToInt32(d.AreaReward),
+		Parts:       PartRes,
 	}
 }
 
@@ -125,7 +174,7 @@ func (d *Decorate) GetDecorateReward(areaId int) ([]*item.Item, error) {
 		return nil, fmt.Errorf("areaId already rewarded")
 	}
 	d.AreaReward = append(d.AreaReward, areaId)
-	return decorateCfg.GetDecoarteReward(areaId), nil
+	return decorateCfg.GetDecoarteReward(areaId, 20), nil
 }
 
 func (d *Decorate) GetAreaId() int {
@@ -139,3 +188,123 @@ func (d *Decorate) GetProgress() int {
 func (d *Decorate) GetDecorateNum() int {
 	return d.DecorateNum
 }
+
+func (d *Decorate) GetPart(Num int) map[int]int {
+	d.initPartPool()
+	res := make(map[int]int, 0)
+	ClassNum := min(Num, 3)
+	ClassList := d.GetPartClass(ClassNum)
+	NewClassList := d.sortClass(ClassList)
+	for i := range Num {
+		Class := NewClassList[i%ClassNum]
+		d.PartPool[Class]--
+		res[Class]++
+	}
+	return res
+}
+
+func (d *Decorate) sortClass(Class []int) []int {
+	d.initPartPool()
+	type sortClass struct {
+		Id  int
+		Num int
+	}
+	sortList := make([]sortClass, 0)
+	for _, v := range Class {
+		sortList = append(sortList, sortClass{
+			Id:  v,
+			Num: d.PartPool[v],
+		})
+	}
+	sort.Slice(sortList, func(i, j int) bool {
+		return sortList[i].Num > sortList[j].Num
+	})
+	res := make([]int, 0)
+	for _, v := range sortList {
+		res = append(res, v.Id)
+	}
+	return res
+}
+
+func (d *Decorate) GetPartClass(Num int) []int {
+	res := []int{}
+	Id := 0
+	for range Num {
+		if len(d.PartClassPool) == 0 {
+			d.initPartClassPool()
+		}
+		Id, d.PartClassPool = GoUtil.PopSlice(d.PartClassPool)
+		res = append(res, Id)
+	}
+	return res
+}
+
+func (d *Decorate) initPartClassPool() {
+	if len(d.PartClassPool) == 0 {
+		ClassList := decorateCfg.GetAllPartId()
+		r1 := GoUtil.SubSlices(ClassList, d.LastPart)
+		c1 := GoUtil.RandSlice(r1)
+		r2 := GoUtil.SubSlices(ClassList, []int{c1})
+		r3 := GoUtil.ShuffleArray(r2)
+		d.PartClassPool = append([]int{c1}, r3...)
+	}
+}
+
+func (d *Decorate) initPartPool() {
+	IsEmpty := true
+	for _, v := range d.PartPool {
+		if v > 0 {
+			IsEmpty = false
+			break
+		}
+	}
+	if IsEmpty {
+		PartList := decorateCfg.GetAllPartId()
+		for _, v := range PartList {
+			d.PartPool[v] = 7
+		}
+	}
+}
+
+func (d *Decorate) initPartCost(AreaId int) {
+	AllPartList := decorateCfg.GetPartNumByAreaId(AreaId)
+	for k, v := range AllPartList {
+		// 初始零件消耗写死
+		if k == 33 {
+			d.PartCost[k] = &PartCostInfo{
+				Items: []*item.Item{item.NewItem(1515, 1)},
+			}
+			continue
+		}
+		if k == 34 {
+			d.PartCost[k] = &PartCostInfo{
+				Items: []*item.Item{item.NewItem(1505, 1)},
+			}
+			continue
+		}
+		if k == 35 {
+			d.PartCost[k] = &PartCostInfo{
+				Items: []*item.Item{item.NewItem(1505, 1), item.NewItem(1515, 1)},
+			}
+			continue
+		}
+		PartList := d.GetPart(v)
+		Items := make([]*item.Item, 0)
+		for k1, v1 := range PartList {
+			Items = append(Items, item.NewItem(k1, v1))
+		}
+		d.PartCost[k] = &PartCostInfo{
+			Items: Items,
+		}
+	}
+}
+
+func (d *Decorate) GetPartCost() map[int]int {
+	res := make(map[int]int)
+	for _, v := range d.PartCost {
+		for _, v1 := range v.Items {
+			res[v1.Id] += v1.Num
+		}
+	}
+	return res
+}

src/server/game/mod/guideTask/guideTask.go

@@ -0,0 +1,148 @@
+package guideTask
+
+import (
+	"fmt"
+	"server/GoUtil"
+	GuideTaskCfg "server/conf/guideTask"
+	"server/game/mod/item"
+	"server/game/mod/quest"
+	"server/msg"
+)
+
+type GuideTaskMod struct {
+	Tasks      map[int]*GuideTask
+	Active     int
+	Reward     []int            // 任务奖励状态
+	UnlockTime int64            // 解锁时间
+	LoginDay   map[int]struct{} // 登录天数
+}
+
+type GuideTask struct {
+	Items  []*item.Item
+	Status int
+	Quest  quest.QuestProgress
+	UnLock bool
+}
+
+func (gt *GuideTaskMod) InitData() {
+	if gt.Tasks == nil {
+		gt.Tasks = make(map[int]*GuideTask)
+	}
+	if len(gt.Tasks) == 0 {
+		for i := 1; ; i++ {
+			Str := GuideTaskCfg.GetTaskById(i)
+			if Str == "" {
+				break
+			}
+			Quest, _ := quest.ParseQuest(Str)
+			gt.Tasks[i] = &GuideTask{
+				Status: quest.QUEST_STATUS_UNFINISH,
+				Quest:  Quest,
+			}
+		}
+	}
+	if gt.LoginDay == nil {
+		gt.LoginDay = make(map[int]struct{})
+	}
+}
+
+func (gt *GuideTaskMod) Login() {
+	// 登录时触发的引导任务
+	if gt.UnlockTime == 0 {
+		return
+	}
+	LoginDay := (GoUtil.Now()-gt.UnlockTime)/86400 + 1
+	gt.LoginDay[int(LoginDay)] = struct{}{}
+	gt.Trigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_GUIDE_LOGIN, A: []interface{}{len(gt.LoginDay)}})
+}
+
+func (gt *GuideTaskMod) Unlock(lv int) bool {
+	UnLockLv := GuideTaskCfg.GetUnlockLv()
+	if lv >= UnLockLv && gt.UnlockTime == 0 {
+		gt.UnlockTime = GoUtil.Now()
+		gt.Login()
+		return true
+	}
+	return false
+}
+
+func (gt *GuideTaskMod) CheckOpen() bool {
+	// 检查是否可以打开引导任务
+	if gt.UnlockTime == 0 {
+		return false
+	}
+	return GoUtil.Now()-gt.UnlockTime <= 96*3600 // 96小时内可以打开
+}
+
+func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
+	if !gt.CheckOpen() {
+		return false
+	}
+	update := false
+	for k, v := range gt.Tasks {
+		if v.Status != quest.QUEST_STATUS_UNFINISH {
+			continue
+		}
+		if v.Quest.Label == quest.TRIGGER_LABEL_GUIDE_LOGIN {
+			v.Quest.A = []interface{}{gt.UnlockTime}
+		}
+		up := quest.TriggerQuestProgress(&v.Quest, Tr)
+		if up {
+			update = true
+		}
+		if v.Quest.Status {
+			v.Status = quest.QUEST_STATUS_FINISH
+		}
+		gt.Tasks[k] = v
+	}
+	return update
+}
+
+func (gt *GuideTaskMod) GetTaskReward(Id int) ([]*item.Item, error) {
+	if task, ok := gt.Tasks[Id]; ok {
+		if task.Status == quest.QUEST_STATUS_FINISH {
+			task.Status = quest.QUEST_STATUS_REWARD
+			Active := GuideTaskCfg.GetTaskActive(Id)
+			gt.Active += Active
+			return GuideTaskCfg.GetTaskRewardById(Id), nil
+		}
+	}
+	return nil, fmt.Errorf("no task id %d", Id)
+}
+
+func (gt *GuideTaskMod) GetActiveReward(Id int) ([]*item.Item, error) {
+	for _, v := range gt.Reward {
+		if v == Id {
+			return nil, fmt.Errorf("active reward already got")
+		}
+	}
+	items, needActive := GuideTaskCfg.GetActiveReward(Id)
+	if items == nil {
+		return nil, fmt.Errorf("no active reward id %d", Id)
+	}
+	if gt.Active < needActive {
+		return nil, fmt.Errorf("active not enough")
+	}
+	gt.Reward = append(gt.Reward, Id)
+	return items, nil
+}
+
+func (gt *GuideTaskMod) BackData() *msg.ResGuideTask {
+	if !gt.CheckOpen() {
+		return nil
+	}
+	resTask := make(map[int32]*msg.GuideTask)
+	for k, v := range gt.Tasks {
+		resTask[int32(k)] = &msg.GuideTask{
+			Status:   int32(v.Status),
+			Progress: quest.QuestProgressToMsg(&v.Quest),
+		}
+	}
+
+	return &msg.ResGuideTask{
+		Task:         resTask,
+		Active:       int32(gt.Active),
+		UnlockTime:   int32(gt.UnlockTime),
+		ActiveReward: GoUtil.SliceIntToInt32(gt.Reward),
+	}
+}

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

@@ -21,6 +21,7 @@ const (
 	ITEM_DIAMOND_ID          = 100003
 	ITEM_FIVE_STAR_CARD_PACK = 100008
 	ITEM_RACING_BATTERY_ID   = 100027
+	ITEM_LAUNCHER_ID         = 1602
 )
 
 const (

src/server/game/mod/mail/Mail.go

@@ -125,7 +125,7 @@ func (m *MailMod) Del(id int) error {
 		return fmt.Errorf("mail id %d not exist", id)
 	}
 	if v.Status == MAIL_STATUS_DEL {
-		return fmt.Errorf("mail have readed")
+		return fmt.Errorf("mail have deleted")
 	}
 	v.Status = MAIL_STATUS_DEL
 	v.Del = GoUtil.Now()

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

@@ -2,12 +2,14 @@ package order
 
 import (
 	"fmt"
+	"log"
 	"server/GoUtil"
 	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mergeDataCfg "server/conf/mergeData"
 	orderCfg "server/conf/order"
 	"server/game/mod/item"
 	"server/msg"
+	"strings"
 	"time"
 )
 
@@ -23,6 +25,8 @@ type OrderMod struct {
 	EmitShuffle     []string       // 发射器乱序
 	ChessPool       []int          // 棋子池
 	OrderPool       map[int]*Order // 订单池
+	FinishOrder     []int          // 已完成订单
+	IsCharge        bool           // 是否充值
 }
 
 type Order struct {
@@ -47,10 +51,17 @@ const (
 	COMFORT_TYPE     = 9  // 安慰订单
 	Guide_type       = 10 // 引导订单
 	Pet_type         = 11 // 宠物订单
+	Preview_type     = 12 // 预览订单
+	Fixed_type       = 13 // 固定订单
+	Playroom_type    = 14 // playroom装饰物订单
+	Part_type        = 15 // 零件订单
 
 	DIFF_LOW  = 1 // 低难度
 	DIFF_MID  = 2 // 中难度
 	DIFF_HIGH = 3 // 高难度
+
+	TRIGGER_TYPE_ORDER = "Order" // 订单触发器
+	TRIGGER_TYPE_LV    = "Lv"    // 等级触发器
 )
 
 func (o *OrderMod) InitData() {
@@ -63,29 +74,18 @@ func (o *OrderMod) InitData() {
 	if o.OrderPool == nil {
 		o.OrderPool = make(map[int]*Order)
 	}
-	if o.Step == 0 {
+	if len(o.OrderList) == 0 {
 		o.OrderList = make(map[int]Order)
-		Cfg := orderCfg.GetStartOrderByStep(o.Step + 1)
+		o.TriggerOrder(1, TRIGGER_TYPE_ORDER, nil, 1)
-		o.Step = 1
-		o.Auto_id = 0
-		o.LastDiff = DIFF_LOW
-		for _, v := range Cfg {
-			star := GetOrderStar(v.MergeList)
-			Items := make([]*item.Item, 0)
-			Items = append(Items, item.NewItem(item.ITEM_STAR_ID, star))
-			o.Auto_id++
-			o.OrderList[o.Auto_id] = Order{
-				Type:    Common_type,
-				MergeId: v.MergeList,
-				Items:   Items,
-			}
-		}
 	}
 	for k, v := range o.OrderList {
 		if GoUtil.InArray(0, v.MergeId) || len(v.MergeId) == 0 {
 			delete(o.OrderList, k)
 		}
 	}
+	if o.Auto_id == 0 {
+		o.Auto_id = 10000
+	}
 }
 
 func (o *OrderMod) GetOrderList() map[int]Order {
@@ -112,6 +112,9 @@ func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
 		if v.Type == Guide_type {
 			return nil, v.MergeId, v.Type, 0, nil
 		}
+		if v.Type == Fixed_type || v.Type == Playroom_type {
+			o.FinishOrder = append(o.FinishOrder, id)
+		}
 		return ItemList, v.MergeId, v.Type, Star, nil
 	}
 	return ItemList, MergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
@@ -169,60 +172,131 @@ func (o *OrderMod) CreatOrderPool(lv int, Emit []int, EnergyMul int) error {
 	return nil
 }
 
+// 触发生成新的固定订单
+func (o *OrderMod) TriggerOrder(lv int, Type string, Emit []int, EnergyMul int) error {
+	TriggerOrderList := orderCfg.GetStartOrderList()
+	FixedOrder := 0
+	for _, v := range o.OrderList {
+		if v.Type == Fixed_type {
+			FixedOrder++
+		}
+	}
+	OrderList := make(map[int]Order, len(o.OrderList))
+	for k, v := range o.OrderList {
+		OrderList[k] = v
+	}
+	// 触发生成新的固定订单
+	for _, v := range TriggerOrderList {
+		if GoUtil.InArray(v.Id, o.FinishOrder) {
+			continue
+		}
+		orderInfo, exists := OrderList[v.Id]
+		if exists && v.Preview == "" {
+			continue
+		}
+		// 预览条件不为空且未存在且未完成
+		if v.Preview != "" && !exists && !GoUtil.InArray(v.Id, o.FinishOrder) {
+			if o.CheckCondition(lv, v.Preview, Type, Emit, FixedOrder, OrderList) {
+				o.addFixOrder(v.Id, v.MergeList, Preview_type, v.Items)
+			}
+		}
+		if v.Appear != "" {
+			if o.CheckCondition(lv, v.Appear, Type, Emit, FixedOrder, OrderList) {
+				Type := Fixed_type
+				OrderType := orderCfg.GetOrderType(v.Id)
+				if OrderType != 0 {
+					Type = OrderType
+				}
+				if exists {
+					orderInfo.Type = Fixed_type
+					o.OrderList[v.Id] = orderInfo
+				} else {
+					o.addFixOrder(v.Id, v.MergeList, Type, v.Items)
+				}
+			}
+		}
+	}
+	if lv >= 12 {
+		o.CreateOrder(lv, Emit, EnergyMul)
+	}
+	return nil
+}
+
+func (o *OrderMod) CheckCondition(lv int, condition, Type string, Emit []int, FixedOrder int, OrderList map[int]Order) bool {
+	r1 := strings.Split(condition, "|")
+	for _, v := range r1 {
+		r2 := strings.Split(v, "=")
+		switch r2[0] {
+		case "Finish":
+			id := GoUtil.Int(r2[1])
+			if !GoUtil.InArray(id, o.FinishOrder) && id != 0 {
+				return false
+			}
+			if id == 0 && Type != TRIGGER_TYPE_ORDER {
+				return false
+			}
+		case "Lv":
+			id := GoUtil.Int(r2[1])
+			if lv < id {
+				return false
+			}
+		case "OrderNum":
+			id := GoUtil.Int(r2[1])
+			if FixedOrder != id {
+				return false
+			}
+		case "Order":
+			id := GoUtil.Int(r2[1])
+			_, ok := OrderList[id]
+			if !GoUtil.InArray(id, o.FinishOrder) && !ok {
+				return false
+			}
+		case "Emit":
+			Class := []string{}
+			for _, v := range Emit {
+				Class = append(Class, mergeDataCfg.GetEmitId(v))
+			}
+			if !GoUtil.InStringArray(r2[1], Class) {
+				return false
+			}
+		case "EmitMax":
+			Class := []string{}
+			for _, v := range Emit {
+				EmitLv := mergeDataCfg.GetLvById(v)
+				MaxLv := mergeDataCfg.GetMaxLvById(v)
+				if EmitLv < MaxLv {
+					continue
+				}
+				Class = append(Class, mergeDataCfg.GetEmitId(v))
+			}
+			if !GoUtil.InStringArray(r2[1], Class) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 // 生成新订单
 func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
-	switch o.LastOrder.Type {
+	/// 生成优先订单
-	case Preheat_type:
+	if o.CreatePriorityOrder(lv, Emit) {
-		ChessId := o.LastOrder.MergeId[0]
+		return nil
-		ChessColor := mergeDataCfg.GetColorById(ChessId)
+	}
-		PreheatStep := o.PreheatStep[ChessColor]
+	MaxOrderNum := orderCfg.GetOrderNum(lv)
-		if PreheatStep < 4 {
+	n := 0
-			NewChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+PreheatStep+1, ChessColor)
+	for _, v := range o.OrderList {
-			if NewChessId == 0 {
+		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 {
-				return fmt.Errorf("CreateOrder: NewChessId is 0, EnergyMul: %d, PreheatStep: %d, ChessColor: %s", EnergyMul, PreheatStep, ChessColor)
+			n++
-			}
-			o.addOrder([]int{NewChessId}, DIFF_LOW, Preheat_type)
-			o.PreheatStep[ChessColor]++
 		}
-	default:
+	}
-		MaxStep := orderCfg.GetMaxStep()
+	for i := n; i < MaxOrderNum; i++ {
-		if o.Step < MaxStep {
+		err := o.CreateNormalOrder(lv, Emit, EnergyMul)
-			n := 0
+		if err != nil {
-			for _, v := range o.OrderList {
+			return err
-				if v.Type == Common_type {
-					n++
-				}
-			}
-			if n != 0 {
-				return nil
-			}
-			Cfg := orderCfg.GetStartOrderByStep(o.Step + 1)
-			o.Step++
-			for _, v := range Cfg {
-				o.addOrder(v.MergeList, DIFF_LOW, Common_type)
-			}
-			return nil
-		} else {
-			/// 生成优先订单
-			if o.CreatePriorityOrder(lv, Emit) {
-				return nil
-			}
-			MaxOrderNum := orderCfg.GetOrderNum(lv)
-			n := 0
-			for _, v := range o.OrderList {
-				if v.Type == Common_type || v.Type == Clean_type || v.Type == Pet_type {
-					n++
-				}
-			}
-			for i := n; i < MaxOrderNum; i++ {
-				err := o.CreateNormalOrder(lv, Emit, EnergyMul)
-				if err != nil {
-					return err
-				}
-			}
 		}
 	}
 	return nil
@@ -271,6 +345,9 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
 							NewLv := GoUtil.RandNum(4+DurLv, 3+DurLv*2)
 							NewChessId = mergeDataCfg.GetChessIdByLvAndColor(NewLv, NewColor)
 						}
+						if NewChessId == 0 {
+							continue
+						}
 						o.addOrder([]int{NewChessId}, DiffLv, Common_type)
 						return true
 					}
@@ -345,7 +422,7 @@ func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 		}
 		break
 	}
-	// log.Printf("CreateNormalOrder: %v, %v, %v", mergeList, OrderDiff, err)
+	log.Printf("CreateNormalOrder: %v, %v, %v", mergeList, OrderDiff, err)
 	o.addOrder(mergeList, OrderDiff, Common_type)
 	return nil
 }
@@ -384,7 +461,15 @@ 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)
@@ -417,14 +502,14 @@ func (o *OrderMod) CreateCleanOrder2(ChessList []int) bool {
 	return true
 }
 
-func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, EnergyMul int) bool {
+func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, EnergyMul, Level int) bool {
-	GetExtraEmitId := mergeDataCfg.GetExtraEmitId()
+	BeginExtraEmitId := orderCfg.GetEmitExtraOrder() // 从发射器F系列开始
 	b1 := false
 	OrderEmit := 0
 	MaxLvChess := make(map[int]int)
 	for _, v := range AddNewEmit {
 		Emit_Id := mergeDataCfg.GetEmitId(v)
-		_, ok := GetExtraEmitId[Emit_Id]
+		ok := Emit_Id >= BeginExtraEmitId
 		_, ok1 := o.EimtOrder[Emit_Id]
 		ChessColor := mergeDataCfg.GetEmitProduceChessType(v)
 		if ok && !ok1 && len(ChessColor) > 0 {
@@ -445,9 +530,20 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
 			MaxLvChess[ChessId]++
 		}
 	}
+	//额外订单补充2；当玩家的棋盘中出现三个相同的满级产物时，立刻生成一个对应的收购订单；
+	for k := range MaxLvChess {
+		ChessNum := GoUtil.GetElemNum(ChessList, k)
+		if ChessNum == 3 && Level >= 12 {
+			b1 = true
+			o.addOrder([]int{k, k, k}, DIFF_LOW, Extra_type)
+		}
+	}
 	//额外订单补充1；CDEG发射器首次合成时，生成其对应2及棋子订单，完成后生成3及，再完成生成4及的；
 	if b1 {
 		ChessColor := mergeDataCfg.GetEmitProduceChessType(OrderEmit)
+		if len(ChessColor) == 0 {
+			return b1
+		}
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(EnergyMul+1, ChessColor[0])
 		if ChessId != 0 {
 			o.PreheatStep[ChessColor[0]] = 1
@@ -521,7 +617,7 @@ func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList
 			Lv := mergeDataCfg.GetLvById(vv)
 			Color := mergeDataCfg.GetColorById(vv)
 			EmitId := GetEmitByColor(Emit, Color)
-			_, Max := getChesslvRange(EmitId, EnergyMul)
+			_, Max := getChesslvRange(EmitId, EnergyMul, o.IsCharge)
 			Adjust := mergeDataCfg.GetAdjust(EmitId, Color)
 			if Lv >= EnergyMul+1 && Lv <= Max-Adjust {
 				continue
@@ -593,3 +689,16 @@ func (o *OrderMod) CreateComfortOrder(lv int, Emit []int, EnergyMul, Diff, Chess
 	o.addOrder(mergeList, Diff, COMFORT_TYPE)
 	return nil
 }
+
+func (o *OrderMod) ResetChessPool() {
+	o.ChessPool = make([]int, 0)
+	o.EmitShuffle = nil
+}
+
+func (o *OrderMod) SetIsCharge() {
+	o.IsCharge = true
+}
+
+func (o *OrderMod) GetIsCharge() bool {
+	return o.IsCharge
+}

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

@@ -12,9 +12,9 @@ var reflectChess = map[int]int{} // 棋子难度映射表
 // 订单棋子数量
 func getChessNumRand(OrderN int) map[int]int {
 	return map[int]int{
-		1: int(15 - 3*OrderN),
+		1: int(70 - 2*OrderN),
-		2: int(50 + OrderN),
+		2: int(25 + OrderN),
-		3: int(35 + 2*OrderN),
+		3: int(5 + OrderN),
 	}
 }
 
@@ -24,21 +24,21 @@ func getOrderDiffRand(Diff, OrderN int) map[int]int {
 	switch Diff {
 	case DIFF_MID:
 		d = map[int]int{
-			DIFF_LOW:  int(21 - 3*OrderN),
+			DIFF_LOW:  21,
-			DIFF_MID:  int(49 + 1.5*float64(OrderN)),
+			DIFF_MID:  49,
-			DIFF_HIGH: int(30 + 1.5*float64(OrderN)),
+			DIFF_HIGH: 30,
 		}
 	case DIFF_HIGH:
 		d = map[int]int{
-			DIFF_LOW:  int(60 - 5*OrderN),
+			DIFF_LOW:  60,
-			DIFF_MID:  int(30 + 3*float64(OrderN)),
+			DIFF_MID:  30,
-			DIFF_HIGH: int(10 + 2*float64(OrderN)),
+			DIFF_HIGH: 10,
 		}
 	default:
 		d = map[int]int{
-			DIFF_LOW:  int(10 - OrderN),
+			DIFF_LOW:  10,
-			DIFF_MID:  int(30),
+			DIFF_MID:  30,
-			DIFF_HIGH: int(60 + OrderN),
+			DIFF_HIGH: 60,
 		}
 	}
 	return d
@@ -56,8 +56,8 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 		switch OrderDiff {
 		case DIFF_LOW:
 			rand := map[int]int{
-				DIFF_LOW: 99 - OrderN,
+				DIFF_LOW: 99,
-				DIFF_MID: 1 + OrderN,
+				DIFF_MID: 1,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
@@ -66,8 +66,8 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 			}
 		case DIFF_MID:
 			rand := map[int]int{
-				DIFF_LOW: 5 + OrderN,
+				DIFF_LOW: 50,
-				DIFF_MID: 95 - OrderN,
+				DIFF_MID: 50,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
@@ -76,9 +76,9 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 			}
 		case DIFF_HIGH:
 			rand := map[int]int{
-				DIFF_LOW:  int(95 - 10*OrderN),
+				DIFF_LOW:  95,
-				DIFF_MID:  int(4 + 6*OrderN),
+				DIFF_MID:  4,
-				DIFF_HIGH: int(1 + 4*OrderN),
+				DIFF_HIGH: 1,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
@@ -90,13 +90,13 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 		switch OrderDiff {
 		case DIFF_LOW:
 			rand := map[int]int{
-				DIFF_LOW: 95 - OrderN,
+				DIFF_LOW: 95,
-				DIFF_MID: 5 + OrderN,
+				DIFF_MID: 5,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				DIFF_LOW: 60 - 4*OrderN,
+				DIFF_LOW: 70,
-				DIFF_MID: 40 + 4*OrderN,
+				DIFF_MID: 30,
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
@@ -106,33 +106,33 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 			}
 		case DIFF_MID:
 			rand := map[int]int{
-				DIFF_LOW: 50 - 3*OrderN,
+				DIFF_LOW: 95,
-				DIFF_MID: 50 + 3*OrderN,
+				DIFF_MID: 5,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				DIFF_MID:  95 - 4*OrderN,
+				DIFF_LOW: 60,
-				DIFF_HIGH: 5 + 4*OrderN,
+				DIFF_MID: 40,
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: DIFF_LOW,
+				1: DIFF_MID,
 				2: secondDiff,
 				3: thirdDiff,
 			}
 		case DIFF_HIGH:
 			rand := map[int]int{
-				DIFF_LOW: int(95 - 10*OrderN),
+				DIFF_LOW: 95,
-				DIFF_MID: int(5 + 10*OrderN),
+				DIFF_MID: 5,
 			}
 			secondDiff := GoUtil.RandMap(rand)
 			rand = map[int]int{
-				DIFF_MID:  int(95 - 8*OrderN),
+				DIFF_LOW: 50,
-				DIFF_HIGH: int(5 + 8*OrderN),
+				DIFF_MID: 50,
 			}
 			thirdDiff := GoUtil.RandMap(rand)
 			rs = map[int]int{
-				1: DIFF_LOW,
+				1: DIFF_HIGH,
 				2: secondDiff,
 				3: thirdDiff,
 			}
@@ -160,6 +160,28 @@ func getChessLv(Min, Max, Diff int) int {
 	return GoUtil.RandNum(Start, End)
 }
 
+func getChessLvRange(Min, Max, Diff int) []int {
+	Start := Min
+	End := Max
+	switch Diff {
+	case DIFF_LOW:
+		End = Min + (Max-Min+1)/3 - 1
+	case DIFF_MID:
+		Start = Min + (Max-Min+1)/3
+		End = Min + (Max-Min+1)/3*2 - 1
+	case DIFF_HIGH:
+		Start = Min + (Max-Min+1)/3*2
+	}
+	Start = max(Min, Start)
+	End = max(Start, End)
+	End = min(Max, End)
+	r := make([]int, 0)
+	for i := Start; i <= End; i++ {
+		r = append(r, i)
+	}
+	return r
+}
+
 // 宝箱雨随机棋子类型
 func RandChessColor(Emit []int) string {
 	r := make(map[string]int)
@@ -182,7 +204,7 @@ func RandChessColor(Emit []int) string {
 }
 
 // 获取棋子等级范围
-func getChesslvRange(Emit int, EnergyMul int) (int, int) {
+func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) {
 	RandEmitLv := mergeDataCfg.GetLvById(Emit)
 	EmitId := mergeDataCfg.GetEmitId(Emit)
 	RandMaxLv := mergeDataCfg.GetMaxLvById(Emit)
@@ -191,6 +213,11 @@ func getChesslvRange(Emit int, EnergyMul int) (int, int) {
 	m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) / Ratio * 100)
 	ChessMinLev := orderCfg.GetLvMin(EnergyMul)
 	ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
+	ProductList := mergeDataCfg.GetEmitProduceType(Emit)
+	ChessMaxLev = ChessMaxLev - len(ProductList) + 2
+	if IsCharge {
+		ChessMaxLev += 1
+	}
 	return ChessMinLev, ChessMaxLev
 }
 
@@ -397,6 +424,9 @@ func getEmitSeries(o *OrderMod, Emit []int) string {
 		}
 		Num := 1
 		for {
+			if len(o.EmitShuffle) == 1 {
+				break
+			}
 			o.EmitShuffle = GoUtil.ShuffleStringArray(o.EmitShuffle)
 			if o.EmitShuffle[0] != PopEmitId {
 				break
@@ -419,6 +449,20 @@ func GetOrderStar(ChessList []int) int {
 	return Star
 }
 
+func GetChessByDiff(EmitId, EnergyMul, Diff int, Color string) []int {
+	ChessMinLv, ChessMaxLv := getChesslvRange(EmitId, EnergyMul, false)
+	LvRange := getChessLvRange(ChessMinLv, ChessMaxLv, Diff)
+	ChessIds := []int{}
+	for _, v := range LvRange {
+		NewLev1 := mergeDataCfg.DynamicLev(v, EmitId, Color)
+		MaxLev := mergeDataCfg.GetMaxLvByColor(Color)
+		NewLev1 = min(NewLev1, MaxLev)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev1, Color)
+		ChessIds = append(ChessIds, ChessId)
+	}
+	return GoUtil.UniqueInts(ChessIds)
+}
+
 // 从棋子池中获取棋子
 func getChessFromPoolByDiff(o *OrderMod, Diff int, Emit []int, EnergyMul int) int {
 	EmitSeries := getEmitSeries(o, Emit)
@@ -447,7 +491,7 @@ func getChessFromPoolByDiff(o *OrderMod, Diff int, Emit []int, EnergyMul int) in
 		MinChessColor := mergeDataCfg.GetColorById(MinChessId)
 		NewEmitChessId := GetEmitByColor(Emit, MinChessColor)
 		ColorRand := mergeDataCfg.GetEmitProduceType(NewEmitChessId)
-		ChessMinLv, ChessMaxLv := getChesslvRange(NewEmitChessId, EnergyMul)
+		ChessMinLv, ChessMaxLv := getChesslvRange(NewEmitChessId, EnergyMul, o.IsCharge)
 		NewLev := getChessLv(ChessMinLv, ChessMaxLv, Diff)
 		MinChessLv := mergeDataCfg.GetLvById(MinChessId)
 		NewLev2 := mergeDataCfg.DynamicLev2(NewLev, NewEmitChessId, ColorRand[0], MinChessColor)
@@ -463,7 +507,7 @@ func getChessFromPoolByDiff(o *OrderMod, Diff int, Emit []int, EnergyMul int) in
 		return Chess
 	}
 	Color := GoUtil.RandStringSlice(ColorRand)
-	ChessMinLv, ChessMaxLv := getChesslvRange(EmitChessId, EnergyMul)
+	ChessMinLv, ChessMaxLv := getChesslvRange(EmitChessId, EnergyMul, o.IsCharge)
 	NewLev := getChessLv(ChessMinLv, ChessMaxLv, Diff)
 	NewLev1 := mergeDataCfg.DynamicLev(NewLev, EmitChessId, Color)
 	MaxLev := mergeDataCfg.GetMaxLvByColor(Color)
@@ -499,7 +543,7 @@ func initReflectChess(Emits []int, EnergyMul int) {
 		if len(ProduceColor) == 0 || ProduceColor[0] == "" {
 			continue
 		}
-		ChessMinLv, ChessMaxLv := getChesslvRange(Emit, EnergyMul)
+		ChessMinLv, ChessMaxLv := getChesslvRange(Emit, EnergyMul, false)
 		Product := mergeDataCfg.GetEmitProduceChessType(Emit)
 		Start = ChessMinLv
 		End = ChessMinLv + (ChessMaxLv-ChessMinLv+1)/3 - 1
@@ -526,6 +570,9 @@ 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)
+		if ChessId == 0 {
+			continue
+		}
 		reflectChess[ChessId] = Diff
 	}
 }

src/server/game/mod/playroom/playroom.go

@@ -518,11 +518,14 @@ func (p *PlayroomMod) Interact(Id, Type int) ([]*item.Item, int, error) {
 	PType, PEffect := playroomCfg.GetInteractPhysiology(Id)
 	p.AddPhysiology(PType, PEffect)
 	p.AddMood(MoodType, Effect)
-	p.AddInteractNum()
 	return ItemList, PType, nil
 }
 
-func (p *PlayroomMod) AddInteractNum() {
+func (p *PlayroomMod) AddInteractNum(Lv int) {
+	Unlock := playroomCfg.GetInteractUnlock()
+	if Lv < Unlock {
+		return
+	}
 	p.InteractNum++
 	p.InteractNum = min(p.InteractNum, playroomCfg.GetInteractNum())
 }
@@ -578,14 +581,15 @@ func (p *PlayroomMod) SetRoom(Room map[int]int) (map[int]int, error) {
 	return diff, nil
 }
 
-func (p *PlayroomMod) AddCollect(Id int) {
+func (p *PlayroomMod) AddCollect(Id int, Label string) {
 	p.NewCollect[Id] = &CollectInfo{
 		Id:      Id,
 		AddTime: GoUtil.Now(),
+		Label:   Label,
 	}
 }
 
-func (p *PlayroomMod) AddDress(Id int) {
+func (p *PlayroomMod) AddDress(Id int, Label string) {
 	Part := playroomCfg.GetDressPart(Id)
 	if _, ok := p.NewDress[Id]; !ok {
 		p.NewDress[Id] = &DressInfo{
@@ -593,7 +597,7 @@ func (p *PlayroomMod) AddDress(Id int) {
 			Part:    Part,
 			AddTime: GoUtil.Now(),
 			EndTime: 0,
-			Label:   "",
+			Label:   Label,
 			Num:     1,
 		}
 	} else {

src/server/game/mod/quest/Quest.go

@@ -18,6 +18,8 @@ const (
 	TRIGGER_LABEL_MERGELVTIME = "MergeLvTime"
 	TRIGGER_LABEL_FINISHORDER = "FinishOrder"
 	TRIGGER_LABEL_ENERGY      = "Energy"
+	TRIGGER_LABEL_STAR        = "Star"    // 收集宠物币
+	TRIGGER_LABEL_DIAMOND     = "Diamond" // 消耗钻石
 	TRIGGER_LABEL_MERGETIME   = "MergeTime"
 	TRIGGER_LABEL_STOKECAT    = "StokeCat"
 	TRIGGER_LABEL_TAKECAT     = "TakeCat"
@@ -26,12 +28,16 @@ const (
 	TRIGGER_LABEL_CLEANCAT    = "CleanCat"
 	TRIGGER_LABEL_UPLV        = "UpLv"        // 升级
 	TRIGGER_LABEL_LOGIN       = "Login"       // 登录
+	TRIGGER_LABEL_GUIDE_LOGIN = "GuideLogin"  // 新手任务登录
 	TRIGGER_LABEL_INTERACT    = "Interact"    // 互动
 	TRIGGER_LABEL_PETDRESS    = "PetDress"    // 宠物换装
 	TRIGGER_LABEL_VISITROOM   = "VisitRoom"   // 参观房间
 	TRIGGER_LABEL_PETTREASURE = "PetTreasure" // 宠物寻宝
 	TRIGGER_LABEL_ROOMDEC     = "RoomDec"     // 房间装饰
 	TRIGGER_LABEL_PETWORK     = "PetWork"     // 宠物工作
+	TRIGGER_LABEL_DECORATE    = "Decorate"    // 装饰
+	TRIGGER_LABEL_PURCHASE    = "Purchase"    // 购买任意物品
+	TRIGGER_LABEL_BUBBLE      = "Bubble"      // 使用钻石打开气泡
 )
 
 type QuestProgress struct {
@@ -69,21 +75,27 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 	}
 
 	switch q.Label {
-	case TRIGGER_LABEL_ENERGY: // 消耗x能量
+	case TRIGGER_LABEL_ENERGY,
-		AddNum := Tr.A[0].(int)
+		TRIGGER_LABEL_STAR,
+		TRIGGER_LABEL_DIAMOND,
+		TRIGGER_LABEL_DECORATE: // 消耗x能量
+		AddNum := GoUtil.Int(Tr.A[0])
 		q.Num += AddNum
 	case TRIGGER_LABEL_MERGELVTIME: // 合成x级棋子y次
-		Lv, _ := Tr.A[0].(int)
+		Lv := GoUtil.Int(Tr.A[0])
 		TargetLv, _ := strconv.Atoi(q.A[0].(string))
 		if TargetLv == Lv {
 			q.Num += 1
 		}
+	case TRIGGER_LABEL_GUIDE_LOGIN: // 引导任务登录
+		LoginDay := GoUtil.Int(q.A[0])
+		q.Num = LoginDay
 	case TRIGGER_LABEL_MERGETIME, // 合成x次
-		TRIGGER_LABEL_FINISHORDER: // 完成x次订单
+		TRIGGER_LABEL_FINISHORDER,
+		TRIGGER_LABEL_BUBBLE: // 完成x次订单
 		q.Num += 1
-
 	case TRIGGER_LABEL_INTERACT: // 互动x类型y次
-		InteractId := Tr.A[0].(int)
+		InteractId := GoUtil.Int(Tr.A[0])
 		Ids := make([]int, 0)
 		for _, v := range q.A {
 			Ids = append(Ids, GoUtil.Int(v))
@@ -113,7 +125,7 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 func QuestProgressToMsg(quest *QuestProgress) *msg.QuestProgress {
 	Param := 0
 	if len(quest.A) > 0 {
-		Param, _ = strconv.Atoi(quest.A[0].(string))
+		Param = GoUtil.Int(quest.A[0])
 	}
 	return &msg.QuestProgress{
 		Label:  quest.Label,

src/server/gamedata/type.go

@@ -19,9 +19,12 @@ type MergeDataRecord struct {
 }
 
 type StartOrderData struct {
-	Id        int   `json:"Id"`
+	Id        int    `json:"Id"`
-	MergeList []int `json:"merge_id_list"`
+	MergeList []int  `json:"merge_id_list"`
-	Step      int   `json:"step"`
+	Step      int    `json:"step"`
+	Appear    string `json:"appear"`
+	Preview   string `json:"preview"`
+	Items     []*item.Item
 }
 
 type SevenLoginRewardData struct {