Merge branch 'develop' into sdk

src/server/GoUtil/feishu.go

@@ -6,30 +6,22 @@ import (
 	"fmt"
 	"net/http"
 	"server/conf"
+	"time"
 )
 
 const (
-	FEISHU_WEBHOOK = "https://open.feishu.cn/open-apis/bot/v2/hook/70e24a79-b019-434a-b4d1-4592bbf7c311"
+	FEISHU_WEBHOOK = "https://gadmin.bywaystudios.com/api/feishu/notify"
 )
 
 // AAqFpbuPhFSEx
 func SendFeishuFatal(PlayerId int, FuncName string, msg string) error {
 	// 创建请求体
 	payload := map[string]interface{}{
-		"msg_type": "interactive",
-		"card": map[string]interface{}{
-			"type": "template",
-			"data": map[string]interface{}{
-				"template_id":           "AAqFpbuPhFSEx",
-				"template_version_name": "1.0.0",
-				"template_variable": map[string]interface{}{
-					"appName":   conf.Server.GameName,
-					"playerId":  PlayerId,
-					"funcName":  FuncName,
-					"fatal_msg": msg,
-				},
-			},
-		},
+		"notify_msg": fmt.Sprintf("游戏接口出错 %s:%d", conf.Server.GameName, PlayerId),
+		"host":       FuncName,
+		"event_name": msg,
+		"severity":   "High",
+		"alarm_time": time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04:05"),
 	}
 	payloadBytes, err := json.Marshal(payload)
 	if err != nil {

src/server/conf/activity/ActivityCfg.go

@@ -2,17 +2,49 @@ package activityCfg
 
 import (
 	"server/GoUtil"
+	"server/game/mod/item"
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 )
 
 const (
-	CFG_ACTIVITY = "Activity"
+	CFG_ACTIVITY      = "Activity"
+	CFG_ACTIVITY_GIFT = "ActivityGift"
 )
 
 func init() {
 	gamedata.InitCfg(CFG_ACTIVITY)
+	gamedata.InitCfg(CFG_ACTIVITY_GIFT)
+}
+
+func GetActivityGiftId(chargeId int) int {
+	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)
+	if err != nil {
+		log.Debug("GetActivityGift err:%v", err)
+	}
+	for _, v := range data {
+		ChargeId := gamedata.GetIntValue(v, "ChargeId")
+		if ChargeId == chargeId {
+			return gamedata.GetIntValue(v, "AId")
+		}
+	}
+	return 0
+}
+
+func GetAcitivityGiftItems(chargeId int) []*item.Item {
+	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)
+	if err != nil {
+		log.Debug("GetAcitivityGiftItems err:%v", err)
+	}
+	for _, v := range data {
+		ChargeId := gamedata.GetIntValue(v, "ChargeId")
+		if ChargeId == chargeId {
+			Items := gamedata.GetItemList(v, "Items")
+			return Items
+		}
+	}
+	return nil
 }
 
 func GetActivityList() []*gamedata.ActivityData {
@@ -37,6 +69,7 @@ func GetActivityList() []*gamedata.ActivityData {
 			ActivityData := &gamedata.ActivityData{
 				Id:        Id,
 				Type:      Type,
+				AType:     gamedata.GetIntValue(v, "AType"),
 				Name:      Name,
 				Title:     Title,
 				Level:     Level,

src/server/conf/champship/ChampshipCfg.go

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

src/server/conf/collect/CollectCfg.go

@@ -0,0 +1,53 @@
+package collectCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_COLLECT         = "Collect"
+	CFG_COLLECT_JACKPOT = "CollectJackpot"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_COLLECT)
+	gamedata.InitCfg(CFG_COLLECT_JACKPOT)
+}
+
+func GetJackpotId() []int {
+	data, err := gamedata.GetData(CFG_COLLECT_JACKPOT)
+	if err != nil {
+		return nil
+	}
+	ret := make([]int, 0)
+	for k := range data {
+		ret = append(ret, GoUtil.Int(k))
+	}
+	return ret
+}
+
+func GetJackpotItems(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT_JACKPOT, Id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetRewardNeed(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Need")
+}
+
+func GetRewardType(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_COLLECT, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Type")
+}

src/server/conf/emoji/emojiCfg.go

@@ -27,3 +27,15 @@ func GetInitList() []int {
 	}
 	return ret
 }
+
+func GetAllList() []int {
+	data, err := gamedata.GetData(CFG_EMOJI)
+	if err != nil {
+		return nil
+	}
+	ret := make([]int, 0)
+	for k := range data {
+		ret = append(ret, GoUtil.Int(k))
+	}
+	return ret
+}

src/server/conf/handbook/handbookCfg.go

@@ -0,0 +1,35 @@
+package handbookCfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+	"server/pkg/github.com/name5566/leaf/log"
+)
+
+const (
+	CFG_HANDBOOK       = "Handbook"
+	CFG_HANDBOOK_CONST = "HandbookConst"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_HANDBOOK)
+	gamedata.InitCfg(CFG_HANDBOOK_CONST)
+}
+
+func GetHandbookReward(Type string) []*item.Item {
+	data, err := gamedata.GetDataByKey(CFG_HANDBOOK, Type)
+	if err != nil {
+		log.Debug("GetHandbookReward err:%v", err)
+		return nil
+	}
+	return gamedata.GetItemList(data, "Items")
+}
+
+func GetHandbookCollectReward() []*item.Item {
+	data, err := gamedata.GetDataByKey(CFG_HANDBOOK_CONST, "collect_item")
+	if err != nil {
+		log.Debug("GetHandbookCollectReward err:%v", err)
+		return nil
+	}
+	return gamedata.GetItemList(data, "Value")
+}

src/server/conf/mergeData/MergeDataCfg.go

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

src/server/conf/playroom/playroomCfg.go

@@ -226,3 +226,29 @@ func GetMoodEffect(Id int) (int, int) {
 	}
 	return gamedata.GetIntValue(data, "MType"), gamedata.GetIntValue(data, "MEffect")
 }
+
+func IsStokeCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "StokeCatId")
+	if err != nil {
+		return false
+	}
+	return gamedata.GetIntValue(data, "Value") == Id
+}
+
+func IsTakeCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "TakeCatId")
+	if err != nil {
+		return false
+	}
+	Ids := gamedata.GetIntSliceValue(data, "Value")
+	return GoUtil.InArray(Id, Ids)
+}
+
+func IsPlayCat(Id int) bool {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "PlayCatId")
+	if err != nil {
+		return false
+	}
+	Ids := gamedata.GetIntSliceValue(data, "Value")
+	return GoUtil.InArray(Id, Ids)
+}

src/server/game/ActivityFunc.go

@@ -46,6 +46,15 @@ func GetActivityInfo(p *Player, actType int) *ActivityInfo {
 	return nil
 }
 
+func GetActivityInfoById(p *Player, Id int) *ActivityInfo {
+	for _, v := range p.activity {
+		if v.Id == Id {
+			return v
+		}
+	}
+	return nil
+}
+
 func GetActivityStatus(p *Player, actType int) int {
 	ActivityInfo := GetActivityInfo(p, actType)
 	if ActivityInfo == nil {

src/server/game/ChargeFunc.go

@@ -1,6 +1,7 @@
 package game
 
 import (
+	activityCfg "server/conf/activity"
 	"server/game/mod/piggyBank"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -11,6 +12,30 @@ func Charge(p *Player, ChargeId int) {
 	EndlessFire(p, ChargeId)   // 无尽礼包
 	PiggyBankFire(p, ChargeId) // 猪猪银行
 	PlayroomFire(p, ChargeId)  // 游乐场
+	ActivityFire(p, ChargeId)  // 活动礼包
+}
+
+func ActivityFire(p *Player, ChargeId int) {
+	ActivityMod := p.PlayMod.getActivityMod()
+	ActivityId := activityCfg.GetActivityGiftId(ChargeId)
+	ActivityInfo := GetActivityInfoById(p, ActivityId)
+	if ActivityInfo == nil {
+		log.Debug("ActivityFire ActivityInfo nil : player id :%d, charge id:%d", p.M_DwUin, ChargeId)
+		return
+	}
+	Item, err := ActivityMod.Fire(ChargeId)
+	if err != nil {
+		log.Debug("ActivityFire err : %s", err)
+		return
+	}
+	err = p.HandleItem(Item, msg.ITEM_POP_LABEL_ActivityGift.String())
+	if err != nil {
+		log.Debug("ChargeFire err : %s", err)
+		return
+	}
+	p.PlayMod.save()
+	p.initAcitivity()
+	p.BackDataActivity()
 }
 
 func PlayroomFire(p *Player, ChargeId int) {

src/server/game/GameLogic.go

@@ -628,7 +628,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("UpdateBaseItemInfo", UpdateBaseItemInfofunction) // 保存引导
 	RegisterMsgProcessFunc("ReqKv", ReqKv)                                   // 保存客户端数据
 	RegisterMsgProcessFunc("ReqGetEnergyByAD", ReqGetEnergyByAD)             // 看广告获取能量
-
+	RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy)                     // 购买能量
 	// #region 棋盘
 	RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
 	RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
@@ -640,15 +640,16 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqBuyChessBagGrid", ReqBuyChessBagGrid)           // 解锁背包格子
 	RegisterMsgProcessFunc("ReqSourceChest", ReqSourceChest)                   // 开宝箱
 	RegisterMsgProcessFunc("ReqSeparateChess", ReqSeparateChess)               // 分解棋子
-
-	RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy) //购买能量
+	RegisterMsgProcessFunc("ReqUpgradeChess", ReqUpgradeChess)                 // 升级棋子
+	RegisterMsgProcessFunc("ReqSellChessNum", ReqSellChessNum)                 //购买能量
 
 	//领取图鉴奖励
 	RegisterMsgProcessFunc("ReqGetHandbookReward", ReqGetHandbookReward) //领取图鉴奖励
-
+	RegisterMsgProcessFunc("RegHandbookAllReward", RegHandbookAllReward) //领取图鉴收集奖励
 	//领取订单奖励
 	RegisterMsgProcessFunc("ReqRewardOrder", ReqRewardOrder) // 领取订单奖励
 	RegisterMsgProcessFunc("ReqDelOrder", ReqDelOrder)       // 删除订单
+
 	//装饰
 	RegisterMsgProcessFunc("ReqDecorate", ReqDecorate)       // 装饰
 	RegisterMsgProcessFunc("ReqDecorateAll", ReqDecorateAll) // 装饰全部
@@ -688,7 +689,9 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqSetAvatar", ReqSetAvatar) // 设置头像框
 	// 表情
 	RegisterMsgProcessFunc("ReqSetEmoji", ReqSetEmoji) // 设置表情
-
+	// 收藏室
+	RegisterMsgProcessFunc("ReqCollectInfo", ReqCollectInfo) // 请求收藏室数据
+	RegisterMsgProcessFunc("ReqCollect", ReqCollect)         // 领取收藏室奖励
 	// 七日签到
 	RegisterMsgProcessFunc("ReqGetSevenLoginReward", ReqGetSevenLoginReward) // 领取七日签到奖励
 	RegisterMsgProcessFunc("ReqGetMonthLoginReward", ReqGetMonthLoginReward) // 领取月签到奖励
@@ -707,6 +710,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqFriendCardMsg", ReqFriendCardMsg)     // 请求好友卡牌申请列表
 	RegisterMsgProcessFunc("ReqFriendTimeLine", ReqFriendTimeLine)   // 请求好友时间线
 	RegisterMsgProcessFunc("ReqFriendRecommend", ReqFriendRecommend) // 获取推荐好友
+	RegisterMsgProcessFunc("ReqFriendTLUpvote", ReqFriendTLUpvote)   // 请求时间线点赞
 
 	RegisterMsgProcessFunc("ReqSearchPlayer", ReqSearchPlayer) // 搜索好友
 	RegisterMsgProcessFunc("ReqApplyFriend", ReqApplyFriend)   // 申请好友

src/server/game/Gm.go

@@ -8,9 +8,11 @@ import (
 	"server/conf"
 	cardCfg "server/conf/card"
 	chargeCfg "server/conf/charge"
+	emojiCfg "server/conf/emoji"
 	playroomCfg "server/conf/playroom"
 	"server/db"
 	"server/game/mod/card"
+	"server/game/mod/emoji"
 	"server/game/mod/friend"
 	"server/game/mod/item"
 	MsgMod "server/game/mod/msg"
@@ -29,6 +31,11 @@ func ReqGmCommand(player *Player, buf []byte) error {
 	return ReqGmCommand_(player, detail.Command)
 }
 func ReqGmCommand_(player *Player, Command string) error {
+	// defer func() {
+	// 	if err := recover(); err != nil {
+	// 		log.Error("ReqGmCommand panic: %v", err)
+	// 	}
+	// }()
 	arg := strings.Split(Command, " ")
 	switch arg[0] {
 	case "additem":
@@ -69,11 +76,18 @@ func ReqGmCommand_(player *Player, Command string) error {
 		player.PlayMod.getBaseMod().Level = num
 		player.PlayMod.getBaseMod().Exp = 0
 		player.PushClientRes(player.PlayerBaseMod.BackAsset())
+		player.initAcitivity()
+		player.BackDataActivity()
 	case "zeroUpdate":
 		VarMod := player.PlayMod.getVarMod()
 		VarMod.DailyResetTime = 0
 		player.ZeroUpdate(nil)
 		// G_GameLogicPtr.ZeroFlush()
+	case "resetActivity":
+		ActivityMod := player.PlayMod.getActivityMod()
+		ActivityMod.Var = nil
+		ActivityMod.InitData()
+		player.PlayMod.save()
 	case "weekUpdate":
 		VarMod := player.PlayMod.getVarMod()
 		VarMod.WeeklyResetTime = 0
@@ -105,6 +119,24 @@ func ReqGmCommand_(player *Player, Command string) error {
 		AvatarMod := player.PlayMod.getAvatarMod()
 		AvatarMod.List = nil
 		AvatarMod.InitData()
+	case "initEmoji":
+		EmojiMod := player.PlayMod.getEmojiMod()
+		InitId := emojiCfg.GetInitList()
+		now := GoUtil.Now()
+		for _, v := range InitId {
+			EmojiMod.List[v] = &emoji.Emoji{
+				AddTime: now,
+			}
+		}
+	case "addEmoji":
+		EmojiMod := player.PlayMod.getEmojiMod()
+		InitId := emojiCfg.GetAllList()
+		now := GoUtil.Now()
+		for _, v := range InitId {
+			EmojiMod.List[v] = &emoji.Emoji{
+				AddTime: now,
+			}
+		}
 	case "createOrder":
 		Lv := player.GetPlayerBaseMod().GetLevel()
 		EmitList := player.PlayMod.getChessMod().GetEmitList()
@@ -193,6 +225,11 @@ func ReqGmCommand_(player *Player, Command string) error {
 		PlayroomMod := playroom.PlayroomMod{}
 		PlayroomMod.InitData()
 		player.PlayMod.mod_list.Playroom = PlayroomMod
+	case "resetCollect":
+		CollectMod := player.PlayMod.getCollectMod()
+		CollectMod.Reward = make([]int, 0)
+		CollectMod.Jackpot = make([]int, 0)
+		CollectMod.InitData()
 	case "playroomCollect":
 		CollectList := playroomCfg.GetDecorateList()
 		PlayroomMod := player.PlayMod.getPlayroomMod()
@@ -265,7 +302,7 @@ func ReqGmCommand_(player *Player, Command string) error {
 		LimitedTimeEventMod.ResetFastProduceCD()
 		EndTime, Times := LimitedTimeEventMod.GetFastProduceInfo()
 		player.PushClientRes(&msg.ResFastProduceInfo{
-			EndTime: int32(EndTime),
+			EndTime: EndTime,
 			Num:     int32(Times),
 		})
 	case "recoverUser":

src/server/game/Player.go

@@ -826,6 +826,10 @@ func (p *Player) TeLog(Type string, Param map[string]interface{}) {
 		EventName: Type,
 		Param:     Param,
 	})
+	agent := p.GetAgent()
+	if agent != nil {
+		Param["Ip"] = agent.RemoteAddr().String()
+	}
 	telog.Te.Track(p.GetPlayerBaseMod().GetName(), p.GetPlayerBaseMod().GetName(), Type, Param)
 }
 
@@ -842,10 +846,14 @@ func (p *Player) initAcitivity() {
 	p.activity = make(map[int]*ActivityInfo)
 	ActivityList := activityCfg.GetActivityList()
 	Level := p.GetPlayerBaseMod().GetLevel()
+	ActivityMod := p.PlayMod.getActivityMod()
 	for _, v := range ActivityList {
 		if v.Level > Level {
 			continue
 		}
+		if !ActivityMod.CheckActivity(v) {
+			continue
+		}
 		p.activity[v.Id] = &ActivityInfo{
 			StartT: v.StartTime,
 			EndT:   v.EndTime,

src/server/game/PlayerBaseMod.go

@@ -515,6 +515,7 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int) (int, error) {
 		player.PushClientRes(ChargeMod.BackData())
 		// 重载活动
 		player.initAcitivity()
+		player.BackDataActivity()
 		p.p.TeLog("level_up", map[string]interface{}{
 			"after_level": BaseMod.Level,
 		})

src/server/game/PlayerChessMod.go

@@ -280,7 +280,6 @@ func getChesslvRange(Emit int, EnergyMul int) (int, int) {
 }
 
 func triggerComposeChess(player *Player, ChessId, EnergyMul int, Emit []int) {
-	return
 	OrderMod := player.PlayMod.getOrderMod()
 	if OrderMod.Step != 12 {
 		return

src/server/game/PlayerFunc.go

@@ -223,6 +223,9 @@ func handle(p *Player, m *msg.Msg) error {
 			Items = m.Extra.([]*item.Item)
 		}
 		p.HandleItem(Items, proto.ITEM_POP_LABEL_Friendtreasure.String())
+	case msg.HANDLE_TYPE_HANDBOOK_COLLECTION: // 图鉴收集奖励
+		data := m.Extra.(msg.HandbookMsg)
+		p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_VISIT, data.Type)
 	}
 	// #region 以下是处理系统请求
 	return nil
@@ -373,6 +376,7 @@ func FriendLogBackData(p *Player) {
 			Time:   int32(v.Time),
 			Param:  v.Param,
 			Id:     int32(v.Id),
+			Upvote: v.Upvote,
 		})
 	}
 	p.PushClientRes(&proto.ResFriendTimeLine{
@@ -492,6 +496,7 @@ func BackUserInfo(p *Player) {
 		AvatarList:  AvatarMod.BackData(),
 		FaceList:    FaceMod.BackData(),
 		EmojiList:   p.PlayMod.getEmojiMod().BackData(),
+		SetEmoji:    p.PlayMod.getEmojiMod().GetEmojiSet(),
 		Login:       int32(BaseMod.GetLoginTime()),
 		PetName:     BaseMod.PetName,
 	})
@@ -868,3 +873,14 @@ func GetUidByFaceBook(Fb string) (int, error) {
 	log.Debug("Fb :%s;Uid :%d", Fb, R.Uid)
 	return R.Uid, err
 }
+
+func NotifyAllFriend(p *Player, m *msg.Msg) {
+	FriendMod := p.PlayMod.getFriendMod()
+	for k := range FriendMod.FriendList {
+		if k == int(p.M_DwUin) {
+			continue
+		}
+		m.To = k
+		FriendMgrSend(m)
+	}
+}

src/server/game/PlayerMod.go

@@ -5,12 +5,14 @@ import (
 	"encoding/gob"
 	"fmt"
 	"server/db"
+	"server/game/mod/activity"
 	"server/game/mod/avatar"
 	"server/game/mod/base"
 	"server/game/mod/card"
 	"server/game/mod/champship"
 	"server/game/mod/charge"
 	"server/game/mod/chess"
+	"server/game/mod/collect"
 	"server/game/mod/dailyTask"
 	"server/game/mod/decorate"
 	"server/game/mod/emoji"
@@ -73,6 +75,8 @@ type PlayerModList struct {
 	Playroom         playroom.PlayroomMod                 // 玩家小屋
 	FriendTreasure   friendTreasure.FriendTreasureMod     // 好友宝藏
 	Emoji            emoji.EmojiMod                       // 表情
+	Collect          collect.Collect                      // 收集
+	Activity         activity.Activity                    // 活动
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -105,7 +109,6 @@ func (p *PlayerModData) ReqModData(buf []byte) {
 
 // 推送基础数据
 func (p *PlayerModData) Reconnect(b bool) []byte {
-
 	return []byte{}
 }
 
@@ -171,6 +174,8 @@ func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	p.ModList.GuessColor.InitData()
 	p.ModList.Playroom.InitData()
 	p.ModList.Emoji.InitData()
+	p.ModList.Collect.InitData()
+	p.ModList.Activity.InitData()
 	return is_update, nil
 }
 
@@ -350,3 +355,11 @@ func (p *PlayerMod) getFriendTreasureMod() *friendTreasure.FriendTreasureMod {
 func (p *PlayerMod) getEmojiMod() *emoji.EmojiMod {
 	return &p.mod_list.Emoji
 }
+
+func (p *PlayerMod) getCollectMod() *collect.Collect {
+	return &p.mod_list.Collect
+}
+
+func (p *PlayerMod) getActivityMod() *activity.Activity {
+	return &p.mod_list.Activity
+}

src/server/game/RegisterNetworkFunc.go

@@ -6,13 +6,16 @@ import (
 	"math"
 	"server/GoUtil"
 	cardCfg "server/conf/card"
+	collectCfg "server/conf/collect"
 	decorateCfg "server/conf/decorate"
+	handbookCfg "server/conf/handbook"
 	mergeDataCfg "server/conf/mergeData"
 	miningCfg "server/conf/mining"
 	playroomCfg "server/conf/playroom"
 	"server/db"
 	"server/game/internal"
 	"server/game/mod/card"
+	"server/game/mod/collect"
 	"server/game/mod/friend"
 	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
@@ -143,8 +146,8 @@ func ReqGetHandbookReward(player *Player, buf []byte) error {
 		})
 		return err
 	}
-	var itemList []*item.Item
-	itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: 5})
+
+	itemList := handbookCfg.GetHandbookCollectReward()
 	err = player.HandleItem(itemList, msg.ITEM_POP_LABEL_HandbookReward.String())
 	if err != nil {
 		player.SendErrClienRes(&msg.ResGetHandbookReward{
@@ -165,6 +168,41 @@ func ReqGetHandbookReward(player *Player, buf []byte) error {
 	return nil
 }
 
+func RegHandbookAllReward(player *Player, buf []byte) error {
+	req := &msg.RegHandbookAllReward{}
+	proto.Unmarshal(buf, req)
+	Items, err := player.PlayMod.getHandbookMod().CollectItem(req.Type)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResHandbookAllReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_HandbookAllReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResHandbookAllReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PushClientRes(&msg.ResHandbookAllReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	NotifyAllFriend(player, &MsqMod.Msg{
+		Type:  MsqMod.HANDLE_TYPE_HANDBOOK_COLLECTION,
+		From:  int(player.M_DwUin),
+		SendT: GoUtil.Now(),
+		Extra: MsqMod.HandbookMsg{
+			Type: req.Type,
+		},
+	})
+	player.PushClientRes(player.PlayMod.getHandbookMod().BackData())
+	player.PlayMod.save()
+	return nil
+}
+
 // 领取订单奖励
 func ReqRewardOrder(player *Player, buf []byte) error {
 	req := &msg.ReqRewardOrder{}
@@ -278,8 +316,13 @@ func ReqRewardOrder(player *Player, buf []byte) error {
 	Lv := player.GetPlayerBaseMod().GetLevel()
 	EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
 	Emit := ChessMod.GetOrderEmit()
-	OrderMod.CreateOrder(Lv, Emit, EnergyMul)
-
+	TriggerSeedSource(player)
+	NewOrder := TriggerSeedOrder(player)
+	if NewOrder == nil {
+		OrderMod.CreateOrder(Lv, Emit, EnergyMul)
+	} else {
+		OrderMod.CreateOrderSeed(NewOrder)
+	}
 	// 存钱罐增加钻石
 	PiggyBankMod := player.PlayMod.getPiggyBankMod()
 	PiggyBankMod.Trigger()
@@ -521,6 +564,7 @@ func ReqGetChessFromBuff(player *Player, buf []byte) error {
 	if Update {
 		player.PushClientRes(OrderMod.BackData())
 	}
+	triggerComposeChess(player, ChessId, player.PlayMod.getBaseMod().EnergyMul, player.PlayMod.getChessMod().GetEmitList())
 	EmitRetireTrigger1(player)
 	player.PlayMod.save()
 	player.PushClientRes(ChessMod.BackData())
@@ -670,6 +714,42 @@ func ReqSeparateChess(player *Player, buf []byte) error {
 	return nil
 }
 
+func ReqUpgradeChess(player *Player, buf []byte) error {
+	req := &msg.ReqUpgradeChess{}
+	proto.Unmarshal(buf, req)
+	ChessMod := player.PlayMod.getChessMod()
+	err := ChessMod.UpgradeChess(int(req.ChessId))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResUpgradeChess{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	data := &PlayerChessData{}
+	err = data.UpdateChessData(player, req.MChessData)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResUpgradeChess{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		player.TeLog("outsync_event", map[string]interface{}{
+			"outsync_event": "ReqUpgradeChess",
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(ChessMod.BackData())
+	player.PushClientRes(&msg.ResUpgradeChess{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	player.TeLog("upgrade_use", map[string]interface{}{
+		"upgrade_item_id": int(req.ChessId),
+	})
+	player.UpdateUserInfo()
+	return nil
+}
+
 // 棋子转换
 func ReqChessEx(player *Player, buf []byte) error {
 	req := &msg.ReqChessEx{}
@@ -1183,7 +1263,7 @@ func ReqFastProduceInfo(player *Player, buf []byte) error {
 	LimitedTimeEventMod := player.PlayMod.getLimitedTimeEventMod()
 	EndTime, Times := LimitedTimeEventMod.GetFastProduceInfo()
 	player.PushClientRes(&msg.ResFastProduceInfo{
-		EndTime: int32(EndTime),
+		EndTime: EndTime,
 		Num:     int32(Times),
 	})
 	return nil
@@ -2284,6 +2364,7 @@ func ReqChampshipReward(player *Player, buf []byte) error {
 	}
 	player.PlayMod.save()
 	BackChampship(player)
+	TriggerSeed(player)
 	player.PushClientRes(&msg.ResChampshipReward{
 		Code: msg.RES_CODE_SUCCESS,
 	})
@@ -2361,6 +2442,37 @@ func ReqFriendTimeLine(player *Player, buf []byte) error {
 	return nil
 }
 
+func ReqFriendTLUpvote(player *Player, buf []byte) error {
+	req := &msg.ReqFriendTLUpvote{}
+	proto.Unmarshal(buf, req)
+	FriendMod := player.PlayMod.getFriendMod()
+	Items, err := FriendMod.Upvote(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTLUpvote{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_TLUpvote.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTLUpvote{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTLUpvote{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   req.Id,
+	})
+	player.TeLog("friend_upvote", map[string]interface{}{
+		"player_id": int(req.Id),
+	})
+	return nil
+}
+
 func ReqChampshipRankReward(player *Player, buf []byte) error {
 	MyLastRank := G_GameLogicPtr.ChampshipMgr.getLastMyRank(int(player.M_DwUin))
 	ChampshipMod := player.PlayMod.getChampshipMod()
@@ -2919,6 +3031,21 @@ func ReqPlayroomInteract(player *Player, buf []byte) error {
 		})
 		return err
 	}
+	if playroomCfg.IsStokeCat(int(req.Id)) {
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_STOKECAT})
+	}
+	if playroomCfg.IsPlayCat(int(req.Id)) {
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_PLAYCAT})
+	}
+	if playroomCfg.IsTakeCat(int(req.Id)) {
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_TAKECAT})
+	}
+	switch req.Type {
+	case playroom.MOOD_TYPE_CLEAN:
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_CLEANCAT})
+	case playroom.MOOD_TYPE_FOOD:
+		player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_FEEDCAT})
+	}
 	player.PlayMod.save()
 	LimitedTimePlayroomTrigger(player)
 	player.PushClientRes(PlayroomMod.NotifyMood())
@@ -3540,5 +3667,73 @@ func ReqSetEmoji(player *Player, buf []byte) error {
 	player.PushClientRes(&msg.ResSetEmoji{
 		Code: msg.RES_CODE_SUCCESS,
 	})
+	BackUserInfo(player)
+	return nil
+}
+
+// 请求收藏室内
+func ReqCollectInfo(player *Player, buf []byte) error {
+	CollectMod := player.PlayMod.getCollectMod()
+	player.PushClientRes(CollectMod.BackData())
+	return nil
+}
+
+// 领取收集奖励
+func ReqCollect(player *Player, buf []byte) error {
+	req := &msg.ReqCollect{}
+	proto.Unmarshal(buf, req)
+	CollectMod := player.PlayMod.getCollectMod()
+	Type := collectCfg.GetRewardType(int(req.Id))
+	Num := 0
+	switch Type {
+	case collect.COLLECT_TYPE_EMOJI:
+		Num = player.PlayMod.getEmojiMod().GetEmojiNum()
+	case collect.COLLECT_TYPE_FACE:
+		Num = player.PlayMod.getFaceMod().GetFaceNum()
+	case collect.COLLECT_TYPE_AVATAR:
+		Num = player.PlayMod.getAvatarMod().GetAvatarNum()
+	}
+	Items, err := CollectMod.GetReward(int(req.Id), Num)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCollect{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_Collect.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCollect{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(CollectMod.BackData())
+	player.PushClientRes(&msg.ResCollect{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	player.TeLog("collect", map[string]interface{}{
+		"Id":    int(req.Id),
+		"Items": Items,
+	})
+	return nil
+}
+
+// 获取出售棋子获得的星星数量
+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
+	if checkChess(int(req.ChessId), BaseMod.GetEnergyMul(), ChessMod.GetEmitList()) {
+		Num = data.Star
+	}
+	player.PushClientRes(&msg.ResSellChessNum{
+		Num: int32(Num),
+	})
 	return nil
 }

src/server/game/Trigger.go

@@ -1,13 +1,19 @@
 package game
 
 import (
+	"math"
 	"server/GoUtil"
 	"server/MergeConst"
 	"server/conf"
+	champshipCfg "server/conf/champship"
+	mergeDataCfg "server/conf/mergeData"
 	"server/db"
+	"server/game/mod/chess"
+	"server/game/mod/item"
 	"server/game/mod/order"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
+	"sort"
 	"time"
 )
 
@@ -105,3 +111,272 @@ func TriggerComfortOrder(p *Player) {
 		OrderMod.CreateComfortOrder(Lv, EmitList, EnergyMul, order.DIFF_LOW, 3)
 	}
 }
+
+func TriggerSeed(player *Player) {
+	ChampshipMod := player.PlayMod.getChampshipMod()
+	Items, Score := champshipCfg.GetRewardItems(ChampshipMod.Reward + 1)
+	if Score < 50 {
+		return
+	}
+	b := false
+	for _, v := range Items {
+		if v.Id == item.ITEM_ENERGY_ID {
+			b = true
+			break
+		}
+	}
+	BaseMod := player.PlayMod.getBaseMod()
+	if !b {
+		BaseMod.SetSeed(false)
+	} else {
+		BaseMod.SetSeed(true)
+	}
+}
+
+func TriggerSeedSource(player *Player) {
+	BaseMod := player.PlayMod.getBaseMod()
+	if !BaseMod.GetSeed() {
+		return
+	}
+	Total := 0
+	Energy := BaseMod.GetEnergy()
+	Total += Energy
+
+	ChessMod := player.PlayMod.getChessMod()
+	ChessList := ChessMod.GetUnlockChessList()
+	ChessBuff := ChessMod.GetChessBuf()
+	AllChess := append(ChessList, ChessBuff...)
+	for _, v := range AllChess {
+		ChessColor := mergeDataCfg.GetColorById(v)
+		if ChessColor == "Energy" {
+			Total += mergeDataCfg.GetSellNumById(v)
+		}
+		if v == chess.CHESS_ENERGY_CHEST {
+			Total += 50
+		}
+		if v == chess.CHESS_SURPRISE_CHEST_LOCK || v == chess.CHESS_SURPRISE_CHEST {
+			Total += 10
+		}
+		if v == chess.CHESS_SOURCE_CHEST {
+			Total += 100
+		}
+		if v == chess.CHESS_HIGH_SOURCE_CHEST {
+			Total += 250
+		}
+	}
+
+	Total += (5 - BaseMod.EnergyAD) * 25
+	BaseMod.SetSource(Total)
+}
+
+func TriggerSeedOrder(player *Player) *order.Order {
+	OrderMod := player.PlayMod.getOrderMod()
+	ChessMod := player.PlayMod.getChessMod()
+	BaseMod := player.PlayMod.getBaseMod()
+	if !BaseMod.GetSeed() {
+		return nil
+	}
+	OrderMod.CreatOrderPool(BaseMod.Level, ChessMod.GetOrderEmit(), BaseMod.EnergyMul)
+	ChampshipMod := player.PlayMod.getChampshipMod()
+	NeedScore := champshipCfg.GetRewardTotalScore(ChampshipMod.Reward + 1)
+	E := BaseMod.GetSource()
+	ChessList := ChessMod.GetUnlockChessList()
+	ChessBuff := ChessMod.GetChessBuf()
+	AllChess := append(ChessList, ChessBuff...)
+	NewOrder := &order.Order{}
+	MaxQ := 0
+	MinQ := 0
+	// 计算Q值
+	for _, Order := range OrderMod.OrderPool {
+		Q := 0
+		for _, v := range Order.MergeId {
+			Color := mergeDataCfg.GetColorById(v)
+			Lv := mergeDataCfg.GetLvById(v)
+			Q1 := int(math.Pow(2, float64(Lv))) - 1
+			Q2 := 0
+			Q3 := 0
+			for _, Chess := range AllChess {
+				Lv1 := mergeDataCfg.GetLvById(Chess)
+				Color1 := mergeDataCfg.GetColorById(Chess)
+				Type := mergeDataCfg.GetTypeById(Chess)
+				if Type != "Product" {
+					continue
+				}
+				if Color != Color1 {
+					continue
+				}
+				if Lv1 > Lv {
+					continue
+				}
+				Q2 += int(math.Pow(2, float64(Lv1))) - 1
+			}
+			for _, Chess := range AllChess {
+				if Chess == chess.CHESS_ZIXUAN_CHEST {
+					if Lv < 3 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 3)) - 1
+				}
+				if Chess == chess.CHESS_HIGH_ZIXUAN_CHEST {
+					if Lv < 7 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 7)) - 1
+				}
+				if Chess == chess.CHESS_SOURCE_CHEST {
+					if Lv < 3 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 3)) - 1
+					Q3 += int(math.Pow(2, 4)) - 1
+				}
+				if Chess == chess.CHESS_HIGH_SOURCE_CHEST {
+					if Lv < 7 {
+						continue
+					}
+					Q3 += int(math.Pow(2, 7)) - 1
+					Q3 += int(math.Pow(2, 7)) - 1
+				}
+			}
+			Q += max(Q1-Q2-Q3, 0)
+			Order.Q = Q
+			MaxQ = max(MaxQ, Q)
+			MinQ = min(MinQ, Q)
+		}
+	}
+
+	if E > MaxQ {
+		return nil
+	}
+
+	if E == MaxQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MaxQ {
+				NewOrder = Order
+				break
+			}
+		}
+		EmitTypeList := []string{}
+		for _, v := range NewOrder.MergeId {
+			Color := mergeDataCfg.GetColorById(v)
+			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
+			EmitTypeList = append(EmitTypeList, EmitType)
+		}
+		ChessList := []int{}
+		for _, v := range AllChess {
+			Color := mergeDataCfg.GetColorById(v)
+			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
+			Lv := mergeDataCfg.GetLvById(v)
+			if Lv < 3 || Lv > 4 {
+				continue
+			}
+			if GoUtil.InStringArray(EmitType, EmitTypeList) {
+				continue
+			}
+			ChessList = append(ChessList, v)
+		}
+		if len(ChessList) != 0 {
+			RandChess := GoUtil.RandSlice(ChessList)
+			Color := mergeDataCfg.GetColorById(RandChess)
+			Lv := mergeDataCfg.GetLvById(RandChess)
+			NewChess := mergeDataCfg.GetChessIdByLvAndColor(Lv, Color)
+			NewOrder.MergeId = append(NewOrder.MergeId, NewChess)
+		}
+		return NewOrder
+	}
+
+	if E == MinQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MinQ {
+				return Order
+			}
+		}
+	}
+
+	if E < MinQ {
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q == MinQ {
+				ChessList := []int{}
+				for _, v := range AllChess {
+					Lv := mergeDataCfg.GetLvById(v)
+					if Lv < 5 {
+						ChessList = append(ChessList, v)
+					}
+				}
+				if len(ChessList) != 0 {
+					NewChess := GoUtil.RandSlice(ChessList)
+					Order.MergeId = append(Order.MergeId, NewChess)
+				}
+				return Order
+			}
+		}
+	}
+
+	if E > MinQ && E < MaxQ {
+		L1 := []*order.Order{}
+		for _, Order := range OrderMod.OrderPool {
+			if Order.Q > E {
+				L1 = append(L1, Order)
+			}
+		}
+		Smax := 0
+		Smin := 0
+		for _, Order := range L1 {
+			Score := 0
+			for _, v := range Order.MergeId {
+				Lv := mergeDataCfg.GetLvById(v)
+				Score += champshipCfg.GetChessScore(Lv)
+			}
+			Smax = max(Score, Smax)
+			Smin = min(Score, Smin)
+			Order.S = Score
+		}
+
+		if NeedScore > Smax {
+			for _, Order := range OrderMod.OrderPool {
+				if Order.Q == MinQ {
+					ChessList := []int{}
+					for _, v := range AllChess {
+						Lv := mergeDataCfg.GetLvById(v)
+						if Lv < 5 {
+							ChessList = append(ChessList, v)
+						}
+					}
+					if len(ChessList) != 0 {
+						NewChess := GoUtil.RandSlice(ChessList)
+						Order.MergeId = append(Order.MergeId, NewChess)
+					}
+					return Order
+				}
+			}
+		}
+		if NeedScore == Smax {
+			for _, Order := range L1 {
+				if Order.S == Smax {
+					return Order
+				}
+			}
+		}
+
+		if NeedScore == Smin {
+			for _, Order := range L1 {
+				if Order.S == Smin {
+					return Order
+				}
+			}
+		}
+		L2 := []*order.Order{}
+		for _, Order := range L1 {
+			if Order.S > NeedScore {
+				L2 = append(L2, Order)
+			}
+		}
+		if len(L2) != 0 {
+			sort.Slice(L2, func(i, j int) bool {
+				return L2[i].Q < L2[j].Q
+			})
+			return L2[0]
+		}
+	}
+	return NewOrder
+}

src/server/game/UnitTest.go

@@ -8,6 +8,7 @@ import (
 	"server/game/mod/sevenLogin"
 	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
+	"time"
 )
 
 func UnitEndlessReward(p *Player) error {
@@ -51,6 +52,20 @@ func UnitOrder(p *Player) error {
 	return nil
 }
 
+func UnitOrderSeed(player *Player) error {
+	start := time.Now()
+
+	BaseMod := player.PlayMod.getBaseMod()
+	BaseMod.Seed = true
+	TriggerSeedSource(player)
+	o := TriggerSeedOrder(player)
+	fmt.Println(o)
+
+	elapsed := time.Since(start)
+	fmt.Printf("UnitOrderSeed took %s\n", elapsed)
+	return nil
+}
+
 func UnitChess(p *Player) error {
 	CardMod := p.PlayMod.getCardMod()
 	for i := 0; i < 1000; i++ {

src/server/game/external.go

@@ -103,7 +103,6 @@ func HandleClientReq(args []interface{}) {
 		data, _ := proto.Marshal(ResRegisterAccount)
 		gl.PackResInfo(a, "ResRegisterAccount", data)
 	case "ReqLogin":
-
 		detail := &msg.ReqLogin{}
 		proto.Unmarshal(buf, detail)
 		accountInfo := db.GetAccountInfoFromDb(detail.UserName)

src/server/game/mod/activity/activity.go

@@ -0,0 +1,72 @@
+package activity
+
+import (
+	"encoding/gob"
+	"server/gamedata"
+)
+
+const (
+	ACT_STATUS_NOT_START = 0
+	ACT_STATUS_START     = 1
+	ACT_STATUS_END       = 2
+)
+
+const (
+	ACT_TYPE_MINING        = 1 // 挖矿
+	ACT_TYPE_GUESS_COLOR   = 2 // 猜颜色
+	ACT_TYPE_RACE          = 3 // 赛跑
+	ACT_TYPE_DISCOUNT_GIFT = 4 // 折扣礼包
+)
+
+const (
+	ACT_ATYPE_NORMAL     = 1 // 普通活动
+	ACT_ATYPE_LIMIT_GIFT = 2 // 限时礼包活动
+)
+
+type Activity struct {
+	Var map[int]interface{}
+	// 活动数据
+}
+
+type Gift struct {
+	Buy  bool
+	Time int64
+}
+
+func init() {
+	gob.Register(&Gift{})
+}
+
+func (a *Activity) InitData() {
+	a.Var = make(map[int]interface{})
+}
+
+func (a *Activity) GetVar(key int) interface{} {
+	return a.Var[key]
+}
+
+func (a *Activity) SetVar(key int, value interface{}) {
+	a.Var[key] = value
+}
+
+func (a *Activity) getGIftVar(key int) *Gift {
+	Var := a.GetVar(key)
+	if Var == nil {
+		Var = &Gift{}
+		a.SetVar(key, Var)
+	}
+	return Var.(*Gift)
+}
+
+func (a *Activity) CheckActivity(data *gamedata.ActivityData) bool {
+	switch data.AType {
+	case ACT_ATYPE_NORMAL:
+		return true
+	case ACT_ATYPE_LIMIT_GIFT:
+		Var := a.getGIftVar(data.Id)
+		if Var.Buy {
+			return false
+		}
+	}
+	return true
+}

src/server/game/mod/activity/activityGift.go

@@ -0,0 +1,19 @@
+package activity
+
+import (
+	"fmt"
+	"server/GoUtil"
+	activityCfg "server/conf/activity"
+	"server/game/mod/item"
+)
+
+func (a *Activity) Fire(Id int) ([]*item.Item, error) {
+	AId := activityCfg.GetActivityGiftId(Id)
+	Var := a.getGIftVar(AId)
+	if Var.Buy {
+		return nil, fmt.Errorf("已购买")
+	}
+	Var.Buy = true
+	Var.Time = GoUtil.Now()
+	return activityCfg.GetAcitivityGiftItems(Id), nil
+}

src/server/game/mod/avatar/Avatar.go

@@ -39,6 +39,10 @@ func (a *AvatarMod) InitData() {
 	}
 }
 
+func (a *AvatarMod) GetAvatarNum() int {
+	return len(a.List)
+}
+
 func (a *AvatarMod) SetAvatar(Id int) error {
 	if _, ok := a.List[Id]; !ok {
 		return fmt.Errorf("avatar id not exist")

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

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

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

@@ -14,11 +14,19 @@ import (
 )
 
 const (
-	ModuleName              = "chess"
-	ChessBoradMaxNum        = 63
-	CHESS_SOURCE_CHEST      = 705
-	CHESS_HIGH_SOURCE_CHEST = 706
-	CHESS_SEPARATE          = 707 // 分解器
+	ModuleName                = "chess"
+	ChessBoradMaxNum          = 63
+	CHESS_ENERGY_CHEST        = 562
+	CHESS_SURPRISE_CHEST_LOCK = 563
+	CHESS_SURPRISE_CHEST      = 564
+	CHESS_ZIXUAN_CHEST        = 701 // 自选宝箱
+	CHESS_HIGH_ZIXUAN_CHEST   = 702 // 高级自选宝箱
+	CHESS_TREASURE_CHEST      = 703 // 宝藏宝箱
+	CHESS_HIGH_TREASURE_CHEST = 704 // 高级宝藏宝箱
+	CHESS_SOURCE_CHEST        = 705 // 资源补给箱
+	CHESS_HIGH_SOURCE_CHEST   = 706 // 高级资源补给箱
+	CHESS_SEPARATE            = 707 // 分解器
+	CHESS_UPGRADE             = 708 // 升级器
 )
 
 type ChessBorad struct {
@@ -87,6 +95,10 @@ func (cb *ChessBorad) ver() {
 	}
 }
 
+func (cb *ChessBorad) GetChessBuf() []int {
+	return cb.ChessBuff
+}
+
 // 棋子合成
 func (cb *ChessBorad) ComposeChess(id int) (int, error) {
 	CfgRecord, err := mergeDataCfg.GetOne(id)
@@ -532,3 +544,26 @@ func (cb *ChessBorad) SeparateChess(ChessId int) error {
 	cb.AddChess(NewChess)
 	return nil
 }
+
+func (cb *ChessBorad) UpgradeChess(ChessId int) error {
+	ChessLv := mergeDataCfg.GetLvById(ChessId)
+	ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId)
+	if ChessLv == ChessMaxLv {
+		return errors.New("chess lv is max")
+	}
+	ChessType := mergeDataCfg.GetTypeById(ChessId)
+	if ChessType != "Product" {
+		return errors.New("chess type is not product")
+	}
+	err := cb.RemoveChess(ChessId)
+	if err != nil {
+		return err
+	}
+	err = cb.RemoveChess(CHESS_UPGRADE)
+	if err != nil {
+		return err
+	}
+	NewChess := mergeDataCfg.GetChessIdByLvAndColor(ChessLv+1, mergeDataCfg.GetColorById(ChessId))
+	cb.AddChess(NewChess)
+	return nil
+}

src/server/game/mod/collect/Collect.go

@@ -0,0 +1,86 @@
+package collect
+
+import (
+	"fmt"
+	"server/GoUtil"
+	collectCfg "server/conf/collect"
+	"server/game/mod/item"
+	"server/msg"
+)
+
+type Collect struct {
+	Reward  []int // 已领取记录
+	Jackpot []int // 奖池
+}
+
+type CollectInfo struct {
+	List map[int]int
+}
+
+const (
+	COLLECT_TYPE_EMOJI  = 1
+	COLLECT_TYPE_FACE   = 2
+	COLLECT_TYPE_AVATAR = 3
+)
+
+func (c *Collect) InitData() {
+	c.Reward = make([]int, 0)
+	if len(c.Jackpot) == 0 {
+		c.Jackpot = initJackpot()
+	}
+	if len(c.Jackpot) <= 18 {
+		c.Jackpot = initJackpot2(c.Jackpot)
+	}
+}
+
+func (c *Collect) GetReward(Id, Num int) ([]*item.Item, error) {
+	// 判断是否已领取
+	for _, v := range c.Reward {
+		if v == Id {
+			return nil, fmt.Errorf("已领取")
+		}
+	}
+	Need := collectCfg.GetRewardNeed(Id)
+	if Num < Need {
+		return nil, fmt.Errorf("收集数量不足")
+	}
+	// 领取奖励
+	c.Reward = append(c.Reward, Id)
+	JackpotId := 0
+	JackpotId, c.Jackpot = GoUtil.PopSlice(c.Jackpot)
+	if len(c.Jackpot) <= 18 {
+		c.Jackpot = initJackpot2(c.Jackpot)
+	}
+	Items := collectCfg.GetJackpotItems(JackpotId)
+	// 删除收集记录
+	return Items, nil
+}
+
+func (c *Collect) BackData() *msg.ResCollectInfo {
+	var ItemsMsg []*msg.CollectItem
+	for i := 0; i < 18; i++ {
+		Items := collectCfg.GetJackpotItems(c.Jackpot[i])
+		ItemsMsg = append(ItemsMsg, &msg.CollectItem{
+			Id:    int32(i + 1),
+			Items: item.ItemToMsg(Items),
+		})
+	}
+	return &msg.ResCollectInfo{
+		Id:    GoUtil.IntToInt32(c.Reward),
+		Items: ItemsMsg,
+	}
+}
+
+func initJackpot2(r1 []int) []int {
+	Ids := collectCfg.GetJackpotId()
+	r2 := GoUtil.ShuffleArray(Ids)
+	return append(r1, r2...)
+}
+
+func initJackpot() []int {
+	Ids := collectCfg.GetJackpotId()
+	r1 := GoUtil.ShuffleArray(Ids)
+	r2 := GoUtil.ShuffleArray(Ids)
+	r3 := GoUtil.ShuffleArray(Ids)
+	return append(append(r1, r2...), r3...)
+}

src/server/game/mod/emoji/emoji.go

@@ -26,6 +26,9 @@ const (
 
 func (e *EmojiMod) InitData() {
 	now := GoUtil.Now()
+	if e.Set == nil {
+		e.Set = make(map[int]int)
+	}
 	if e.List == nil {
 		e.List = make(map[int]*Emoji)
 		InitId := emojiCfg.GetInitList()
@@ -34,10 +37,13 @@ func (e *EmojiMod) InitData() {
 				AddTime: now,
 			}
 		}
-
 	}
 }
 
+func (e *EmojiMod) GetEmojiNum() int {
+	return len(e.List)
+}
+
 func (e *EmojiMod) SetEmoji(Id, Type int) error {
 	if Id == 0 {
 		e.Set[Type] = Id
@@ -67,6 +73,11 @@ func (e *EmojiMod) Unlock(Id, Time int) error {
 	return nil
 }
 
+func (e *EmojiMod) GetEmojiSet() map[int32]int32 {
+	return GoUtil.MapIntToInt32(e.Set)
+
+}
+
 func (e *EmojiMod) BackData() []*msg.EmojiInfo {
 	l := make([]*msg.EmojiInfo, 0)
 	for k, v := range e.List {

src/server/game/mod/face/Face.go

@@ -40,6 +40,10 @@ func (f *FaceMod) InitData() {
 	}
 }
 
+func (f *FaceMod) GetFaceNum() int {
+	return len(f.List)
+}
+
 func (f *FaceMod) SetFace(Id int) error {
 	if Id == 0 {
 		f.SetId = Id

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

@@ -1,9 +1,11 @@
 package friend
 
 import (
+	"fmt"
 	"server/GoUtil"
 	cardCfg "server/conf/card"
 	"server/game/mod/card"
+	"server/game/mod/item"
 )
 
 type FriendMod struct {
@@ -30,6 +32,7 @@ const (
 	LOG_TYPE_CARD_EX_SUCCESS_2 = 11 // 卡牌交换成功
 	LOG_TYPE_FRIEND_DELETE     = 14 // 删除好友
 	LOG_TYPE_PLAYROOM_VISIT    = 15 // 拜访玩家
+	LOG_TYPE_HANDBOOK          = 16 // 图鉴收集
 )
 
 const (
@@ -40,11 +43,12 @@ const (
 )
 
 type LogInfo struct {
-	Id    int
-	Uid   int
-	Type  int
-	Time  int64
-	Param string
+	Id     int
+	Uid    int
+	Type   int
+	Time   int64
+	Param  string
+	Upvote bool // 点赞
 }
 
 func (f *FriendMod) InitData() {
@@ -163,3 +167,15 @@ func (f *FriendMod) ResetGoldCardEx() {
 		}
 	}
 }
+
+func (f *FriendMod) Upvote(Id int) ([]*item.Item, error) {
+	info := f.Log[Id]
+	if info == nil {
+		return nil, fmt.Errorf("log not exist")
+	}
+	if info.Upvote {
+		return nil, fmt.Errorf("already upvote")
+	}
+	info.Upvote = true
+	return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, 1)}, nil
+}

src/server/game/mod/handbook/Handbook.go

@@ -2,12 +2,16 @@ package handbook
 
 import (
 	"errors"
+	"fmt"
+	handbookCfg "server/conf/handbook"
 	startMergeCfg "server/conf/startMerge"
+	"server/game/mod/item"
 	"server/msg"
 )
 
 type Handbook struct {
 	BookList map[int]int `json:"BookList"`
+	Collect  map[string]struct{}
 }
 
 const (
@@ -16,6 +20,9 @@ const (
 )
 
 func (h *Handbook) InitData() {
+	if h.Collect == nil {
+		h.Collect = make(map[string]struct{})
+	}
 	if h.BookList == nil {
 		h.BookList = make(map[int]int)
 		InitChess := startMergeCfg.GetInitChessList()
@@ -51,6 +58,18 @@ func (h *Handbook) GetHandbookReward(Id int) error {
 	return nil
 }
 
+func (h *Handbook) CollectItem(Id string) ([]*item.Item, error) {
+	if _, ok := h.Collect[Id]; ok {
+		return nil, fmt.Errorf("已经领取过该奖励")
+	}
+	h.Collect[Id] = struct{}{}
+	Reward := handbookCfg.GetHandbookReward(Id)
+	if Reward == nil {
+		return nil, fmt.Errorf("奖励不存在")
+	}
+	return Reward, nil
+}
+
 func (h *Handbook) BackData() *msg.Handbook {
 	var BookList []*msg.HandbookInfo
 	for k, v := range h.BookList {

src/server/game/mod/msg/Msg.go

@@ -71,6 +71,8 @@ const (
 	FRIEND_TREASURE_HANDLE  //好友宝藏操作
 	HANDLE_TYPE_MAIL_ADD    //添加邮件
 	HANDLE_TYPE_MAIL_RELOAD //重新加载邮件
+
+	HANDLE_TYPE_HANDBOOK_COLLECTION //图鉴收集
 )
 
 const (

src/server/game/mod/msg/data.go

@@ -0,0 +1,5 @@
+package msg
+
+type HandbookMsg struct {
+	Type string
+}

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

@@ -25,6 +25,7 @@ type OrderMod struct {
 	PreheatStep     map[string]int // 预热订单步骤
 	EmitShuffle     []string       // 发射器乱序
 	ChessPool       []int          // 棋子池
+	OrderPool       map[int]*Order // 订单池
 }
 
 type Order struct {
@@ -32,6 +33,8 @@ type Order struct {
 	Diff      int   // 难度
 	Type      int   // 类型
 	Timestamp int64 // 时间戳
+	Q         int
+	S         int
 }
 
 const (
@@ -57,6 +60,9 @@ func (o *OrderMod) InitData() {
 	if o.PreheatStep == nil {
 		o.PreheatStep = make(map[string]int)
 	}
+	if o.OrderPool == nil {
+		o.OrderPool = make(map[int]*Order)
+	}
 	if o.Step == 0 {
 		o.OrderList = make(map[int]Order)
 		Cfg := startOrderCfg.GetStartOrderByStep(o.Step + 1)
@@ -103,6 +109,58 @@ func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
 	}
 	return ItemList, MergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
 }
+func (o *OrderMod) CreateOrderSeed(Order *Order) error {
+	for k, v := range o.OrderPool {
+		if v.Timestamp == Order.Timestamp {
+			delete(o.OrderPool, k)
+			break
+		}
+	}
+	o.addOrder(Order.MergeId, Order.Diff, Common_type)
+	return nil
+}
+
+func (o *OrderMod) CreatOrderPool(lv int, Emit []int, EnergyMul int) error {
+	o.OrderPool = make(map[int]*Order)
+	index := 1
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_LOW)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_MID)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	for i := 0; i < 10; i++ {
+		ChessList := o.CreateNormalOrderSeed(lv, Emit, EnergyMul, DIFF_HIGH)
+		if len(ChessList) == 0 {
+			continue
+		}
+		o.OrderPool[index] = &Order{
+			MergeId:   ChessList,
+			Diff:      DIFF_LOW,
+			Timestamp: int64(index),
+		}
+		index++
+	}
+	return nil
+}
 
 // 生成新订单
 func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
@@ -215,6 +273,39 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
 	return false
 }
 
+// 生成新订单
+func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff int) []int {
+	if len(Emit) == 0 {
+		return nil
+	}
+	randNum := 0
+	mergeList := make([]int, 0)
+	var err error
+	for {
+		if randNum > 50 {
+			break
+		}
+		randNum++
+		mergeList, _, err = randOrderChessSeed(o, lv, Emit, EnergyMul, Diff)
+		if err != nil {
+			continue
+		}
+		lastMergelist := o.LastNormalOrder.MergeId
+		conbine := false
+		for _, v := range mergeList {
+			if GoUtil.InArray(v, lastMergelist) {
+				conbine = true
+				break
+			}
+		}
+		if conbine {
+			continue
+		}
+		break
+	}
+	return mergeList
+}
+
 // 生成新订单
 func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {
@@ -447,23 +538,23 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
 			o.addOrder([]int{ChessId}, DIFF_LOW, Preheat_type)
 		}
 	}
-	//额外订单补充2；当玩家的棋盘中出现三个相同的满级产物时，立刻生成一个对应的收购订单；
-	for k := range MaxLvChess {
-		ChessNum := GoUtil.GetElemNum(ChessList, k)
-		OrderChess := 0
-		for _, order := range o.OrderList {
-			for _, v := range order.MergeId {
-				if v == k {
-					OrderChess++
-				}
-			}
-		}
-		OrderNum := (ChessNum - OrderChess) / 3
-		for i := 0; i < OrderNum; i++ {
-			b1 = true
-			o.addOrder([]int{k, k, k}, DIFF_LOW, Extra_type)
-		}
-	}
+	// //额外订单补充2；当玩家的棋盘中出现三个相同的满级产物时，立刻生成一个对应的收购订单；
+	// for k := range MaxLvChess {
+	// 	ChessNum := GoUtil.GetElemNum(ChessList, k)
+	// 	OrderChess := 0
+	// 	for _, order := range o.OrderList {
+	// 		for _, v := range order.MergeId {
+	// 			if v == k {
+	// 				OrderChess++
+	// 			}
+	// 		}
+	// 	}
+	// 	OrderNum := (ChessNum - OrderChess) / 3
+	// 	for i := 0; i < OrderNum; i++ {
+	// 		b1 = true
+	// 		o.addOrder([]int{k, k, k}, DIFF_LOW, Extra_type)
+	// 	}
+	// }
 	return b1
 }
 

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

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

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

@@ -49,6 +49,8 @@ const (
 	MOOD_TYPE_ENTER = 1 // 娱乐
 	MOOD_TYPE_FOOD  = 2 // 食物
 	MOOD_TYPE_CLEAN = 3 // 清洁
+	MOOD_TYPE_TAKE  = 4 // 照料
+	MOOD_TYPE_PLAY  = 5 // 玩耍
 
 	GAME_RESULT_LOW    = 1 // 低
 	GAME_RESULT_MIDDLE = 2 // 中
@@ -515,7 +517,7 @@ func (p *PlayroomMod) UnLock(Lv int) {
 	}
 	if len(p.MoodInfo) == 0 {
 		p.MoodInfo = make(map[int]*Mood)
-		for k := 1; k <= 3; k++ {
+		for k := 1; k <= 5; k++ {
 			p.MoodInfo[k] = &Mood{Id: k, Num: 100}
 		}
 	}

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

@@ -19,6 +19,11 @@ const (
 	TRIGGER_LABEL_FINISHORDER = "FinishOrder"
 	TRIGGER_LABEL_ENERGY      = "Energy"
 	TRIGGER_LABEL_MERGETIME   = "MergeTime"
+	TRIGGER_LABEL_STOKECAT    = "StokeCat"
+	TRIGGER_LABEL_TAKECAT     = "TakeCat"
+	TRIGGER_LABEL_PLAYCAT     = "PlayCat"
+	TRIGGER_LABEL_FEEDCAT     = "FeedCat"
+	TRIGGER_LABEL_CLEANCAT    = "CleanCat"
 )
 
 type QuestProgress struct {

src/server/gamedata/reader.go

@@ -129,6 +129,23 @@ func GetIntValue(a interface{}, key string) int {
 	return 0
 }
 
+func GetIntSliceValue(a interface{}, key string) []int {
+	if a == nil {
+		return nil
+	}
+	if v, ok := a.(map[string]interface{})[key]; ok {
+		if v == nil {
+			return nil
+		}
+		var r []int
+		for _, v := range v.([]interface{}) {
+			r = append(r, int(v.(float64)))
+		}
+		return r
+	}
+	return nil
+}
+
 func GetFloatValue(a interface{}, key string) float64 {
 	if a == nil {
 		return 0

src/server/gamedata/type.go

@@ -44,6 +44,7 @@ type ActivityData struct {
 	StartTime int64
 	EndTime   int64
 	Type      int
+	AType     int
 	Name      string
 	Title     string
 	Mail      string

src/server/pkg/github.com/name5566/leaf/leaf.go

@@ -8,6 +8,7 @@ import (
 	"server/game"
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/cluster"
+	"server/pkg/github.com/name5566/leaf/conf"
 	"server/pkg/github.com/name5566/leaf/console"
 	"server/pkg/github.com/name5566/leaf/log"
 	"server/pkg/github.com/name5566/leaf/module"
@@ -15,18 +16,18 @@ import (
 )
 
 func Run(mods ...module.Module) {
-	// logger
-	// if conf.LogLevel != "" {
-	// 	if _, err := os.Stat(conf.LogPath); os.IsNotExist(err) {
-	// 		os.Mkdir(conf.LogPath, os.ModePerm)
-	// 	}
-	// 	logger, err := log.New(conf.LogLevel, conf.LogPath, conf.LogFlag)
-	// 	if err != nil {
-	// 		panic(err)
-	// 	}
-	// 	log.Export(logger)
-	// 	defer logger.Close()
-	// }
+	//logger
+	if conf.LogLevel != "" {
+		if _, err := os.Stat(conf.LogPath); os.IsNotExist(err) {
+			os.Mkdir(conf.LogPath, os.ModePerm)
+		}
+		logger, err := log.New(conf.LogLevel, conf.LogPath, conf.LogFlag)
+		if err != nil {
+			panic(err)
+		}
+		log.Export(logger)
+		defer logger.Close()
+	}
 	log.Release("服务器版本: %s", "1.0.02")
 	log.Release("%s 启动, 节点类型: %s, 区服id: %d", sconf.Server.GameName, sconf.Server.ServerType, sconf.Server.ServerID)