Merge branch 'sdk' into online

src/server/cluster/cluster_type.go

@@ -1,15 +1,5 @@
 package mergeCluster
 
-import (
-	"encoding/gob"
-	"server/game/mod/msg"
-)
-
-func init() {
-	gob.Register(&msg.Msg{})
-	gob.Register(&ClusterJoinData{})
-}
-
 type ClusterJoinData struct {
 	ServerId   int
 	Country    int

src/server/conf/notification/notification_cfg.go

@@ -0,0 +1,43 @@
+package notification_cfg
+
+import "server/gamedata"
+
+const (
+	CFG_NOTIFICATION = "Notification"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_NOTIFICATION)
+}
+
+func GetFriendApplyNotificationCooldown() int {
+	data, err := gamedata.GetDataByIntKey(CFG_NOTIFICATION, 2)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Cooldown")
+}
+
+func GetPetroomGameNotificationCooldown() (int, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_NOTIFICATION, 1)
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data, "Cooldown"), gamedata.GetIntValue(data, "DailyLimit")
+}
+
+func GetPetroomGameNotificationMsg() (string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_NOTIFICATION, 1)
+	if err != nil {
+		return "", ""
+	}
+	return gamedata.GetStringValue(data, "TitleKey"), gamedata.GetStringValue(data, "InfoKey")
+}
+
+func GetFriendApplyNotificationMsg() (string, string) {
+	data, err := gamedata.GetDataByIntKey(CFG_NOTIFICATION, 2)
+	if err != nil {
+		return "", ""
+	}
+	return gamedata.GetStringValue(data, "TitleKey"), gamedata.GetStringValue(data, "InfoKey")
+}

src/server/game/GameLogic.go

@@ -473,7 +473,7 @@ func G_getGameLogic() *GameLogic {
 		G_GameLogicPtr.RegisterNetWorkFunc() // 注册客户端接口
 		G_GameLogicPtr.InitActivity()        // 初始化活动
 		if conf.Server.ServerType == "center" {
-			G_GameLogicPtr.CreateFriendMgr()    //创建好友管理器
+			// G_GameLogicPtr.CreateFriendMgr()    //创建好友管理器
 			G_GameLogicPtr.CreateChampshipMgr() // 创建竞标赛管理器
 			G_GameLogicPtr.CreateVarMgr()       // 创建变量管理器
 		}
@@ -877,9 +877,10 @@ func (ad *GameLogic) GetStartTime() int64 {
 }
 
 func NotifyPlayer(Uid int, m *MsgMod.Msg) {
-	m.To = Uid
+	clone := *m
-	m.HandleType = MsgMod.HANDLE_MOD_PLAYER_MSG
+	clone.To = Uid
-	NotifyPlayerMsgAsync(m)
+	clone.HandleType = MsgMod.HANDLE_MOD_PLAYER_MSG
+	NotifyPlayerMsgAsync(&clone)
 }
 
 func Destroy() {

src/server/game/activity_func.go

@@ -19,23 +19,14 @@ import (
 // 活动模块 登录
 func (p *Player) ActivityLogin() {
 	ItemMod := p.PlayMod.getItemMod()
-	// 挖矿
+
-	ActivityId := p.GetActivityId(activity.ACT_TYPE_MINING)
+	// 通用登录处理：检查旧Activity道具并通过邮件退还
-	MiningMod := p.PlayMod.getMiningMod()
+	handleSimpleLogin := func(actType int, loginFn func(int) int) {
-	OldId := MiningMod.Login(ActivityId)
+		ActivityId := p.GetActivityId(actType)
-	if OldId != 0 {
+		OldId := loginFn(ActivityId)
-		ItemId := guesscolorCfg.GetActivityItemId(OldId)
+		if OldId == 0 {
-		ItemNum := ItemMod.GetItem(ItemId)
+			return
-		if ItemNum != 0 {
-			ItemMod.AddItem(ItemId, -ItemNum)
-			p.SendActivityMail(ItemId, ItemNum, ActivityId, nil)
 		}
-	}
-	// 猜颜色
-	ActivityId = p.GetActivityId(activity.ACT_TYPE_GUESS_COLOR)
-	GuessColorMod := p.PlayMod.getGuessColorMod()
-	OldId = GuessColorMod.Login(ActivityId)
-	if OldId != 0 {
 		ItemId := guesscolorCfg.GetActivityItemId(OldId)
 		ItemNum := ItemMod.GetItem(ItemId)
 		if ItemNum != 0 {
@@ -44,22 +35,16 @@ func (p *Player) ActivityLogin() {
 		}
 	}
 
+	// 挖矿
+	handleSimpleLogin(activity.ACT_TYPE_MINING, p.PlayMod.getMiningMod().Login)
+	// 猜颜色
+	handleSimpleLogin(activity.ACT_TYPE_GUESS_COLOR, p.PlayMod.getGuessColorMod().Login)
 	// 赛跑
-	ActivityId = p.GetActivityId(activity.ACT_TYPE_RACE)
+	handleSimpleLogin(activity.ACT_TYPE_RACE, p.PlayMod.getRaceMod().Login)
-	RaceMod := p.PlayMod.getRaceMod()
-	OldId = RaceMod.Login(ActivityId)
-	if OldId != 0 {
-		ItemId := guesscolorCfg.GetActivityItemId(OldId)
-		ItemNum := ItemMod.GetItem(ItemId)
-		if ItemNum != 0 {
-			ItemMod.AddItem(ItemId, -ItemNum)
-			p.SendActivityMail(ItemId, ItemNum, ActivityId, nil)
-		}
-	}
 	// 猫草大作战
-	ActivityId = p.GetActivityId(activity.ACT_TYPE_CATNIP)
+	CatnipActivityId := p.GetActivityId(activity.ACT_TYPE_CATNIP)
 	CatnipMod := p.PlayMod.getCatnipMod()
-	OldId, CatnipUnReward := CatnipMod.Login(ActivityId)
+	OldId, CatnipUnReward := CatnipMod.Login(CatnipActivityId)
 	if OldId != 0 && len(CatnipUnReward) > 0 {
 		// 清空猫草大作战数据无需发邮件
 		MailMod := p.PlayMod.getMailMod()
@@ -78,16 +63,16 @@ func (p *Player) ActivityLogin() {
 	}
 
 	// 通行证
-	ActivityId = p.GetActivityId(activity.ACT_TYPE_PASS)
+	PassActivityId := p.GetActivityId(activity.ACT_TYPE_PASS)
 	PassMod := p.PlayMod.getPassMod()
-	OldId = PassMod.Login(ActivityId)
+	PassOldId := PassMod.Login(PassActivityId)
-	if OldId != 0 {
+	if PassOldId != 0 {
-		ItemId := passCfg.GetActivityItemId(OldId)
+		ItemId := passCfg.GetActivityItemId(PassOldId)
 		ItemNum := PassMod.Num
 		RewardItems, _ := PassMod.GetRewardItems()
 		if ItemNum != 0 {
 			ItemMod.AddItem(ItemId, -ItemNum)
-			p.SendActivityMail(ItemId, ItemNum, ActivityId, RewardItems)
+			p.SendActivityMail(ItemId, ItemNum, PassActivityId, RewardItems)
 		}
 	}
 }
@@ -104,9 +89,9 @@ func (p *Player) SendActivityMail(ItemId, ItemNum, ActivityId int, RewardItems [
 	mc_zh := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_CN, mail_content_key)
 	mt_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_title_key)
 	mc_en := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_EN, mail_content_key)
-	mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, activity_title_key)
+	mt_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_title_key)
 	mc_pt := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_PTBR, mail_content_key)
-	mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, activity_title_key)
+	mt_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_title_key)
 	mc_es := languageCfg.GetLanguage(msg.LANG_TYPE_LANG_ES_LATAM, mail_content_key)
 	Items := []*item.Item{item.NewItem(ItemId, ItemNum)}
 	Items = append(Items, RewardItems...)
@@ -127,30 +112,22 @@ func (p *Player) SendActivityMail(ItemId, ItemNum, ActivityId int, RewardItems [
 // 活动模块 零点更新
 func (p *Player) ActivityZeroUpdate() {
 	p.ActivityLogin()
-	ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_MINING)
+
-	if ActivityInfo != nil {
+	type zeroHandler struct {
-		MiningMod := p.PlayMod.getMiningMod()
+		actType  int
-		MiningMod.ZeroUpdate(ActivityInfo.Id)
+		updateFn func(int)
 	}
-	ActivityInfo = p.GetActivityInfo(activity.ACT_TYPE_GUESS_COLOR)
+	handlers := []zeroHandler{
-	if ActivityInfo != nil {
+		{activity.ACT_TYPE_MINING, func(id int) { p.PlayMod.getMiningMod().ZeroUpdate(id) }},
-		GuessColorMod := p.PlayMod.getGuessColorMod()
+		{activity.ACT_TYPE_GUESS_COLOR, func(id int) { p.PlayMod.getGuessColorMod().ZeroUpdate(id) }},
-		GuessColorMod.ZeroUpdate(ActivityInfo.Id)
+		{activity.ACT_TYPE_RACE, func(id int) { p.PlayMod.getRaceMod().ZeroUpdate(id) }},
+		{activity.ACT_TYPE_PASS, func(id int) { p.PlayMod.getPassMod().ZeroUpdate(id) }},
+		{activity.ACT_TYPE_CATNIP, func(id int) { p.PlayMod.getCatnipMod().ZeroUpdate(id) }},
 	}
-	ActivityInfo = p.GetActivityInfo(activity.ACT_TYPE_RACE)
+	for _, h := range handlers {
-	if ActivityInfo != nil {
+		if info := p.GetActivityInfo(h.actType); info != nil {
-		RaceMod := p.PlayMod.getRaceMod()
+			h.updateFn(info.Id)
-		RaceMod.ZeroUpdate(ActivityInfo.Id)
+		}
-	}
-	ActivityInfo = p.GetActivityInfo(activity.ACT_TYPE_PASS)
-	if ActivityInfo != nil {
-		PassMod := p.PlayMod.getPassMod()
-		PassMod.ZeroUpdate(ActivityInfo.Id)
-	}
-	ActivityInfo = p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
-	if ActivityInfo != nil {
-		CatnipMod := p.PlayMod.getCatnipMod()
-		CatnipMod.ZeroUpdate(ActivityInfo.Id)
 	}
 }
 
@@ -320,12 +297,18 @@ func (p *Player) ActPassBackData() {
 // 获取活动道具
 func (p *Player) GetActivityItem(ActType []int) []*item.Item {
 	Items := make([]*item.Item, 0)
+	Now := GoUtil.Now()
 	for _, v := range ActType {
-		Status := p.GetActivityStatus(v)
 		ActivityInfo := p.GetActivityInfo(v)
 		if ActivityInfo == nil {
 			continue
 		}
+		Status := ACT_STATUS_START
+		if Now < ActivityInfo.StartT {
+			Status = ACT_STATUS_NOT_START
+		} else if Now > ActivityInfo.EndT {
+			Status = ACT_STATUS_END
+		}
 		if Status != ACT_STATUS_START {
 			continue
 		}
@@ -351,7 +334,7 @@ func (p *Player) GetActivityItem(ActType []int) []*item.Item {
 
 // 猫草大作战活动数据返回
 func (p *Player) CatnipBackData() {
-	ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
+	ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_CATNIP)
 	if ActivityInfo == nil {
 		return
 	}

src/server/game/champship_mgr.go

@@ -110,6 +110,7 @@ func (c *ChampshipMgr) NotifyAll() (interface{}, error) {
 	NotifyAllPlayerMsg(&msg.Msg{
 		Type:       msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
 		HandleType: msg.HANDLE_MOD_PLAYER_MSG,
+		End:        GoUtil.Now() + onehour,
 	})
 	return nil, nil
 }
@@ -234,11 +235,12 @@ func (c *ChampshipMgr) ai() (interface{}, error) {
 		}
 		ChampshipData.Rank[k] = v
 	}
-
+	now := GoUtil.Now()
 	// 在锁外通知玩家，避免在持锁时启动 goroutine 访问可能被并发修改的数据
 	for uid := range uids {
 		go NotifyPlayer(uid, &msg.Msg{
 			Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+			End:  now + onehour,
 		})
 	}
 
@@ -461,6 +463,7 @@ func (c *ChampshipMgr) group() (interface{}, error) {
 	for _, uid := range notifyList {
 		go NotifyPlayer(uid, &msg.Msg{
 			Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+			End:  GoUtil.Now() + onehour,
 		})
 	}
 	return nil, nil
@@ -552,6 +555,7 @@ func (c *ChampshipMgr) inRank(m *msg.Msg) (interface{}, error) {
 	for _, uid := range notifyList {
 		go NotifyPlayer(uid, &msg.Msg{
 			Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
+			End:  GoUtil.Now() + onehour,
 		})
 	}
 	return nil, nil

src/server/game/charge_func.go

@@ -85,22 +85,20 @@ func (p *Player) ActivityFire(ChargeId int) {
 }
 
 func (p *Player) PassFire(ChargeId int) {
-	ActivityStatus := p.GetActivityStatus(activity.ACT_TYPE_PASS)
-	if ActivityStatus != ACT_STATUS_START {
-		return
-	}
 	ActivityInfo := p.GetActivityInfo(activity.ACT_TYPE_PASS)
 	if ActivityInfo == nil {
 		return
 	}
-	LowChargeId := passCfg.GetLowChargeId(ActivityInfo.Id)
+	Now := GoUtil.Now()
-	PassMod := p.PlayMod.getPassMod()
+	if Now < ActivityInfo.StartT || Now > ActivityInfo.EndT {
-	Items := []*item.Item{}
+		return
-	if ChargeId == LowChargeId {
-		Items = PassMod.GetLowChargeItems()
 	}
-	HighChargeId := passCfg.GetHighChargeId(ActivityInfo.Id)
+	PassMod := p.PlayMod.getPassMod()
-	if ChargeId == HighChargeId {
+	var Items []*item.Item
+	switch ChargeId {
+	case passCfg.GetLowChargeId(ActivityInfo.Id):
+		Items = PassMod.GetLowChargeItems()
+	case passCfg.GetHighChargeId(ActivityInfo.Id):
 		Items = PassMod.GetHighChargeItems()
 	}
 	if len(Items) == 0 {
@@ -122,7 +120,7 @@ func (p *Player) PlayroomFire(ChargeId int) {
 	}
 	err := p.HandleItem(Item, proto.ITEM_POP_LABEL_Playroom.String())
 	if err != nil {
-		log.Debug("ChargeFire err : %s", err)
+		log.Debug("PlayroomFire err : %s", err)
 	}
 	p.TeLog("get_assist_battery", map[string]interface{}{
 		"assist_battery _type": "charge",
@@ -138,7 +136,7 @@ func (p *Player) PiggyBankFire(ChargeId int) {
 	}
 	err := p.HandleItem(Item, proto.ITEM_POP_LABEL_PiggyBank.String())
 	if err != nil {
-		log.Debug("ChargeFire err : %s", err)
+		log.Debug("PiggyBankFire err : %s", err)
 	}
 	p.LimitedTimePiggyBankTrigger()
 	p.TeLog("piggy_bank_open", map[string]interface{}{
@@ -171,7 +169,7 @@ func (p *Player) ChargeItem(ChargeId int) []*item.Item {
 	return Item
 }
 
-// 处理玩家充值
+// 处理无尽礼包充值
 func (p *Player) EndlessFire(ChargeId int) {
 	EndlessMod := p.PlayMod.getEndlessMod()
 	Item := EndlessMod.Fire(ChargeId)
@@ -180,7 +178,7 @@ func (p *Player) EndlessFire(ChargeId int) {
 	}
 	err := p.HandleItem(Item, proto.ITEM_POP_LABEL_Endless.String())
 	if err != nil {
-		log.Debug("ChargeFire err : %s", err)
+		log.Debug("EndlessFire err : %s", err)
 	}
 	p.PlayMod.save()
 	p.PushClientRes(EndlessMod.BackData())
@@ -230,7 +228,7 @@ func (p *Player) GoogleVerify(OrderSn, ProduceId, Token string) (*db.SqlChargeOr
 	outputStr := string(output)
 
 	// 替换单引号为双引号
-	outputStr = strings.Replace(outputStr, "'", "\"", -1)
+	outputStr = strings.ReplaceAll(outputStr, "'", "\"")
 	type VerifyData struct {
 		PurchaseState    int    `json:"purchaseState"`
 		DeveloperPayload string `json:"developerPayload"`
@@ -268,9 +266,5 @@ func (p *Player) CancelOrder(OrderSn string) error {
 		return fmt.Errorf("订单已支付")
 	}
 	Order.PayStatus = MergeConst.ORDER_STATUS_CANCEL
-	err = db.UpdatePlayerChargeData(Order)
+	return db.UpdatePlayerChargeData(Order)
-	if err != nil {
-		return err
-	}
-	return nil
 }

src/server/game/common.go

@@ -13,16 +13,20 @@ const (
 	CHESS_MODULE     = "chess"
 )
 
+const (
+	onehour   = 3600
+	oneday    = 24 * onehour
+	sevendays = 7 * oneday
+)
+
 // 解析参数
 func ParseArgs(args []interface{}) (gate.Agent, *Player, []byte) {
 	a := args[0].(gate.Agent)
 	p, _ := internal.Agents.Load(a)
-	player := p.(*Player)
+	return a, p.(*Player), args[1].([]byte)
-	buf := args[1].([]byte)
-	return a, player, buf
 }
 
-// 解析参数
+// 解析管理员参数
 func ParseAdminArgs(args []interface{}) (gate.Agent, []byte) {
 	a := args[0].(gate.Agent)
 	buf := args[1].([]byte)
@@ -41,22 +45,22 @@ func GetStructName(v interface{}) string {
 	return ""
 }
 
-// 判断两个切片的元素是否一致
+// 判断两个切片的元素是否一致（忽略顺序）
 func SlicesEqual(a, b []int) bool {
 	if len(a) != len(b) {
 		return false
 	}
-
 	// 创建副本以避免修改原始切片
 	aCopy := make([]int, len(a))
 	bCopy := make([]int, len(b))
 	copy(aCopy, a)
 	copy(bCopy, b)
-
-	// 对切片进行排序
 	sort.Ints(aCopy)
 	sort.Ints(bCopy)
-
+	for i := range aCopy {
-	// 比较排序后的切片
+		if aCopy[i] != bCopy[i] {
-	return reflect.DeepEqual(aCopy, bCopy)
+			return false
+		}
+	}
+	return true
 }

src/server/game/external.go

@@ -35,6 +35,7 @@ func RegisterHandlerRPC(param []interface{}) {
 }
 
 func init() {
+	register()
 	db.InitDB()
 	db.InitRedis()
 	// db.TestGetAllKey()
@@ -208,8 +209,10 @@ func HandleClientReq(args []interface{}) {
 			backup := p.(*Player).BackUp() // 备份当前的 Player 值
 			defer func() {
 				if r := recover(); r != nil {
-					log.Error("uid : %d, func : %s, fatal : %s", p.(*Player).M_DwUin, m.GetFunc(), r)
+					if m.GetFunc() != "ReqGmCommand" { // 如果不是 GM 命令，才记录日志和发送飞书告警
-					GoUtil.SendFeishuFatal(int(p.(*Player).M_DwUin), m.GetFunc(), fmt.Sprintf("fatal : %s", r))
+						log.Error("uid : %d, func : %s, fatal : %s", p.(*Player).M_DwUin, m.GetFunc(), r)
+						GoUtil.SendFeishuFatal(int(p.(*Player).M_DwUin), m.GetFunc(), fmt.Sprintf("fatal : %s", r))
+					}
 					p.(*Player).Recover(backup) //还原Player的数据
 				}
 				p.(*Player).lock.Unlock() //解锁

src/server/game/friend_func.go

@@ -44,19 +44,19 @@ func (p *Player) GetVisitorPlayer() int {
 	}
 	if len(PlayerList) != 0 {
 		sort.Slice(PlayerList, func(i, j int) bool {
-			return PlayerList[i].Time < PlayerList[j].Time
+			return PlayerList[i].Time > PlayerList[j].Time
 		})
 		return PlayerList[0].Uid
 	}
 	if len(PlayerList2) != 0 {
 		sort.Slice(PlayerList2, func(i, j int) bool {
-			return PlayerList2[i].Time < PlayerList2[j].Time
+			return PlayerList2[i].Time > PlayerList2[j].Time
 		})
 		return PlayerList2[0].Uid
 	}
 	// 若不存在符合条件的用户，则选择24小时内登入过游戏且上次登入时间与当前时间最近的好友
 	var recentFriendUid int
-	var recentLoginTime int64 = 0
+	var recentLoginTime int64
 	for uid := range FriendMod.GetFriendList() {
 		if uid == int(p.M_DwUin) {
 			continue
@@ -83,13 +83,12 @@ func (p *Player) GetVisitorPlayer() int {
 	if err != nil {
 		return 0
 	}
-	PlayerList4 := make([]int, 0)
+	var PlayerList4 []int
 	for _, Uid := range uids {
 		if Uid == int(p.M_DwUin) {
 			continue
 		}
-		PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
+		if G_GameLogicPtr.GetSimplePlayerByUid(Uid) == nil {
-		if PlayerSimpleData == nil {
 			continue
 		}
 		PlayerList4 = append(PlayerList4, Uid)
@@ -172,10 +171,7 @@ func GetRecommendPlayer(p *Player, Num int) []int {
 	diffLimit := 10
 	filtered := make([]int, 0, len(baseList))
 	breakNum := 100
-	for {
+	for breakNum > 0 {
-		if breakNum <= 0 {
-			break
-		}
 		breakNum--
 		filtered = filtered[:0]
 		for _, ps := range baseList {
@@ -190,7 +186,7 @@ func GetRecommendPlayer(p *Player, Num int) []int {
 				filtered = append(filtered, ps.Uid)
 			}
 		}
-		if len(filtered) >= 5 || len(baseList) == 0 {
+		if len(filtered) >= 5 {
 			break
 		}
 		diffLimit++

src/server/game/friend_mgr.go

@@ -1,13 +1,9 @@
 package game
 
 import (
-	"encoding/gob"
 	"fmt"
 	mergeCluster "server/cluster"
 	"server/conf"
-	"server/game/mod/card"
-	"server/game/mod/friend"
-	"server/game/mod/item"
 	"server/game/mod/msg"
 	GoUtil "server/game_util"
 	"server/pkg/github.com/name5566/leaf/log"
@@ -24,10 +20,6 @@ type FirendData struct {
 }
 
 func (f *FriendMgr) Init() {
-	gob.Register(card.CardInfo{})
-	gob.Register(item.Item{})
-	gob.Register([]*item.Item{}) // 注册 []*item.Item 类型
-	gob.Register(friend.ReplyInfo{})
 	f.key = FRIEND_MGR_KEY
 	f.data = &FirendData{
 		List:       make(map[int][]*msg.Msg),
@@ -98,7 +90,7 @@ func (f *FriendMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
 	Now := GoUtil.Now()
 	for k, v := range f.getData().List {
 		for j, msg := range v {
-			if msg.End < Now-7*24*3600 {
+			if msg.End < Now-sevendays {
 				f.getData().List[k] = append(f.getData().List[k][:j], f.getData().List[k][j+1:]...)
 			}
 		}

src/server/game/game_type.go

@@ -2,6 +2,8 @@ package game
 
 import (
 	"encoding/gob"
+	mergeCluster "server/cluster"
+	"server/game/mod/activity"
 	"server/game/mod/card"
 	"server/game/mod/friend"
 	"server/game/mod/item"
@@ -35,6 +37,8 @@ type PlayerSimpleData struct {
 	CardInfo    []int
 	ActLog      *friend.ActLogInfo
 	Physiology  map[int]int
+	Lang        int
+	Account     string
 }
 
 type VarGoldCard struct {
@@ -113,9 +117,15 @@ type CatnipLock struct {
 	End     int
 }
 
-func init() {
+func register() {
+	gob.Register(card.CardInfo{})
+	gob.Register(item.Item{})
+	gob.Register(friend.ReplyInfo{})
+	gob.Register(&msg.Msg{})
+	gob.Register(&mergeCluster.ClusterJoinData{})
 	gob.Register(&limitedTimeEvent.MoneyCat{})
 	gob.Register(&limitedTimeEvent.LuckyCat{})
+	gob.Register(&limitedTimeEvent.PaybackDay{})
 	gob.Register(&msg.HandbookMsg{})
 	gob.Register(&limitedTimeEvent.CatTrick{})
 	gob.Register(&limitedTimeEvent.PaybackDay{})
@@ -133,4 +143,11 @@ func init() {
 	gob.Register([]*item.Item{}) // 注册 []*item.Item 类型
 	gob.Register(friend.ReplyInfo{})
 	gob.Register(GameResult{})
+	gob.Register(map[string]interface{}{})
+	gob.Register(&MessageData{})
+	gob.Register(&MessageList{})
+	gob.Register(&activity.Gift{})
+	gob.Register(&VarGoldCard{})
+	gob.Register(&VarExpireData{})
+	gob.Register(msg.VarData{})
 }

src/server/game/gm_handler.go

@@ -11,7 +11,9 @@ import (
 	chargeCfg "server/conf/charge"
 	emojiCfg "server/conf/emoji"
 	faceCfg "server/conf/face"
+	languageCfg "server/conf/language"
 	mergeDataCfg "server/conf/merge_data"
+	notification_cfg "server/conf/notification"
 	playroomCfg "server/conf/playroom"
 	"server/db"
 	"server/game/mod/activity"
@@ -599,22 +601,27 @@ func ReqGmCommand_(player *Player, Command string) error {
 		player.PushClientRes(LimitedTimeEventMod.BackData())
 	case "resetTriggerMail":
 		player.PlayMod.mod_list.Mail.TriggerMail = make([]int, 0, 8)
-	case "debugMsg":
+	case "notification":
-		to, _ := strconv.Atoi(arg[1])
+		Id, _ := strconv.Atoi(arg[1])
-		num, _ := strconv.Atoi(arg[1])
+		NotifyFriendApply(Id, int(player.M_DwUin))
-		for i := 0; i < num; i++ {
+		NotifyPetroomGame(Id)
-			uid := 100100000 + i
+	case "notificationTest":
-			if uid == int(player.M_DwUin) {
+		Id, _ := strconv.Atoi(arg[1])
-				continue
+		PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Id)
-			}
+		if PlayerSimpleData == nil {
-			SendMsgToCenterAsync(&MsgMod.Msg{
+			return nil
-				From:       uid,
-				To:         to,
-				Type:       MsgMod.HANDLE_TYPE_APPLY,
-				SendT:      GoUtil.Now(),
-				HandleType: MsgMod.HANDLE_MOD_PLAYER_MSG,
-			})
 		}
+		titlekey, infokey := notification_cfg.GetFriendApplyNotificationMsg()
+		title := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), titlekey)
+		info := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), infokey)
+		BaseMod := player.PlayMod.getBaseMod()
+		GoUtil.NotifyPlayer(GoUtil.Int(PlayerSimpleData.Account), 1, title, fmt.Sprintf(info, BaseMod.NickName))
+
+		titlekey, infokey = notification_cfg.GetPetroomGameNotificationMsg()
+		title = languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), titlekey)
+		info = languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), infokey)
+		GoUtil.NotifyPlayer(GoUtil.Int(PlayerSimpleData.Account), NOTIFY_TYPE_PETROOM_GAME, fmt.Sprintf(title, PlayerSimpleData.PetName), fmt.Sprintf(info, PlayerSimpleData.PetName))
+
 	default:
 		return fmt.Errorf("Player %d ReqGmCommand:%v not found", player.M_DwUin, arg)
 	}

src/server/game/limited_time_trigger.go

@@ -8,7 +8,7 @@ import (
 	"server/game/mod/card"
 	"server/game/mod/item"
 	limitedTimeEvent "server/game/mod/limited_time_event"
-	MsgMod "server/game/mod/msg" // Ensure this package exists and is correctly referenced
+	MsgMod "server/game/mod/msg"
 	"server/game/mod/playroom"
 	GoUtil "server/game_util"
 	"server/msg"
@@ -20,7 +20,11 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
 	Lv := p.GetPlayerBaseMod().GetLevel()
 	EndTime, TimeoutEvent, AddEvent := p.PlayMod.getLimitedTimeEventMod().Trigger(Lv)
 	remainingTime := GoUtil.NextHourRemain()
-	EndTime = GoUtil.IfTrue(EndTime > 0, min(EndTime, int(remainingTime)), int(remainingTime)).(int)
+	if EndTime <= 0 {
+		EndTime = int(remainingTime)
+	} else {
+		EndTime = min(EndTime, int(remainingTime))
+	}
 	if AddEventId != 0 {
 		AddEvent = append(AddEvent, AddEventId)
 	}
@@ -42,16 +46,14 @@ func (p *Player) LimitedTimeEventTrigger(AddEventId int) {
 		case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
 			BaseMod := p.PlayMod.getBaseMod()
 			EnergyMul := BaseMod.GetEnergyMul()
-			NewEnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
 			OrderMod := p.PlayMod.getOrderMod()
-			Lv := p.GetPlayerBaseMod().GetLevel()
 			Emit := p.PlayMod.getChessMod().GetOrderEmit()
 			ChessList := p.PlayMod.getChessMod().GetUnlockChessList()
-			OrderMod.ChangeEnergyMul(Lv, Emit, NewEnergyMul, ChessList)
+			OrderMod.ChangeEnergyMul(Lv, Emit, EnergyMul, ChessList)
 			p.PushClientRes(OrderMod.BackData())
 			p.TeLog("mutil_merge_change", map[string]interface{}{
 				"change_from": math.Pow(2, float64(EnergyMul)),
-				"change_to":   math.Pow(2, float64(NewEnergyMul)),
+				"change_to":   math.Pow(2, float64(EnergyMul)),
 				"is_auto":     true,
 			})
 			p.PushClientRes(p.PlayMod.getBaseMod().BackData())
@@ -110,18 +112,18 @@ func (p *Player) LimitedTimeCardTrigger() {
 	FriendMod := p.PlayMod.getFriendMod()
 	CardMod := p.PlayMod.getCardMod()
 	Now := GoUtil.Now()
-	EndTime := int64(0)
+	var EndTime int64
 	for k, v := range FriendMod.Card {
 		if v.EndTime > 0 && v.EndTime <= Now {
-			if v.Status == card.STATUS_CARD_EX_1 {
+			switch v.Status {
+			case card.STATUS_CARD_EX_1:
 				delete(FriendMod.Card, k)
 				FriendMgrSend(&MsgMod.Msg{
 					From: v.BUid,
 					To:   v.AUid,
 					Type: MsgMod.HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT,
 				})
-			}
+			case card.STATUS_CARD_EX_2:
-			if v.Status == card.STATUS_CARD_EX_2 {
 				delete(FriendMod.Card, k)
 				FriendMgrSend(&MsgMod.Msg{
 					From: v.AUid,
@@ -133,8 +135,11 @@ func (p *Player) LimitedTimeCardTrigger() {
 				p.PushClientRes(CardMod.NotifyTimes())
 				p.PushClientRes(CardMod.NotifyCard())
 			}
+			continue
+		}
+		if v.EndTime > 0 && (EndTime == 0 || v.EndTime < EndTime) {
+			EndTime = v.EndTime
 		}
-		EndTime = min(EndTime, v.EndTime)
 	}
 	if EndTime > 0 {
 		p.CallEvent(time.Duration(EndTime-Now)*time.Second, func() {
@@ -170,7 +175,6 @@ func (p *Player) LimitedTimePlayroomTrigger_(Id int) {
 	if Id == playroom.PHYSIOLOGY_TYPE_TOLIET && Num == 0 && CleanMood.Num > 50 {
 		CleanMood.Num = 50
 	}
-	// log.Debug("PlayroomTrigger Id:%d, Time:%d, Num:%d, NewTime:%d, NextSecond:%d, MType:%d, MEffect:%d, Num :%d", Id, Physiology.Time, Physiology.Num, NewTime, NextSecond, MType, MEffect, Num)
 	Physiology.Num = Num
 	if PlayroomMod.GetMoodInfo(MType).Num == 0 { // 心情值为0时，重置生理状态
 		PlayroomMod.ResetPhysiology(MType)
@@ -199,10 +203,7 @@ func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
 		return Time, int64(NeedDuration), Num
 	}
 	n := 0
-	for {
+	for n <= 100 {
-		if n > 100 {
-			return 0, 0, 0
-		}
 		Num--
 		NeedDuration := playroomCfg.GetPhysiologyDuration(Id, Num)
 		Time += int64(NeedDuration)
@@ -214,6 +215,7 @@ func PlayroomTrigger(Id int, Time int64, Num int) (int64, int64, int) {
 		}
 		n++
 	}
+	return 0, 0, 0
 }
 
 func LimitedTimePlayroomWorkTrigger(p *Player) {
@@ -227,7 +229,7 @@ func LimitedTimePlayroomWorkTrigger(p *Player) {
 		p.SendClientRes()
 		return
 	}
-	NextSecond := EndTime - GoUtil.Now()
+	NextSecond := EndTime - Now
 	if NextSecond > 0 {
 		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
 			p.lock.Lock()

src/server/game/message_handler.go

@@ -53,7 +53,7 @@ func (p *Player) HandleMsg(m *msg.Msg) {
 		p.ProcessTrigger()
 		p.SendClientRes()
 	} else {
-		p.Msg = make([]PlayerMsg, 0)
+		p.Msg = nil
 	}
 }
 
@@ -134,7 +134,7 @@ func (p *Player) handle(m *msg.Msg) error {
 		p.NoonUpdate(nil)
 	case msg.HANDLE_TYPE_INVITE_ADD_FRIEND: // 邀请添加好友
 		FriendMod := p.PlayMod.getFriendMod()
-		if m.From == 0 && m.From == int(p.M_DwUin) {
+		if m.From == 0 || m.From == int(p.M_DwUin) {
 			return nil
 		}
 		FriendMod.AddFriend(m.From)
@@ -205,11 +205,9 @@ func (p *Player) handle(m *msg.Msg) error {
 		}
 		for k, v := range OtherUid { // 通知好友请求已结束
 			v.Status = card.STATUS_CARD_GIVE_3
-			msg := &msg.Msg{Type: msg.HANDLE_TYPE_REG_CARD_FINISH, From: k, Extra: &v}
+			FriendMgrSend(&msg.Msg{Type: msg.HANDLE_TYPE_REG_CARD_FINISH, From: k, Extra: &v})
-			FriendMgrSend(msg)
 			CardMod.DelRequestCard(k)
 		}
-		// p.AddLog(int(p.M_DwUin), friend.LOG_TYPE_CARD_ACCEPT_GIVE, fmt.Sprintf("%d", CardInfo.CardId))
 		p.PlayMod.save()
 		p.PushClientRes(
 			&proto.NotifyFriendCard{
@@ -249,7 +247,6 @@ func (p *Player) handle(m *msg.Msg) error {
 			return nil
 		}
 		FriendMod.SetCardInfo(&CardInfo)
-		// p.AddLog(int(p.M_DwUin), friend.LOG_TYPE_CARD_SELECT_GET, fmt.Sprintf("%d", CardInfo.CardId))
 		p.PlayMod.save()
 		p.PushClientRes(
 			&proto.NotifyFriendCard{
@@ -300,8 +297,8 @@ func (p *Player) handle(m *msg.Msg) error {
 	case msg.HANDLE_TYPE_CHAMPSHIP_RESULT: // #  好友锦标赛结果
 		Extra := GoUtil.IntSlice(m.Extra)
 		p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_CHAMPSHIP, fmt.Sprintf("%d_%d", Extra[0], Extra[1]), m.SendT)
-	case msg.HANDLE_TYPE_TREASURE_RESULT: // #  好友宝藏结果
+	case msg.HANDLE_TYPE_TREASURE_RESULT: // 好友宝藏结果
-		//p.AddLog(m.From, friend.LOG_TYPE_TREASURE, fmt.Sprintf("%d", m.Extra.(int)), m.SendT)
+		// 暂未处理
 	case msg.HANDLE_TYPE_MAIL: // 邮件操作
 		SyncMailMsg(p)
 	case msg.HANDLE_TYPE_PLAYROOM_LOSE: // #  玩家输了
@@ -328,7 +325,7 @@ func (p *Player) handle(m *msg.Msg) error {
 		PlayroomMod.AddMood(playroom.MOOD_TYPE_CLEAN, -50)
 		PlayroomMod.AddVisitor(m.From, m.SendT)
 
-		if len(Items) > 0 && Items[0].Id == item.ITEM_STAR_ID {
+		if Items[0].Id == item.ITEM_STAR_ID {
 			BaseMod := p.PlayMod.getBaseMod()
 			StarNum := BaseMod.GetStar()
 			Items[0].Num = min(Items[0].Num, StarNum)
@@ -359,7 +356,7 @@ func (p *Player) handle(m *msg.Msg) error {
 		p.AddLog(m.From, friend.LOG_TYPE_TREASURE_HELP, "", m.SendT)
 		p.HandleItem(Items, proto.ITEM_POP_LABEL_Friendtreasure.String())
 	case msg.HANDLE_TYPE_HANDBOOK_COLLECTION: // 图鉴收集奖励
-		if m.Extra != nil {
+		if m.Extra == nil {
 			return nil
 		}
 		data, ok := m.Extra.(msg.HandbookMsg)
@@ -517,7 +514,7 @@ func (p *Player) handle(m *msg.Msg) error {
 	case msg.HANDLE_TYPE_FRIEND_GREETING_REPLY:
 		FriendMod := p.PlayMod.getFriendMod()
 		if v, ok := m.Extra.(friend.ReplyInfo); ok {
-			FriendMod.AddReplyInfo(v.Uid, v.Type, v.Param, GoUtil.Now()+24*3600, nil)
+			FriendMod.AddReplyInfo(v.Uid, v.Type, v.Param, GoUtil.Now()+oneday, nil)
 			p.FriendLogBackData()
 		}
 	case msg.HANDLE_TYPE_FRIEND_SPONSOER:
@@ -527,7 +524,6 @@ func (p *Player) handle(m *msg.Msg) error {
 	default:
 		log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
 	}
-	// #region 以下是处理系统请求
 	return nil
 }
 
@@ -623,7 +619,7 @@ func GetCardInfoMsg(CardInfo *card.CardInfo) *proto.ResFriendCard {
 func (p *Player) EmitRetireTrigger1() {
 	ChessMod := p.PlayMod.getChessMod()
 	EmitList := ChessMod.GetEmitList()
-	EmitId := make(map[string]struct{}, 0)
+	EmitId := make(map[string]struct{})
 	for _, v := range EmitList {
 		Emit_Id := mergeDataCfg.GetEmitId(v)
 		if Emit_Id == "" {
@@ -631,7 +627,7 @@ func (p *Player) EmitRetireTrigger1() {
 		}
 		EmitId[Emit_Id] = struct{}{}
 	}
-	EmitId1 := make([]string, 0)
+	var EmitId1 []string
 	for k := range EmitId {
 		EmitId1 = append(EmitId1, k)
 	}
@@ -655,7 +651,7 @@ func (p *Player) EmitRetireTrigger2() {
 	OrderMod := p.PlayMod.getOrderMod()
 	BaseMod := p.PlayMod.getBaseMod()
 	OrderList := OrderMod.GetOrderList()
-	AllChess := make(map[string]struct{}, 0)
+	AllChess := make(map[string]struct{})
 	for _, v := range OrderList {
 		for _, v1 := range v.MergeId {
 			Color := mergeDataCfg.GetColorById(v1)
@@ -720,13 +716,19 @@ func NotifyChampshipResult(Uid, Rank int) {
 	if PlayerSimpleData == nil {
 		return
 	}
+	now := GoUtil.Now()
+	serveropenday := GoUtil.GetServerOpenDay()
 	for _, v := range PlayerSimpleData.Friend {
+		if CheckPlayerLose(v) {
+			continue
+		}
 		SendPlayerMsgAsync(&msg.Msg{
 			Type:  msg.HANDLE_TYPE_CHAMPSHIP_RESULT,
 			From:  Uid,
 			To:    v,
-			SendT: GoUtil.Now(),
+			SendT: now,
-			Extra: []int{Rank, GoUtil.GetServerOpenDay()},
+			End:   now + sevendays,
+			Extra: []int{Rank, serveropenday},
 		})
 	}
 }
@@ -958,7 +960,7 @@ func (player *Player) CreatePetOrder() {
 			if v.Type != order.Pet_type {
 				continue
 			}
-			Items := make([]*item.Item, 0)
+			var Items []*item.Item
 			Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
 			// Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
 			Items = player.GetPetOrderReward(Star, Items)
@@ -995,10 +997,9 @@ func (player *Player) CreateNormalOrder() {
 				if v.Type != order.COMFORT_TYPE {
 					continue
 				}
-				Items := make([]*item.Item, 0)
 				Star := order.GetOrderStar(v.MergeId, ChessMod.GetOrderEmit())
 				Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
-				v.Items = append(Items, &item.Item{Id: item.ITEM_STAR_ID, Num: Star})
+				v.Items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: Star}}
 				OrderMod.OrderList[k] = v
 			}
 		}
@@ -1021,7 +1022,7 @@ func (player *Player) CreateNormalOrder() {
 			if v.Type != order.Pet_type {
 				continue
 			}
-			Items := make([]*item.Item, 0)
+			var Items []*item.Item
 			Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
 			// Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
 			Items = player.GetPetOrderReward(Star, Items)
@@ -1076,10 +1077,9 @@ func (player *Player) InitOrderItem() {
 		if len(v.Items) != 0 {
 			continue
 		}
-		Items := make([]*item.Item, 0)
 		Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
 		Star = int(float64(Star)*float64(OrderFactor)/1000+0.5) * 10
-		v.Items = append(Items, &item.Item{Id: item.ITEM_STAR_ID, Num: Star})
+		v.Items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: Star}}
 		OrderMod.OrderList[k] = v
 	}
 }
@@ -1129,7 +1129,7 @@ func (p *Player) GetPlayroomGameReward(Type, SelectId int) []*item.Item {
 	PlayroomMod := p.PlayMod.getPlayroomMod()
 	BaseMod := p.PlayMod.getBaseMod()
 	Level := BaseMod.GetLevel()
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
 	switch Type {
 	case playroom.GAME_RESULT_LOSE:
 		Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 20))
@@ -1149,8 +1149,8 @@ func (p *Player) GetPetThiefReward(Target int) error {
 		return fmt.Errorf("target %d not exist", Target)
 	}
 	CardStar := limitedTimeEventCfg.GetThiefProb()
-	starMap := make(map[int][]int, 0)
+	starMap := make(map[int][]int)
-	cardList := []int{}
+	var cardList []int
 	for _, v := range PlayerData.CardInfo {
 		Star := cardCfg.GetStarById(v)
 		starMap[Star] = append(starMap[Star], v)
@@ -1200,10 +1200,10 @@ func (p *Player) AddHighOrder() {
 	NewColor := mergeDataCfg.GetColorById(NewChess)
 	LastEmitId := order.GetEmitByColor(ChessMod.GetOrderEmit(), LastColor)
 	AddNewEmitId := order.GetEmitByColor(ChessMod.GetOrderEmit(), NewColor)
-	Product := []string{}
+	var Product []string
 	Product = append(Product, mergeDataCfg.GetEmitProduceType(LastEmitId)...)
 	Product = append(Product, mergeDataCfg.GetEmitProduceType(AddNewEmitId)...)
-	ChessMap := make(map[string]int, 0)
+	ChessMap := make(map[string]int)
 	ChessList := ChessMod.GetUnlockChessList()
 	for _, v := range ChessList {
 		ChessType := mergeDataCfg.GetTypeById(v)
@@ -1250,7 +1250,7 @@ func (p *Player) AddHighOrder2() {
 	OrderMod := p.PlayMod.getOrderMod()
 	ChessMod := p.PlayMod.getChessMod()
 	ChessList := ChessMod.GetUnlockChessList()
-	ChessMap := make(map[int]int, 0)
+	ChessMap := make(map[int]int)
 	for _, v := range ChessList {
 		Lv := mergeDataCfg.GetLvById(v)
 		MaxLv := mergeDataCfg.GetMaxLvById(v)
@@ -1282,7 +1282,7 @@ func (p *Player) AddHighOrder2() {
 }
 
 func (p *Player) FormatPetOrderItem(Items []*item.Item) []*item.Item {
-	NewItems := make([]*item.Item, 0)
+	var NewItems []*item.Item
 	PlayroomMod := p.PlayMod.getPlayroomMod()
 	for _, v := range Items {
 		if v.Id != item.ITEM_PLAYROOM_BOX_LOW_ID && v.Id != item.ITEM_PLAYROOM_BOX_MID_ID && v.Id != item.ITEM_PLAYROOM_BOX_HIGH_ID {
@@ -1315,7 +1315,7 @@ func (p *Player) FormatPetOrderItem(Items []*item.Item) []*item.Item {
 			NewItems = append(NewItems, item.NewItem(GoUtil.RandSlice(RandList), 1))
 			continue
 		}
-		RandList := make([]int, 0)
+		var RandList []int
 		for k, v1 := range OrderItem {
 			if k == 1 || k == 2 {
 				continue

src/server/game/message_mgr.go

@@ -2,18 +2,12 @@ package game
 
 import (
 	"context"
-	"encoding/gob"
 	"fmt"
 	"runtime/debug"
 	mergeCluster "server/cluster"
 	"server/conf"
-	"server/game/mod/card"
-	"server/game/mod/friend"
-	"server/game/mod/item"
-	limitedTimeEvent "server/game/mod/limited_time_event"
 	"server/game/mod/msg"
 	GoUtil "server/game_util"
-	proto "server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"sync"
 	"time"
@@ -92,26 +86,7 @@ func (m *MessageMgr) MessageMgrInit() {
 		MessageList: make(map[int64]*MessageList),
 		PlayerList:  make(map[int64]int),
 	}
-	// 注册所有可能在消息中使用的类型
+
-	gob.Register(&limitedTimeEvent.MoneyCat{})
-	gob.Register(&limitedTimeEvent.LuckyCat{})
-	gob.Register(&msg.HandbookMsg{})
-	gob.Register(&limitedTimeEvent.CatTrick{})
-	gob.Register(&VarOpration{})
-	gob.Register(&VarUserData{})
-	gob.Register(&ActivityInfo{})
-	gob.Register(&ChargeExtra{})
-	gob.Register(CatnipMsg{})
-	gob.Register(&CatnipLock{})
-	gob.Register(CRank{})
-	gob.Register(&proto.ResChampshipRank{})
-	gob.Register(&proto.ResChampshipPreRank{})
-	gob.Register(card.CardInfo{})
-	gob.Register(item.Item{})
-	gob.Register([]*item.Item{}) // 注册 []*item.Item 类型
-	gob.Register(friend.ReplyInfo{})
-	gob.Register(msg.VarData{})
-	gob.Register(GameResult{})
 	// 注册处理函数
 	m.init()
 	m.handler = make(map[int]MessageHandlerFunc)
@@ -138,12 +113,17 @@ func FixBug() {
 			delete(messageMgrData.MessageList, k)
 			continue
 		}
+		isLose := CheckPlayerLose(int(k))
 		// 反向遍历以安全删除元素
 		for i := len(v.Messages) - 1; i >= 0; i-- {
 			if v.Messages[i].Type == msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY || (v.Messages[i].End != 0 && v.Messages[i].End < now) {
 				// 删除消息
 				v.Messages = append(v.Messages[:i], v.Messages[i+1:]...)
 			}
+			if isLose && v.Messages[i].Type == msg.HANDLE_TYPE_CHAMPSHIP_RESULT {
+				// 删除消息
+				v.Messages = append(v.Messages[:i], v.Messages[i+1:]...)
+			}
 		}
 		if len(v.Messages) == 0 {
 			delete(messageMgrData.MessageList, k)
@@ -219,11 +199,11 @@ func NotifyAllPlayerMsg(m *msg.Msg) {
 		playerListCopy[k] = v
 	}
 	messageMgrData.mu.Unlock()
-
 	// 在锁外发送消息
 	for PlayerId, node := range playerListCopy {
-		m.To = int(PlayerId)
+		copym := m.Clone()
-		SendMsgToNodeAsync(m, node)
+		copym.To = int(PlayerId)
+		SendMsgToNodeAsync(copym, node)
 	}
 }
 
@@ -382,10 +362,22 @@ func CenterPlayerMsgHandler(data *msg.Msg) (interface{}, error) {
 		SendMsgToNodeAsync(data, node)
 	} else {
 		// 不在线则存储消息
+		applycount := 0
 		if !GoUtil.InArray(data.Type, notify_msg_type) {
 			messages := getMessge(PlayerId)
 			messages.mu.Lock()
 			messages.Messages = append(messages.Messages, data)
+			for _, msgItem := range messages.Messages {
+				if msgItem == nil {
+					continue
+				}
+				if msgItem.Type == msg.HANDLE_TYPE_APPLY {
+					applycount++
+				}
+			}
+			if applycount > 1 && data.Type == msg.HANDLE_TYPE_APPLY {
+				go NotifyFriendApply(data.To, data.From)
+			}
 			messages.mu.Unlock()
 		}
 	}
@@ -891,6 +883,8 @@ func saveMessage(m *msg.Msg) error {
 	messages := getMessgeUnsafe(int64(m.To))
 	messages.mu.Lock()
 	defer messages.mu.Unlock()
+	now := GoUtil.Now()
+	applycount := 0
 	for _, msgItem := range messages.Messages {
 		if msgItem == nil {
 			continue
@@ -899,9 +893,17 @@ func saveMessage(m *msg.Msg) error {
 			// 已存在相同消息，直接返回
 			return nil
 		}
+		if msgItem.End != 0 && msgItem.End < now {
+			// 删除过期消息
+			messages.Messages = append(messages.Messages[:0], messages.Messages[1:]...)
+		}
+		if msgItem.Type == msg.HANDLE_TYPE_APPLY {
+			applycount++
+		}
+	}
+	if applycount > 1 && m.Type == msg.HANDLE_TYPE_APPLY {
+		go NotifyFriendApply(m.To, m.From)
 	}
-	// 添加消息
-	messages.Messages = append(messages.Messages, m)
 	// 添加消息
 	messages.Messages = append(messages.Messages, m)
 	// 设置上限为2000条，超过则丢弃最早的消息

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

@@ -1,7 +1,6 @@
 package activity
 
 import (
-	"encoding/gob"
 	"fmt"
 	activityCfg "server/conf/activity"
 	"server/game/mod/item"
@@ -43,67 +42,60 @@ type Gift struct {
 	RewardTime int64
 }
 
-func init() {
-	gob.Register(&Gift{})
-}
-
 func (a *Activity) InitData() {
 	if a.Var == nil {
 		a.Var = make(map[int]interface{}, 8)
 	}
 }
 
+// 获取活动数据
 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)
+func (a *Activity) getGiftVar(key int) *Gift {
-	if Var == nil {
+	if v, ok := a.Var[key].(*Gift); ok {
-		Var = &Gift{}
+		return v
-		a.SetVar(key, Var)
-		return Var.(*Gift)
-	}
-	gift, ok := Var.(*Gift)
-	if !ok {
-		// 类型不匹配，重置为新的 Gift 对象
-		gift = &Gift{}
-		a.SetVar(key, gift)
 	}
+	// nil 或类型不匹配，重置为新的 Gift 对象
+	gift := &Gift{}
+	a.Var[key] = gift
 	return gift
 }
 
+// 获取活动状态
 func (a *Activity) GetActivityStatus(data *gamedata.ActivityData) int {
-	if data.AType == ACT_ATYPE_NORMAL {
+	switch data.AType {
+	case ACT_ATYPE_NORMAL:
 		return ACT_STATUS_START
-	}
+	case ACT_ATYPE_LIMIT_GIFT:
-
+		v := a.getGiftVar(data.Id)
-	if data.AType == ACT_ATYPE_LIMIT_GIFT {
-		Var := a.getGIftVar(data.Id)
 		switch data.Type {
 		case ACT_TYPE_ADD_GIFT, ACT_TYPE_SUPER_GIFT:
-			if Var.Reward {
+			if v.Reward {
 				return ACT_STATUS_NOT_START
 			}
-			if Var.Buy {
+			if v.Buy {
 				return ACT_STATUS_END
 			}
 		default:
-			if Var.Buy {
+			if v.Buy {
 				return ACT_STATUS_NOT_START
 			}
 		}
 	}
-
 	return ACT_STATUS_START
 }
 
+// 活动礼包-获取奖励
 func (a *Activity) GetReward(ActId int) ([]*item.Item, error) {
-	Var := a.getGIftVar(ActId)
+	Var := a.getGiftVar(ActId)
 	if !Var.Buy {
 		return nil, fmt.Errorf("ActId:%d not buy", ActId)
 	}

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

@@ -7,9 +7,10 @@ import (
 	GoUtil "server/game_util"
 )
 
+// 活动礼包
 func (a *Activity) Fire(Id int) ([]*item.Item, error) {
 	AId := activityCfg.GetActivityGiftId(Id)
-	Var := a.getGIftVar(AId)
+	Var := a.getGiftVar(AId)
 	if Var.Buy {
 		return nil, fmt.Errorf("Id%d已购买", Id)
 	}

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

@@ -113,6 +113,10 @@ func (c *CardMod) InitData() {
 	}
 }
 
+/*
+*
+卡牌系统-登录：赛季结束则重置
+*/
 func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
 	Now := GoUtil.Now()
 	Duration := cardCfg.GetCardDuration()
@@ -124,7 +128,6 @@ func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
 		c.AllCollect = 0
 		c.EndTime = 0
 		c.Round = 0
-		c.Handbook = make(map[int]int)
 		for k, v := range c.Handbook {
 			if v == HANDBOOK_STATUS_GET {
 				continue
@@ -135,6 +138,7 @@ func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
 			}
 			HandbookItemNum += cardCfg.GetStarById(k)
 		}
+		c.Handbook = make(map[int]int)
 	}
 	if c.EndTime == 0 {
 		c.EndTime = ((Now-ServerOpenTime)/Duration+1)*Duration + ServerOpenTime
@@ -142,6 +146,7 @@ func (c *CardMod) Login(ServerOpenTime int64) []*item.Item {
 	return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: HandbookItemNum}}
 }
 
+// 零点更新
 func (c *CardMod) ZeroUpdate(ServerOpenTime int64) []*item.Item {
 	c.ReqTimes = cardCfg.GetReqTimes()
 	c.ExTimes = cardCfg.GetExTimes()
@@ -215,6 +220,28 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
 	return newCard, nil
 }
 
+// cleanExpired 清理过期的请求和交换记录，返回有效 uid 列表
+func (c *CardMod) cleanExpired() (reqUid, exUid []int64) {
+	Now := GoUtil.Now()
+	reqUid = make([]int64, 0, len(c.ReqFriend))
+	for k, v := range c.ReqFriend {
+		if v.EndTime < Now {
+			delete(c.ReqFriend, k)
+			continue
+		}
+		reqUid = append(reqUid, int64(k))
+	}
+	exUid = make([]int64, 0, len(c.ExCard))
+	for k, v := range c.ExCard {
+		if v.EndTime < Now {
+			delete(c.ExCard, k)
+			continue
+		}
+		exUid = append(exUid, int64(k))
+	}
+	return
+}
+
 // 协议返回
 func (c *CardMod) BackData() *msg.ResCardInfo {
 	var cardList []*msg.Card
@@ -224,22 +251,7 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
 		}
 		cardList = append(cardList, &msg.Card{Id: int32(k), Count: int32(v)})
 	}
-	ReqUid := make([]int64, 0, len(c.ReqFriend))
+	ReqUid, ExUid := c.cleanExpired()
-	for _, v := range c.ReqFriend {
-		if v.EndTime < GoUtil.Now() {
-			delete(c.ReqFriend, v.BUid)
-			continue
-		}
-		ReqUid = append(ReqUid, int64(v.BUid))
-	}
-	ExUid := make([]int64, 0, len(c.ExCard))
-	for k, v := range c.ExCard {
-		if v.EndTime < GoUtil.Now() {
-			delete(c.ExCard, k)
-			continue
-		}
-		ExUid = append(ExUid, int64(k))
-	}
 
 	if c.EndTime < GoUtil.Now() {
 		log.Debug("CardMod BackData EndTime < Now, reset card data")
@@ -419,17 +431,16 @@ func (c *CardMod) AddExTimes(CardInfo *CardInfo) {
 
 // 交换卡牌
 func (c *CardMod) ExchangeCard(From, To, CardId int) (*CardInfo, error) {
-	Now := GoUtil.Now()
-	Id := GoUtil.CreateCardId(From, To, CardId)
-	err := c.SubCard(CardId)
 	if c.ExTimes <= 0 {
 		return nil, fmt.Errorf("ExchangeCard times not enough, CardId: %d", CardId)
 	}
-	c.ExTimes--
+	err := c.SubCard(CardId)
 	if err != nil {
 		return nil, err
 	}
-
+	c.ExTimes--
+	Now := GoUtil.Now()
+	Id := GoUtil.CreateCardId(From, To, CardId)
 	CardInfo := &CardInfo{
 		Id:        Id,
 		AUid:      From,
@@ -445,16 +456,16 @@ func (c *CardMod) ExchangeCard(From, To, CardId int) (*CardInfo, error) {
 }
 
 func (c *CardMod) SendCard(From, To, CardId int) (*CardInfo, error) {
-	Now := GoUtil.Now()
-	Id := GoUtil.CreateCardId(From, To, CardId)
-	err := c.SubCard(CardId)
 	if c.ExTimes <= 0 {
 		return nil, fmt.Errorf("SendCard times not enough, CardId: %d", CardId)
 	}
-	c.ExTimes--
+	err := c.SubCard(CardId)
 	if err != nil {
 		return nil, err
 	}
+	c.ExTimes--
+	Now := GoUtil.Now()
+	Id := GoUtil.CreateCardId(From, To, CardId)
 	CardInfo := &CardInfo{
 		Id:        Id,
 		AUid:      From,
@@ -501,36 +512,19 @@ func (c *CardMod) NotifyCard() *msg.ResNotifyCard {
 		Card:     make(map[int]int),
 		Master:   make(map[int]int),
 		Handbook: make(map[int]int),
-		ExStar:   0,
 	}
 	return m
 }
 
 func (c *CardMod) NotifyTimes() *msg.ResNotifyCardTimes {
-	ReqUid := make([]int64, 0, len(c.ReqFriend))
+	ReqUid, ExUid := c.cleanExpired()
-	for k, v := range c.ReqFriend {
+	return &msg.ResNotifyCardTimes{
-		if v.EndTime < GoUtil.Now() {
-			delete(c.ReqFriend, k)
-			continue
-		}
-		ReqUid = append(ReqUid, int64(k))
-	}
-	ExUid := make([]int64, 0, len(c.ExCard))
-	for k, v := range c.ExCard {
-		if v.EndTime < GoUtil.Now() {
-			delete(c.ExCard, k)
-			continue
-		}
-		ExUid = append(ExUid, int64(k))
-	}
-	m := &msg.ResNotifyCardTimes{
 		ExTimes:   int32(c.ExTimes),
 		ReqTimes:  int32(c.ReqTimes),
 		ExUid:     ExUid,
 		ReqUid:    ReqUid,
 		GoldTimes: int32(c.GoldTimes),
 	}
-	return m
 }
 
 func (c *CardMod) ResetGoldCardEx() {

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

@@ -5,6 +5,7 @@ import (
 	GoUtil "server/game_util"
 )
 
+// 随机卡牌
 func randCard(Round, Star, IsGold int, Except []int) int {
 	cardList := cardCfg.GetCardListByStar(Round, Star, IsGold)
 	cardList = GoUtil.SubSlices(cardList, Except)
@@ -12,6 +13,7 @@ func randCard(Round, Star, IsGold int, Except []int) int {
 	return cardId
 }
 
+// 排位赛金卡
 func RankGoldCard() (int, int) {
 	Card1 := randCard(0, 4, 1, []int{})
 	Card2 := randCard(0, 5, 1, []int{Card1})

src/server/game/mod/catnip/Catnip.go

@@ -39,8 +39,6 @@ const (
 )
 
 func (c *CatnipMod) InitData() {
-	// Initialize Catnip data here
-	// c.Game = nil
 	if c.Game == nil {
 		c.Game = make(map[int]*CatnipGame)
 	}
@@ -52,6 +50,7 @@ func (c *CatnipMod) InitData() {
 	}
 }
 
+// 登录 判断是否需要重置数据
 func (c *CatnipMod) Login(Id int) (int, []*item.Item) {
 	OldId := c.Id
 	if Id == 0 {
@@ -77,13 +76,14 @@ func (c *CatnipMod) Login(Id int) (int, []*item.Item) {
 			Status:   GAME_STATUS_IDLE, // Not started
 		}
 	}
-	return c.Id, Items
+	return OldId, Items
 }
 
 func (c *CatnipMod) ZeroUpdate(Id int) {
 	c.Login(Id)
 }
 
+// 邀请好友
 func (c *CatnipMod) Invite(Uid, Id int) error {
 	if c.InviteList[Uid] != nil {
 		return fmt.Errorf("user with ID %d is already invited", Uid)
@@ -96,6 +96,7 @@ func (c *CatnipMod) Invite(Uid, Id int) error {
 	return nil
 }
 
+// 被邀请
 func (c *CatnipMod) BeInvited(Uid int, Time int64) error {
 	// Check if the user is already invited
 	invite := c.BeInvitedList[Uid]
@@ -109,63 +110,66 @@ func (c *CatnipMod) BeInvited(Uid int, Time int64) error {
 	return nil
 }
 
+// 同意邀请
 func (c *CatnipMod) Agree(Id, Uid int) ([]int, error) {
 	_, exists := c.BeInvitedList[Uid]
 	if !exists {
 		return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
 	}
-	// Remove the invite after agreeing
-
 	delete(c.BeInvitedList, Uid)
 	for _, GameInfo := range c.Game {
 		if GameInfo.Partner == 0 {
 			GameInfo.Partner = Uid
 			GameInfo.Status = GAME_STATUS_IN_PROGRESS
-			return []int{}, nil
+			return nil, nil
 		}
 	}
-	return []int{}, nil
+	return nil, nil
 }
 
+// 同意邀请-指定格子
 func (c *CatnipMod) BeAgree(Id, Uid int) ([]int, error) {
 	info, exists := c.InviteList[Uid]
 	if !exists {
 		return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
 	}
-	// Remove the invite after agreeing
+	delete(c.InviteList, Uid)
 	GameInfo := c.Game[info.InviteId]
 	if GameInfo.Partner == 0 {
 		GameInfo.Partner = Uid
 		GameInfo.Status = GAME_STATUS_IN_PROGRESS
-		delete(c.InviteList, Uid)
+		return nil, nil
-		return []int{}, nil
 	}
-	delete(c.InviteList, Uid)
+	// 目标格子已有伙伴，分配到第一个空闲格
 	for _, GameInfo := range c.Game {
 		if GameInfo.Partner == 0 {
 			GameInfo.Partner = Uid
 			GameInfo.Status = GAME_STATUS_IN_PROGRESS
-			return []int{}, nil
+			return nil, nil
 		}
 	}
-	return []int{}, nil
+	return nil, nil
 }
 
+// 删除邀请
 func (c *CatnipMod) DelInvited(Id, Uid int) error {
 	delete(c.InviteList, Uid)
 	return nil
 }
 
+// 设置倍数
 func (c *CatnipMod) Multiply(Mul int) error {
 	c.Mul = Mul
 	return nil
 }
 
+// 拒绝邀请
 func (c *CatnipMod) Refuse(Id, Uid int) error {
 	delete(c.BeInvitedList, Uid)
 	return nil
 }
 
+// 玩游戏
 func (c *CatnipMod) Play(Id int) (int, int, int, []*item.Item, []*item.Item, int, error) {
 	GameInfo, ok := c.Game[Id]
 	if !ok {
@@ -184,6 +188,7 @@ func (c *CatnipMod) Play(Id int) (int, int, int, []*item.Item, []*item.Item, int
 	return Id, Growth, GameInfo.Partner, Items, ItemCost, FriendItems, nil
 }
 
+// 领取奖励
 func (c *CatnipMod) Reward(Id int) ([]*item.Item, *CatnipGame, error) {
 	GameInfo, ok := c.Game[Id]
 	if !ok {
@@ -201,6 +206,7 @@ func (c *CatnipMod) Reward(Id int) ([]*item.Item, *CatnipGame, error) {
 	return Items, GameInfo, nil
 }
 
+// 领取大奖励
 func (c *CatnipMod) GrandReward() ([]*item.Item, error) {
 	for _, game := range c.Game {
 		if game.Status != GAME_STATUS_COMPLETED {
@@ -214,6 +220,7 @@ func (c *CatnipMod) GrandReward() ([]*item.Item, error) {
 	return catnipCfg.GetGrandReward(c.Id), nil
 }
 
+// 进度增加
 func (c *CatnipMod) Growth(Id, Growth int) {
 	GameInfo, ok := c.Game[Id]
 	if !ok {
@@ -223,17 +230,18 @@ func (c *CatnipMod) Growth(Id, Growth int) {
 		return // Game is not in progress
 	}
 	GameInfo.Progress += Growth
-	if GameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) { // Assuming the game ends when progress reaches a certain threshold
+	if GameInfo.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
 		GameInfo.Status = GAME_STATUS_COMPLETED
 	}
 }
 
+// 伙伴贡献增加
 func (c *CatnipMod) GrowthByUid(Uid, Growth int) {
 	for _, v := range c.Game {
 		if v.Partner == Uid {
 			v.Progress += Growth
 			v.PartnerAdd += Growth
-			if v.Progress >= catnipCfg.GetGameMaxProgress(c.Id) { // Assuming the game ends when progress reaches a certain threshold
+			if v.Progress >= catnipCfg.GetGameMaxProgress(c.Id) {
 				v.Status = GAME_STATUS_COMPLETED
 			}
 		}
@@ -241,6 +249,7 @@ func (c *CatnipMod) GrowthByUid(Uid, Growth int) {
 
 }
 
+// 设置表情
 func (c *CatnipMod) SetEmoji(Uid, EmojiId int) {
 	for _, v := range c.Game {
 		if v.Partner == Uid {
@@ -262,6 +271,7 @@ func (c *CatnipMod) SetSendEmoji(Id, EmojiId int) {
 	c.Game[Id].SendEmoji = EmojiId
 }
 
+// 获取未领取的奖励
 func (c *CatnipMod) GetUnGetReward() []*item.Item {
 	var rewards []*item.Item
 	for _, v := range c.Game {

src/server/game/mod/champship/Champship.go

@@ -19,6 +19,11 @@ type ChampshipMod struct {
 
 func (c *ChampshipMod) InitData() {}
 
+// isActive 判断当前是否在冠军赛活跃时段（零点后 30 分钟内为结算期，不计分）
+func (c *ChampshipMod) isActive() bool {
+	return GoUtil.Now()-GoUtil.ZeroTimestamp() >= 1800
+}
+
 func (c *ChampshipMod) ZeroUpdate() {
 	c.PreMax = c.Reward
 	c.Score = 0
@@ -39,8 +44,7 @@ func (c *ChampshipMod) GetRankReward(Rank int) ([]*item.Item, error) {
 }
 
 func (c *ChampshipMod) AddScore(Chess []int) {
-	Status := GoUtil.IfTrue(GoUtil.Now()-GoUtil.ZeroTimestamp() < 1800, 0, 1)
+	if !c.isActive() {
-	if Status.(int) == 0 {
 		return
 	}
 	score := 0
@@ -60,23 +64,24 @@ func (c *ChampshipMod) GetReward() []*item.Item {
 }
 
 func (c *ChampshipMod) BackData(MyRank, MyPreRank int) *msg.ResChampship {
-	RankReward := 0
+	rankReward := 0
 	if c.RankReward {
-		RankReward = 2
+		rankReward = 2
-	} else {
+	} else if MyPreRank > 0 {
-		if MyPreRank > 0 {
+		rankReward = 1
-			RankReward = 1
+	}
-		}
+	status := 0
+	if c.isActive() {
+		status = 1
 	}
-	Status := GoUtil.IfTrue(GoUtil.Now()-GoUtil.ZeroTimestamp() < 1800, 0, 1)
 	return &msg.ResChampship{
 		Score:      int32(c.Score),
 		Reward:     int32(c.Reward),
-		EndTime:    int32(GoUtil.ZeroTimestamp() + 86400), //  零点结束
+		EndTime:    int32(GoUtil.ZeroTimestamp() + 86400),
 		Period:     int32(GoUtil.GetServerOpenDay()),
 		Rank:       int32(MyRank),
-		RankReward: int32(RankReward),
+		RankReward: int32(rankReward),
-		Status:     int32(Status.(int)),
+		Status:     int32(status),
 	}
 }
 

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

@@ -78,6 +78,11 @@ const (
 	CHESS_SHOP    = 2 // 棋子商店
 	ENERGY_SHOP   = 3 // 能量商店
 )
+const (
+	secondsIn35Days = 35 * 24 * 3600
+	secondsIn7Days  = 7 * 24 * 3600
+	secondsIn1Day   = 24 * 3600
+)
 
 func (c *ChargeMod) InitData() {
 	if c.SpecialShop == nil {
@@ -110,12 +115,17 @@ func (c *ChargeMod) Login(LogoutTime int64) {
 	c.PetWorkTime -= c.LastWorkTime
 }
 
+// resetSpecialChargeIfExpired 若距上次充値超过 35 天则清零特惠充値记录
+func (c *ChargeMod) resetSpecialChargeIfExpired(now int64) {
+	if c.LastCharge != 0 && now-c.LastCharge > secondsIn35Days {
+		c.SpecialCharge = 0
+	}
+}
+
 // 零点更新
 func (c *ChargeMod) ZeroUpdate(Emit []int) {
 	Now := GoUtil.Now()
-	if c.LastCharge != 0 && Now-c.LastCharge > 35*24*3600 {
+	c.resetSpecialChargeIfExpired(Now)
-		c.SpecialCharge = 0
-	}
 	if GoUtil.IsFirstDayOfMonth() {
 		c.MonthCharge = 0
 	}
@@ -135,10 +145,12 @@ func (c *ChargeMod) ZeroUpdate(Emit []int) {
 		SpecialGrade = max(1, M-a)
 		c.SpecialShop[i] = &SepcialShop{Grade: SpecialGrade, Count: SpecialShopCount}
 	}
-	c.WishList.SendList = make([]int64, 0)
+	if c.WishList != nil {
+		c.WishList.SendList = nil
+	}
 	if c.IsWeeklyDiscountDay() && c.WeeklyEndTime < Now {
 		c.WeeklyDiscount = make(map[int]int)
-		c.WeeklyEndTime = GoUtil.ZeroTimestamp() + 7*24*3600
+		c.WeeklyEndTime = GoUtil.ZeroTimestamp() + secondsIn7Days
 	}
 	c.InitChessShop(Emit)
 }
@@ -168,10 +180,7 @@ func (c *ChargeMod) Fire(ChargeId int) (Item []*item.Item) {
 	if c.FirstCharge == 0 {
 		c.FirstCharge = Now
 	}
-	if c.LastCharge != 0 && Now-c.LastCharge > 35*24*3600 {
+	c.resetSpecialChargeIfExpired(Now)
-		c.SpecialCharge = 0
-
-	}
 	c.LastCharge = Now
 	if Money > c.MaxCharge {
 		c.MaxCharge = Money
@@ -206,6 +215,7 @@ func (c *ChargeMod) FireDiamondShop(ChargeId int) []*item.Item {
 	return chargeCfg.GetDiamondShopReward(ChargeId)
 }
 
+// 宠物币商店
 func (c *ChargeMod) FirePetCoinShop(ChargeId int) []*item.Item {
 	return chargeCfg.GetPetCoinShopReward(ChargeId)
 }
@@ -265,11 +275,11 @@ func (c *ChargeMod) FireAdReward(ChargeId int) []*item.Item {
 	if PetWorkDay != 0 {
 		Now := GoUtil.Now()
 		if c.AdEndTime < Now {
-			c.AdEndTime = Now + int64(PetWorkDay*24*3600)
+			c.AdEndTime = Now + int64(PetWorkDay*secondsIn1Day)
 		} else {
-			c.AdEndTime += int64(PetWorkDay * 24 * 3600)
+			c.AdEndTime += int64(PetWorkDay * secondsIn1Day)
 		}
-		c.PetWorkTime += int64(PetWorkDay * 24 * 3600)
+		c.PetWorkTime += int64(PetWorkDay * secondsIn1Day)
 		c.Ad = true
 	}
 	return Items
@@ -284,6 +294,7 @@ func (c *ChargeMod) FireFreeShop() ([]*item.Item, error) {
 	return chargeCfg.GetFreeShopReward(c.FreeShop), nil
 }
 
+// 初始化棋子商店
 func (c *ChargeMod) InitChessShop(Emit []int) {
 	if len(Emit) == 0 {
 		return
@@ -328,6 +339,7 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 	}
 }
 
+// 购买能量
 func (c *ChargeMod) BuyEnergy(IsWeeklyDiscount bool) ([]*item.Item, []*item.Item, int) {
 	diamond := 40
 	if IsWeeklyDiscount {
@@ -346,6 +358,7 @@ func (c *ChargeMod) BuyEnergy(IsWeeklyDiscount bool) ([]*item.Item, []*item.Item
 		}, diamond
 }
 
+// 购买棋子
 func (c *ChargeMod) BuyChess(Chess int, IsWeeklyDiscount bool) ([]*item.Item, []*item.Item, int, error) {
 	v, ok := c.ChessShop[Chess]
 	if !ok {
@@ -376,10 +389,12 @@ func (c *ChargeMod) BuyChess(Chess int, IsWeeklyDiscount bool) ([]*item.Item, []
 		}, v.Id, nil
 }
 
+// 棋子商店解锁
 func (c *ChargeMod) TriggerChargeUnlock(Lv int, Emit []int) {
 	c.InitChessShop(Emit)
 }
 
+// 添加心愿单
 func (c *ChargeMod) AddWish(Id, Type int) ([]*item.Item, error) {
 	ItemId := 0
 	switch Type {
@@ -389,7 +404,7 @@ func (c *ChargeMod) AddWish(Id, Type int) ([]*item.Item, error) {
 	if ItemId == 0 {
 		return nil, fmt.Errorf("AddWish itemid not exist id:%d", Id)
 	}
-	Items := []*item.Item{}
+	var Items []*item.Item
 	if c.WishList.ItemId != 0 {
 		if c.WishList.ItemId == ItemId {
 			return nil, fmt.Errorf("AddWish itemid already exist id:%d", Id)
@@ -401,6 +416,7 @@ func (c *ChargeMod) AddWish(Id, Type int) ([]*item.Item, error) {
 	return Items, nil
 }
 
+// 获取心愿单奖励
 func (c *ChargeMod) GetWish() ([]*item.Item, error) {
 	if c.WishList.ItemId == 0 {
 		return nil, fmt.Errorf("AddWishCount itemid not exist")
@@ -409,11 +425,13 @@ func (c *ChargeMod) GetWish() ([]*item.Item, error) {
 	if c.WishList.Count < Max {
 		return nil, fmt.Errorf("AddWishCount count max")
 	}
+	rewardItemId := c.WishList.ItemId
 	c.WishList.Count = 0
 	c.WishList.ItemId = 0
-	return []*item.Item{item.NewItem(c.WishList.ItemId, 1)}, nil
+	return []*item.Item{item.NewItem(rewardItemId, 1)}, nil
 }
 
+// 发送心愿单
 func (c *ChargeMod) SendWishBeg(Uids []int64) error {
 	for _, v := range Uids {
 		if GoUtil.InArray64(v, c.WishList.SendList) {
@@ -424,6 +442,7 @@ func (c *ChargeMod) SendWishBeg(Uids []int64) error {
 	return nil
 }
 
+// 增加心愿单完成度
 func (c *ChargeMod) AddWishCount() {
 	if c.WishList.ItemId == 0 {
 		return
@@ -435,6 +454,7 @@ func (c *ChargeMod) AddWishCount() {
 	c.WishList.Count++
 }
 
+// 是否在每周折扣日
 func (c *ChargeMod) IsWeeklyDiscountDay() bool {
 	Day := chargeCfg.GetWeeklyDiscountDay()
 	if Day == -1 {
@@ -444,6 +464,7 @@ func (c *ChargeMod) IsWeeklyDiscountDay() bool {
 	return Weekday == Day || c.WeeklyEndTime > GoUtil.Now()
 }
 
+// 重置每周折扣
 func (c *ChargeMod) ResetWeeklyDiscount() {
 	if c.IsWeeklyDiscountDay() {
 		return
@@ -451,6 +472,7 @@ func (c *ChargeMod) ResetWeeklyDiscount() {
 	c.WeeklyDiscount = make(map[int]int)
 }
 
+// 宠物打工数据
 func (c *ChargeMod) PetWorkBackData() *msg.LogoutPetWork {
 	res := &msg.LogoutPetWork{
 		WorkTime:   c.LastWorkTime,

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

@@ -4,6 +4,7 @@ import (
 	"math"
 )
 
+// 弃用
 func GetChessDiamond(Lv, Type int) int {
 	Diamond := 0.0
 	if Type == 1 {

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

@@ -164,8 +164,7 @@ func (cb *ChessBorad) ComposeChess(id int) (int, error) {
 	ChessType := mergeDataCfg.GetTypeById(id)
 	if ChessType == "Emitter" {
 		cb.EmitList[id+1]++
-		cb.EmitList[id]--
+		cb.EmitList[id] -= 2
-		cb.EmitList[id]--
 	}
 	id++
 	newList = append(newList, id)
@@ -178,6 +177,7 @@ func (cb *ChessBorad) GetChessList() []int {
 	return cb.ChessList
 }
 
+// 获取解锁棋子列表
 func (cb *ChessBorad) GetUnlockChessList() []int {
 	r := make([]int, 0, len(cb.ChessList))
 	for k, v := range cb.ChessMap {
@@ -189,18 +189,13 @@ func (cb *ChessBorad) GetUnlockChessList() []int {
 	return r
 }
 
-// func (cb *ChessBorad) GetUnlockChessList() []int {
-// 	return cb.ChessBag.List
-// }
-
 // 添加棋子
 func (cb *ChessBorad) AddChess(id int) error {
 	_, err := mergeDataCfg.GetOne(id)
 	if err != nil {
 		return errors.New("配置错误")
 	}
-	NewChessList := append(cb.ChessList, id)
+	if len(cb.ChessList)+1 > ChessBoradMaxNum { // 棋盘满了 加入缓存区
-	if len(NewChessList) > ChessBoradMaxNum { // 棋盘满了 加入缓存区
 		cb.ChessBuff = append(cb.ChessBuff, id)
 		return nil
 	}
@@ -283,8 +278,10 @@ func (cb *ChessBorad) RemoveChess(Id int) error {
 	}
 	return nil
 }
-func (cb *ChessBorad) GetStarEmitList() []int {
+
-	result := make([]int, 0, len(cb.EmitList))
+// emitListToSlice 将 EmitList 过滤并转换为发射器 ID 列表。
+// retireFilter 为 true 时过滤已退役的发射器。
+func (cb *ChessBorad) emitListToSlice(retireFilter bool) []int {
 	EM := make(map[string]int)
 	for k, v := range cb.EmitList {
 		if v <= 0 {
@@ -295,46 +292,27 @@ func (cb *ChessBorad) GetStarEmitList() []int {
 		if EmitID == "" {
 			continue
 		}
-		EmitType := mergeDataCfg.GetEmitType(k)
+		if retireFilter && cb.Retire[EmitID] >= EMIT_RETIRE_START {
-		if EmitType == "sub" {
 			continue
 		}
-		if v > 0 {
+		if mergeDataCfg.GetEmitType(k) == "sub" {
-			EM[EmitID] = max(EM[EmitID], k)
+			continue
 		}
+		EM[EmitID] = max(EM[EmitID], k)
 	}
+	result := make([]int, 0, len(EM))
 	for _, v := range EM {
 		result = append(result, v)
 	}
 	return result
 }
+
+func (cb *ChessBorad) GetStarEmitList() []int {
+	return cb.emitListToSlice(false)
+}
+
 func (cb *ChessBorad) GetEmitList() []int {
-	result := make([]int, 0, len(cb.EmitList))
+	return cb.emitListToSlice(true)
-	EM := make(map[string]int)
-	for k, v := range cb.EmitList {
-		if v <= 0 {
-			delete(cb.EmitList, k)
-			continue
-		}
-		EmitID := mergeDataCfg.GetEmitId(k)
-		if EmitID == "" {
-			continue
-		}
-		if cb.Retire[EmitID] >= EMIT_RETIRE_START {
-			continue
-		}
-		EmitType := mergeDataCfg.GetEmitType(k)
-		if EmitType == "sub" {
-			continue
-		}
-		if v > 0 {
-			EM[EmitID] = max(EM[EmitID], k)
-		}
-	}
-	for _, v := range EM {
-		result = append(result, v)
-	}
-	return result
 }
 
 // 完成订单 移除棋子
@@ -345,8 +323,8 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
 		unlockChessMap[v]++
 	}
 
-	boardChess := []int{}
+	var boardChess []int
-	BagChess := []int{}
+	var BagChess []int
 	for _, v := range ChessId {
 		if unlockChessMap[v] > 0 {
 			unlockChessMap[v]--
@@ -370,6 +348,7 @@ func (cb *ChessBorad) FinishOrder(ChessId []int) error {
 	return nil
 }
 
+// 完成订单 移除棋子
 func (cb *ChessBorad) FinishOrderChess(Chess int) error {
 	for k, v := range cb.ChessList {
 		if v == Chess {
@@ -380,6 +359,7 @@ func (cb *ChessBorad) FinishOrderChess(Chess int) error {
 	return fmt.Errorf("order finish board chess id：%d not exist", Chess)
 }
 
+// 完成订单 移除棋子
 func (cb *ChessBorad) FinishOrderChessByBag(Chess int) error {
 	for k, v := range cb.ChessBag.List {
 		if v.ChessId == Chess {
@@ -415,21 +395,18 @@ func (cb *ChessBorad) RemoveHonor(Id int) {
 	delete(cb.Honor, Id)
 }
 
+// 从暂存区添加棋子到棋盘
 func (cb *ChessBorad) GetChessFromBuff(Chess int) error {
 	for i, v := range cb.ChessBuff {
 		if v == Chess {
 			cb.ChessBuff = append(cb.ChessBuff[:i], cb.ChessBuff[i+1:]...)
-			cb.AddChess(Chess)
+			return 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 {
@@ -469,7 +446,7 @@ func (cb *ChessBorad) BackData() *msg.ResPlayerChessInfo {
 	}
 	Rw := make([]string, 0, len(cb.RetireReward))
 	for k, v := range cb.RetireReward {
-		if v == true {
+		if v {
 			Rw = append(Rw, k)
 		}
 	}
@@ -524,6 +501,7 @@ func (cb *ChessBorad) TriggerChessBagUnlock(Lv int) bool {
 	return false
 }
 
+// 将棋子放入背包
 func (cb *ChessBorad) PutChessInBag(Grid, ChessId, EmitId int) error {
 	err := cb.RemoveChess(ChessId)
 	if err != nil {
@@ -548,6 +526,7 @@ 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 {
@@ -558,14 +537,10 @@ func (cb *ChessBorad) PutPartInBag(ChessId int) error {
 	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)
 	}
+	Num := cb.PartBag.List[ChessId].Num
 	cb.PartBag.List[ChessId] = PartBagGrid{
 		PartId: ChessId,
 		Num:    Num + 1,
@@ -573,6 +548,7 @@ func (cb *ChessBorad) PutPartInBag(ChessId int) error {
 	return nil
 }
 
+// 将棋子从背包取出
 func (cb *ChessBorad) TakeChessOutBag(Grid int) (int, error) {
 	if Grid < 0 {
 		cb.RemoveHonor(-Grid)
@@ -598,6 +574,7 @@ func (cb *ChessBorad) GetRetireEmit() map[string]int {
 	return cb.Retire
 }
 
+// 获取退役发射器的棋子列表
 func (cb *ChessBorad) GetRetireChess(EmitType string) []int {
 	v, ok := cb.RetireChessMap[EmitType]
 	if !ok {
@@ -614,6 +591,7 @@ func (cb *ChessBorad) GetRetireChess(EmitType string) []int {
 	return v[:2]
 }
 
+// 开始退役
 func (cb *ChessBorad) BeginRetire(EmitType string) error {
 	if cb.Retire == nil {
 		cb.Retire = make(map[string]int)
@@ -626,6 +604,7 @@ func (cb *ChessBorad) BeginRetire(EmitType string) error {
 	return nil
 }
 
+// 退役棋子处理
 func (cb *ChessBorad) RetireOrder(EmitType string) error {
 	if cb.Retire[EmitType] != 1 {
 		return errors.New("chess has not been retired")
@@ -646,6 +625,7 @@ func (cb *ChessBorad) RetireOrder(EmitType string) error {
 	return nil
 }
 
+// 完成退役
 func (cb *ChessBorad) FinishRetire(EmitType string) error {
 	_, ok := cb.Retire[EmitType]
 	if !ok {
@@ -655,6 +635,7 @@ func (cb *ChessBorad) FinishRetire(EmitType string) error {
 	return nil
 }
 
+// 获取资源宝箱奖励
 func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) {
 	err := cb.RemoveChess(ChessId)
 	if err != nil {
@@ -670,6 +651,7 @@ func (cb *ChessBorad) SourceChest(ChessId int) ([]*item.Item, error) {
 	return nil, nil
 }
 
+// 降低棋子等级
 func (cb *ChessBorad) SeparateChess(ChessId int) (int, error) {
 	ChessLv := mergeDataCfg.GetLvById(ChessId)
 	if ChessLv == 1 {
@@ -694,6 +676,7 @@ func (cb *ChessBorad) SeparateChess(ChessId int) (int, error) {
 	return NewChess, nil
 }
 
+// 提高棋子等级
 func (cb *ChessBorad) UpgradeChess(ChessId int) (int, error) {
 	ChessLv := mergeDataCfg.GetLvById(ChessId)
 	ChessMaxLv := mergeDataCfg.GetMaxLvById(ChessId)

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

@@ -21,6 +21,8 @@ const (
 	COLLECT_TYPE_EMOJI  = 1
 	COLLECT_TYPE_FACE   = 2
 	COLLECT_TYPE_AVATAR = 3
+
+	jackpotPreviewSize = 18 // 展示的奖池预览数量，同时作为补充阈値
 )
 
 func (c *Collect) InitData() {
@@ -30,11 +32,17 @@ func (c *Collect) InitData() {
 	if len(c.Jackpot) == 0 {
 		c.Jackpot = initJackpot()
 	}
-	if len(c.Jackpot) <= 18 {
+	c.ensureJackpot()
+}
+
+// ensureJackpot 当奖池剩余少于预览数量时自动补充
+func (c *Collect) ensureJackpot() {
+	if len(c.Jackpot) <= jackpotPreviewSize {
 		c.Jackpot = initJackpot2(c.Jackpot)
 	}
 }
 
+// 获取收集奖励
 func (c *Collect) GetReward(Id, Num int) ([]*item.Item, error) {
 	// 判断是否已领取
 	for _, v := range c.Reward {
@@ -50,17 +58,13 @@ func (c *Collect) GetReward(Id, Num int) ([]*item.Item, error) {
 	c.Reward = append(c.Reward, Id)
 	JackpotId := 0
 	JackpotId, c.Jackpot = GoUtil.PopSlice(c.Jackpot)
-	if len(c.Jackpot) <= 18 {
+	c.ensureJackpot()
-		c.Jackpot = initJackpot2(c.Jackpot)
+	return collectCfg.GetJackpotItems(JackpotId), nil
-	}
-	Items := collectCfg.GetJackpotItems(JackpotId)
-	// 删除收集记录
-	return Items, nil
 }
 
 func (c *Collect) BackData() *msg.ResCollectInfo {
-	var ItemsMsg []*msg.CollectItem
+	ItemsMsg := make([]*msg.CollectItem, 0, jackpotPreviewSize)
-	for i := 0; i < 18; i++ {
+	for i := 0; i < jackpotPreviewSize; i++ {
 		Items := collectCfg.GetJackpotItems(c.Jackpot[i])
 		ItemsMsg = append(ItemsMsg, &msg.CollectItem{
 			Id:    int32(i + 1),
@@ -80,9 +84,5 @@ func initJackpot2(r1 []int) []int {
 }
 
 func initJackpot() []int {
-	Ids := collectCfg.GetJackpotId()
+	return initJackpot2(initJackpot2(initJackpot2(nil)))
-	r1 := GoUtil.ShuffleArray(Ids)
-	r2 := GoUtil.ShuffleArray(Ids)
-	r3 := GoUtil.ShuffleArray(Ids)
-	return append(append(r1, r2...), r3...)
 }

src/server/game/mod/daily_task/DailyFunc.go

@@ -10,45 +10,47 @@ import (
 
 func getTaskReward(Id, AreaId int) []*item.Item {
 	switch Id {
-	case 1:
-		return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 5}}
 	case 2:
 		StarNum := int(50 * math.Pow(1.04, float64(AreaId)))
 		return []*item.Item{{Id: item.ITEM_STAR_ID, Num: StarNum}}
 	case 3:
 		return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 10}}
+	default: // case 1 及其他
+		return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 5}}
 	}
-	return []*item.Item{{Id: item.ITEM_ENERGY_ID, Num: 5}}
 }
 
+// randJackpot 随机选取 num 个奖池项，约束：不允许连续两个 is_card=1 的项相邻。
+// 最多尝试 100 次，超时则返回最后一次结果。
 func randJackpot(jackpot map[int]dailyTaskCfg.Jackpot, num int) map[int][]*item.Item {
 	Ids := GoUtil.GetMapKey(jackpot)
-	r := make(map[int][]*item.Item)
+	var lastIds1 []int
-	t := 0
+	for t := 0; t <= 100; t++ {
-	for {
 		Ids1 := GoUtil.RandSliceNum(Ids, num)
 		sort.Ints(Ids1)
-		b := 0
+		lastIds1 = Ids1
-		finish := true
+		prevIsCard := 0
+		valid := true
 		for _, k := range Ids1 {
-			jack := jackpot[k]
+			curIsCard := jackpot[k].Is_card
-			if b == jack.Is_card && b == 1 {
+			if prevIsCard == 1 && curIsCard == 1 {
-				finish = false
+				valid = false
 				break
 			}
-			b = jack.Is_card
+			prevIsCard = curIsCard
 		}
-
+		if valid {
-		if finish {
+			r := make(map[int][]*item.Item, num)
 			for _, k := range Ids1 {
 				r[k] = jackpot[k].Items
 			}
 			return r
 		}
-		t++
-		if t > 100 {
-			return r
-		}
 	}
-
+	// 超时：返回最后一次随机结果
+	r := make(map[int][]*item.Item, num)
+	for _, k := range lastIds1 {
+		r[k] = jackpot[k].Items
+	}
+	return r
 }

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

@@ -67,10 +67,6 @@ func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId int) {
 	TaskId := GoUtil.RandSliceNum(TaskList1, 3)
 	for i := 0; i < len(TaskId); i++ {
 		Id := i + 1
-		Lock := false
-		if Id == 1 {
-			Lock = true
-		}
 		questStr := TaskList[TaskId[i]]
 		QuestProgress, err := quest.ParseQuest(questStr)
 		if err != nil {
@@ -79,10 +75,15 @@ func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId int) {
 		Items := getTaskReward(Id, AreaId)
 		dt.DayTask[Id] = DailyTask{
 			Items:  Items,
-			UnLock: Lock,
+			UnLock: Id == 1,
 			Quest:  QuestProgress,
 		}
 	}
+	// 更新 lastTask，下次不重复当前任务
+	dt.lastTask = make(map[int]struct{}, len(TaskId))
+	for _, id := range TaskId {
+		dt.lastTask[id] = struct{}{}
+	}
 }
 
 func (dt *DailyTaskMod) WeekUpdate() {
@@ -90,14 +91,12 @@ func (dt *DailyTaskMod) WeekUpdate() {
 	jackpotRand := randJackpot(jackpot, 5)
 	jackpotId := GoUtil.GetMapKey(jackpotRand)
 	sort.Ints(jackpotId)
-	weekReward := make(map[int]WeekReward)
+	weekReward := make(map[int]WeekReward, len(jackpotId)+1)
-	i := 1
+	for i, v := range jackpotId {
-	for _, v := range jackpotId {
+		weekReward[i+1] = WeekReward{
-		weekReward[i] = WeekReward{
 			Id:    v,
 			Items: jackpotRand[v],
 		}
-		i++
 	}
 	weekReward[6] = WeekReward{
 		Id:    0,
@@ -194,15 +193,14 @@ func (dt *DailyTaskMod) GetWeekReward(id int) ([]*item.Item, error) {
 }
 
 func (dt *DailyTaskMod) GetWeekReward2() []*item.Item {
-	max := 0
+	maxId := 0
 	for id := range dt.WeekReward {
-		if id > max {
+		if id > maxId {
-			max = id
+			maxId = id
 		}
 	}
-	max++
+	if v, ok := dt.WeekReward[maxId]; ok {
-	if v, ok := dt.WeekReward[max]; ok {
+		NeedActive := dailyTaskCfg.GetTaskActiveById(maxId)
-		NeedActive := dailyTaskCfg.GetTaskActiveById(max)
 		if dt.Active < NeedActive {
 			return nil
 		}

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

@@ -41,12 +41,19 @@ func (d *Decorate) InitData() {
 	if len(d.PartCost) == 0 {
 		d.initPartCost(d.AreaId)
 	}
+	d.prunePartCost()
+}
+
+// prunePartCost 删除 PartCost 中属于已过区域的条目，若清空则初始化当前区域的零件消耗
+func (d *Decorate) prunePartCost() {
 	for k := range d.PartCost {
-		AreaId := decorateCfg.GetAreaIdByIndoorId(k)
+		if decorateCfg.GetAreaIdByIndoorId(k) < d.AreaId {
-		if AreaId < d.AreaId {
 			delete(d.PartCost, k)
 		}
 	}
+	if len(d.PartCost) == 0 {
+		d.initPartCost(d.AreaId)
+	}
 }
 
 // 装饰
@@ -62,7 +69,7 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
 		return nil, fmt.Errorf("decorateId not in areaId")
 	}
 	d.FinishList[decorateId] = struct{}{}
-	d.Progress += 1
+	d.Progress++
 	Item := decorateCfg.GetProgressReward(areaId, d.Progress)
 	Item1 := decorateCfg.GetDecoarteReward(areaId, decorateId)
 	Item = append(Item, Item1...)
@@ -70,15 +77,7 @@ func (d *Decorate) Decorate(areaId int, decorateId int) ([]*item.Item, error) {
 		d.AreaId++
 		d.Progress = 0
 		d.FinishList = make(map[int]struct{})
-		for k := range d.PartCost {
+		d.prunePartCost()
-			AreaId := decorateCfg.GetAreaIdByIndoorId(k)
-			if AreaId < d.AreaId {
-				delete(d.PartCost, k)
-			}
-		}
-		if len(d.PartCost) == 0 {
-			d.initPartCost(d.AreaId)
-		}
 	}
 
 	d.DecorateNum++
@@ -108,9 +107,9 @@ func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExis
 		PartItemList = PartItem.Items
 		delete(d.PartCost, Id)
 	}
+	// 清理旧区域零件；若当前区域全部消耗完则预加载下一区域
 	for k := range d.PartCost {
-		AreaId := decorateCfg.GetAreaIdByIndoorId(k)
+		if decorateCfg.GetAreaIdByIndoorId(k) < d.AreaId {
-		if AreaId < d.AreaId {
 			delete(d.PartCost, k)
 		}
 	}
@@ -120,6 +119,7 @@ func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExis
 	return Items, PetExp, PartItemList
 }
 
+// 一键装饰
 func (d *Decorate) DecorateAll(Star int, DecorateOffIsExist bool) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
 	DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
 	SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
@@ -176,15 +176,7 @@ func (d *Decorate) DecorateAll(Star int, DecorateOffIsExist bool) ([]*item.Item,
 		d.AreaId++
 		d.Progress = 0
 		d.FinishList = make(map[int]struct{})
-		for k := range d.PartCost {
+		d.prunePartCost()
-			AreaId := decorateCfg.GetAreaIdByIndoorId(k)
-			if AreaId < d.AreaId {
-				delete(d.PartCost, k)
-			}
-		}
-		if len(d.PartCost) == 0 {
-			d.initPartCost(d.AreaId)
-		}
 	}
 	SubItems = append(SubItems, item.NewItem(item.ITEM_STAR_ID, SubItem))
 	return SubItems, AddItem, Num, DecorateList, Log, PetExp
@@ -192,7 +184,7 @@ func (d *Decorate) DecorateAll(Star int, DecorateOffIsExist bool) ([]*item.Item,
 
 // 获取装饰信息
 func (d *Decorate) BackData() *msg.ResDecorateInfo {
-	PartRes := []*msg.DecoratePart{}
+	var PartRes []*msg.DecoratePart
 	for k, v := range d.PartCost {
 		PartRes = append(PartRes, &msg.DecoratePart{
 			Id:    int32(k),
@@ -207,6 +199,7 @@ func (d *Decorate) BackData() *msg.ResDecorateInfo {
 	}
 }
 
+// 获取装饰奖励
 func (d *Decorate) GetDecorateReward(areaId int) ([]*item.Item, error) {
 	if GoUtil.InArray(areaId, d.AreaReward) {
 		return nil, fmt.Errorf("areaId already rewarded")
@@ -227,9 +220,10 @@ 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)
+	res := make(map[int]int)
 	ClassNum := min(Num, 3)
 	ClassList := d.GetPartClass(ClassNum)
 	NewClassList := d.sortClass(ClassList)
@@ -243,40 +237,38 @@ func (d *Decorate) GetPart(Num int) map[int]int {
 
 func (d *Decorate) sortClass(Class []int) []int {
 	d.initPartPool()
-	type sortClass struct {
+	type sortItem struct {
 		Id  int
 		Num int
 	}
-	sortList := make([]sortClass, 0)
+	sortList := make([]sortItem, len(Class))
-	for _, v := range Class {
+	for i, v := range Class {
-		sortList = append(sortList, sortClass{
+		sortList[i] = sortItem{Id: v, Num: d.PartPool[v]}
-			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)
+	res := make([]int, len(Class))
-	for _, v := range sortList {
+	for i, v := range sortList {
-		res = append(res, v.Id)
+		res[i] = v.Id
 	}
 	return res
 }
 
 func (d *Decorate) GetPartClass(Num int) []int {
-	res := []int{}
+	res := make([]int, 0, Num)
-	Id := 0
 	for range Num {
 		if len(d.PartClassPool) == 0 {
 			d.initPartClassPool()
 		}
-		Id, d.PartClassPool = GoUtil.PopSlice(d.PartClassPool)
+		Id, newPool := GoUtil.PopSlice(d.PartClassPool)
+		d.PartClassPool = newPool
 		res = append(res, Id)
 	}
 	return res
 }
 
+// 初始化零件类别池，优先保证每个类别至少出现一次
 func (d *Decorate) initPartClassPool() {
 	if len(d.PartClassPool) == 0 {
 		ClassList := decorateCfg.GetAllPartId()
@@ -304,6 +296,7 @@ func (d *Decorate) initPartPool() {
 	}
 }
 
+// 初始化零件消耗，预加载当前区域和下一区域的零件消耗，减少玩家装饰时的卡顿感
 func (d *Decorate) initPartCost(AreaId int) {
 	AllPartList := decorateCfg.GetPartNumByAreaId(AreaId)
 	for k, v := range AllPartList {

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

@@ -30,8 +30,8 @@ func (e *EmojiMod) InitData() {
 		e.Set = make(map[int]int)
 	}
 	if e.List == nil {
-		e.List = make(map[int]*Emoji)
 		InitId := emojiCfg.GetInitList()
+		e.List = make(map[int]*Emoji, len(InitId))
 		for _, v := range InitId {
 			e.List[v] = &Emoji{
 				AddTime: now,
@@ -44,6 +44,7 @@ func (e *EmojiMod) GetEmojiNum() int {
 	return len(e.List)
 }
 
+// 设置表情，Id为0表示清空该类型表情
 func (e *EmojiMod) SetEmoji(Id, Type int) error {
 	if Id == 0 {
 		e.Set[Type] = Id
@@ -56,6 +57,7 @@ func (e *EmojiMod) SetEmoji(Id, Type int) error {
 	return nil
 }
 
+// 解锁表情，Time为解锁时长，单位为秒
 func (e *EmojiMod) Unlock(Id, Time int) error {
 	v, ok := e.List[Id]
 	if ok {
@@ -73,6 +75,7 @@ func (e *EmojiMod) Unlock(Id, Time int) error {
 	return nil
 }
 
+// 获取表情列表
 func (e *EmojiMod) GetEmojiSet() map[int32]int32 {
 	return GoUtil.MapIntToInt32(e.Set)
 

src/server/game/mod/endless/Endless.go

@@ -63,26 +63,24 @@ func (e *EndlessMod) ZeroUpdate(MaxMoney float64, Lv int) {
 		}
 	}
 
-	var r map[int]*Endless
+	money := FirstMoney
-	r, e.Auto = initGrade(FirstMoney, e.Auto, Lv)
+	for range 3 {
-	for k, v := range r {
+		e.appendGrade(money, Lv)
-		e.List[k] = v
+		money = endlessCfg.NextMoney(money)
 	}
-	NextMoney := endlessCfg.NextMoney(FirstMoney)
-	r, e.Auto = initGrade(NextMoney, e.Auto, Lv)
-	for k, v := range r {
-		e.List[k] = v
-	}
-
-	NextMoney = endlessCfg.NextMoney(NextMoney)
-	r, e.Auto = initGrade(NextMoney, e.Auto, Lv)
-	for k, v := range r {
-		e.List[k] = v
-	}
-	e.LastMoney = NextMoney
 	e.Id = 1
 }
 
+// appendGrade 初始化一档礼包并合并到列表
+func (e *EndlessMod) appendGrade(money float64, Lv int) {
+	r, autoNext := initGrade(money, e.Auto, Lv)
+	e.Auto = autoNext
+	for k, v := range r {
+		e.List[k] = v
+	}
+	e.LastMoney = money
+}
+
 // 领取免费礼包
 func (e *EndlessMod) GetReward(Lv int) ([]*item.Item, error) {
 	v, ok := e.List[e.Id]
@@ -94,15 +92,8 @@ func (e *EndlessMod) GetReward(Lv int) ([]*item.Item, error) {
 	}
 	delete(e.List, e.Id)
 	e.Id++
-	v1 := e.List[e.Id]
+	if v1 := e.List[e.Id]; v1 != nil && v1.Type == ENDLESS_TYPE_CHARGE { //领完一阶段 随机新的一阶段
-	if v1.Type == ENDLESS_TYPE_CHARGE { //领完一阶段 随机新的一阶段
+		e.appendGrade(endlessCfg.NextMoney(e.LastMoney), Lv)
-		var r map[int]*Endless
-		NextMoney := endlessCfg.NextMoney(e.LastMoney)
-		r, e.Auto = initGrade(NextMoney, e.Auto, Lv)
-		for k, v := range r {
-			e.List[k] = v
-		}
-		e.LastMoney = NextMoney
 	}
 	return v.Items, nil
 }

src/server/game/mod/endless/endless_func.go

@@ -8,7 +8,7 @@ import (
 )
 
 // 初始化奖励
-func InitReward(Energy float64, Order, Lv int) []*item.Item {
+func InitReward(Energy float64, Lv int) []*item.Item {
 	numRand := map[int]int{1: 30, 2: 60, 3: 10}
 	Num := Util.RandMap(numRand)
 	PerEnergy := endlessCfg.GetPerEnergy(item.ITEM_ENERGY_ID)
@@ -77,7 +77,7 @@ func initGrade(Money float64, Auto, Lv int) (map[int]*Endless, int) {
 		result[Auto] = &Endless{
 			ChargeId: Charge,
 			Type:     Type,
-			Items:    InitReward(Energy*Per[i-1], i, Lv),
+			Items:    InitReward(Energy*Per[i-1], Lv),
 		}
 		Auto++
 	}

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

@@ -19,10 +19,9 @@ type Face struct {
 }
 
 func (f *FaceMod) Login(RegisterTime int64) {
-	for k, v := range f.List {
+	for _, v := range f.List {
 		if v.AddTime == 0 {
 			v.AddTime = RegisterTime
-			f.List[k] = v
 		}
 	}
 }
@@ -46,24 +45,25 @@ func (f *FaceMod) InitData() {
 	}
 }
 
+// 获取表情数量
 func (f *FaceMod) GetFaceNum() int {
 	return len(f.List)
 }
 
+// 设置表情，Id为0表示清空表情
 func (f *FaceMod) SetFace(Id int) error {
-	if Id == 0 {
+	if Id != 0 {
-		f.SetId = Id
+		if _, ok := f.List[Id]; !ok {
-		return nil
+			return fmt.Errorf("face id not exist")
-	}
+		}
-	if _, ok := f.List[Id]; !ok {
-		return fmt.Errorf("face id not exist")
 	}
 	f.SetId = Id
 	return nil
 }
 
-func (a *FaceMod) Unlock(Id, Time int) error {
+// 解锁表情
-	v, ok := a.List[Id]
+func (f *FaceMod) Unlock(Id, Time int) error {
+	v, ok := f.List[Id]
 	if ok {
 		if v.Ts == 0 {
 			return nil
@@ -72,7 +72,7 @@ func (a *FaceMod) Unlock(Id, Time int) error {
 		return nil
 	}
 	now := GoUtil.Now()
-	a.List[Id] = &Face{
+	f.List[Id] = &Face{
 		Ts:      now + int64(Time),
 		AddTime: now,
 	}

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

@@ -183,12 +183,12 @@ type LogInfo struct {
 	Reward bool // 是否已领取奖励
 }
 
+// 初始化数据
 func (f *FriendMod) InitData() {
 	if f.FriendList == nil {
 		f.FriendList = make(map[int]struct{})
 	}
 	if len(f.ActivityLog) == 0 {
-		f.ActivityLog = make([]*ActLogInfo, 0)
 		f.AddActLog(ACT_LOG_TYPE_FIRST_LOGIN, "")
 	}
 	if f.ApplyList == nil {
@@ -218,6 +218,7 @@ func (f *FriendMod) InitData() {
 	}
 }
 
+// 零点更新
 func (f *FriendMod) ZeroUpdate() {
 	f.DailySponsor = f.GetDailySponsorLimit()
 	f.DailyGetApply = 0
@@ -227,6 +228,7 @@ func (f *FriendMod) GetNpc() []int {
 	return f.Npc
 }
 
+// 增加NPC好友
 func (f *FriendMod) SetNpc(id int) error {
 	if !friendCfg.IsNpcFriend(id) {
 		return fmt.Errorf("not npc friend")
@@ -248,6 +250,7 @@ func (f *FriendMod) SetSyncId(Id int64) {
 	f.Id = Id
 }
 
+// 好友交互
 func (f *FriendMod) Interact(id, t int, T int64) {
 	if _, ok := f.NewFriendList[id]; !ok {
 		return
@@ -264,11 +267,12 @@ func (f *FriendMod) Interact(id, t int, T int64) {
 	})
 }
 
+// 获取好友交互时间
 func (f *FriendMod) GetInteractTime(id int) int64 {
 	if _, ok := f.NewFriendList[id]; !ok {
 		return 0
 	}
-	LastTime := int64(0)
+	var LastTime int64
 	// 获取最近一次拜访或点赞的时间
 	for _, v := range f.NewFriendList[id].Interact {
 		if v.VisitTime > LastTime {
@@ -278,6 +282,7 @@ func (f *FriendMod) GetInteractTime(id int) int64 {
 	return LastTime
 }
 
+// 获取好友添加时间
 func (f *FriendMod) GetAddTime(id int) int64 {
 	if _, ok := f.NewFriendList[id]; !ok {
 		return 0
@@ -285,14 +290,15 @@ func (f *FriendMod) GetAddTime(id int) int64 {
 	return f.NewFriendList[id].AddTime
 }
 
+// 增加好友
 func (f *FriendMod) AddFriend(id int) {
 	f.NewFriendList[id] = &FriendInfo{
 		AddTime: GoUtil.Now(),
-		DelTime: 0,
 	}
 	delete(f.ApplyList, id)
 }
 
+// 获取卡牌交换信息
 func (f *FriendMod) GetCardInfo(Id string) *card.CardInfo {
 	v, ok := f.Card[Id]
 	if !ok {
@@ -301,35 +307,39 @@ func (f *FriendMod) GetCardInfo(Id string) *card.CardInfo {
 	return v
 }
 
+// 设置卡牌交换信息
 func (f *FriendMod) SetCardInfo(CardInfo *card.CardInfo) {
 	f.Card[CardInfo.Id] = CardInfo
 }
 
+// 删除卡牌交换信息
 func (f *FriendMod) DelCardInfo(Id string) {
 	delete(f.Card, Id)
 }
 
+// 删除好友
 func (f *FriendMod) DelFriend(id int) {
 	f.NewFriendList[id].DelTime = GoUtil.Now()
 }
 
+// 检查是否好友
 func (f *FriendMod) CheckFriend(Uid int) bool {
-	_, ok := f.NewFriendList[Uid]
+	v, ok := f.NewFriendList[Uid]
-	if !ok {
+	return ok && v.DelTime == 0
-		return false
-	}
-	return f.NewFriendList[Uid].DelTime == 0
 }
 
+// 获取好友数量
 func (f *FriendMod) GetFriendLen() int {
 	return len(f.GetFriendList())
 }
 
+// 拒绝好友申请
 func (f *FriendMod) RefuseApply(id int) {
 	delete(f.ApplyList, id)
 	delete(f.SendApply, id)
 }
 
+// 检查好友申请
 func (f *FriendMod) CheckApply(id int) bool {
 	_, ok := f.ApplyList[id]
 	return ok
@@ -343,6 +353,8 @@ func (f *FriendMod) GetFriendNum() int {
 	}
 	return i
 }
+
+// 获取好友列表
 func (f *FriendMod) GetFriendList() map[int]*FriendInfo {
 	res := make(map[int]*FriendInfo)
 	for k, v := range f.NewFriendList {
@@ -353,6 +365,7 @@ func (f *FriendMod) GetFriendList() map[int]*FriendInfo {
 	return res
 }
 
+// 获取好友uid列表
 func (f *FriendMod) GetSimpleFriendList() []int {
 	rs := make([]int, 0, len(f.NewFriendList))
 	for k, v := range f.NewFriendList {
@@ -363,6 +376,8 @@ func (f *FriendMod) GetSimpleFriendList() []int {
 	}
 	return rs
 }
+
+// 检查是否有新的好友
 func (f *FriendMod) CheckAddBefore(uid int) bool {
 	_, ok := f.NewFriendList[uid]
 	return ok
@@ -389,6 +404,7 @@ func (f *FriendMod) CheckSendApply(Id int) bool {
 	return ok
 }
 
+// 获取发送申请时间
 func (f *FriendMod) GetSendApplyTime(Id int) int64 {
 	if t, ok := f.SendApply[Id]; ok {
 		return t
@@ -396,12 +412,14 @@ func (f *FriendMod) GetSendApplyTime(Id int) int64 {
 	return 0
 }
 
+// 同意申请
 func (f *FriendMod) AgreeApply(UId int) {
 	f.AddFriend(UId)
 	delete(f.SendApply, UId)
 	delete(f.ApplyList, UId)
 }
 
+// 增加好友日志
 func (f *FriendMod) AddLog(Uid, Type int, Param string) int {
 	f.AutoId++
 	f.Log = append(f.Log, &LogInfo{
@@ -412,9 +430,7 @@ func (f *FriendMod) AddLog(Uid, Type int, Param string) int {
 		Param: Param,
 	})
 	switch Type {
-	case LOG_TYPE_HANDBOOK_UPVOTE:
+	case LOG_TYPE_HANDBOOK_UPVOTE, LOG_TYPE_PLAYROOM_UPVOTE:
-		f.AddBubble(f.AutoId, Type, nil)
-	case LOG_TYPE_PLAYROOM_UPVOTE:
 		f.AddBubble(f.AutoId, Type, nil)
 	case LOG_TYPE_TREASURE_HELP:
 		ItemNum := GoUtil.RandNum(2, 5)
@@ -426,6 +442,8 @@ func (f *FriendMod) AddLog(Uid, Type int, Param string) int {
 	}
 	return f.AutoId
 }
+
+// 增加气泡
 func (f *FriendMod) AddBubble(Id, Type int, ItemList []*item.Item) {
 	f.Bubble[Id] = &BubbleInfo{
 		Id:       Id,
@@ -435,7 +453,8 @@ func (f *FriendMod) AddBubble(Id, Type int, ItemList []*item.Item) {
 	}
 }
 
-func (f *FriendMod) GetBubbble(Id int) *msg.FriendBubbleInfo {
+// 获取气泡信息
+func (f *FriendMod) GetBubble(Id int) *msg.FriendBubbleInfo {
 	if v, ok := f.Bubble[Id]; ok {
 		return &msg.FriendBubbleInfo{
 			Id:    int32(v.Id),
@@ -460,6 +479,7 @@ func (f *FriendMod) BubbleBackData() *msg.ResFriendBubble {
 	}
 }
 
+// 金卡限时事件结束后， 重置金卡交换请求
 func (f *FriendMod) ResetGoldCardEx() {
 	for _, v := range f.Card {
 		if cardCfg.CheckCardIsGold(v.CardId) || cardCfg.CheckCardIsGold(v.ExId) {
@@ -468,6 +488,7 @@ func (f *FriendMod) ResetGoldCardEx() {
 	}
 }
 
+// 增加活动日志
 func (f *FriendMod) AddActLog(Type int, Param string) {
 	f.ActivityLog = append(f.ActivityLog, &ActLogInfo{
 		Type:  Type,
@@ -479,6 +500,7 @@ func (f *FriendMod) AddActLog(Type int, Param string) {
 	}
 }
 
+// 时间线点赞
 func (f *FriendMod) Upvote(Id int) ([]*item.Item, int, error) {
 	info := &LogInfo{}
 	for _, v := range f.Log {
@@ -497,16 +519,15 @@ func (f *FriendMod) Upvote(Id int) ([]*item.Item, int, error) {
 	return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, 5)}, info.Uid, nil
 }
 
+// 获取时间线点赞奖励
 func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
 	info, ok := f.Bubble[Id]
 	if !ok {
 		return nil, fmt.Errorf("bubble not exist")
 	}
-	reward := []*item.Item{}
+	var reward []*item.Item
 	switch info.Type {
-	case LOG_TYPE_HANDBOOK_UPVOTE:
+	case LOG_TYPE_HANDBOOK_UPVOTE, LOG_TYPE_PLAYROOM_UPVOTE:
-		reward = append(reward, item.NewItem(item.ITEM_ENERGY_ID, 5))
-	case LOG_TYPE_PLAYROOM_UPVOTE:
 		reward = append(reward, item.NewItem(item.ITEM_ENERGY_ID, 5))
 	case LOG_TYPE_TREASURE_HELP:
 		reward = append(reward, info.ItemList...)
@@ -517,6 +538,7 @@ func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
 	return reward, nil
 }
 
+// 增加心愿单申请
 func (f *FriendMod) AddWishApply(Uid int64) error {
 	for _, v := range f.Apply {
 		if v.Type == APPLY_TYPE_WISH && v.Uid == Uid {
@@ -531,8 +553,9 @@ func (f *FriendMod) AddWishApply(Uid int64) error {
 	return nil
 }
 
+// 获取心愿单申请列表
 func (f *FriendMod) GetWishApply() []*ApplyInfo {
-	rs := []*ApplyInfo{}
+	var rs []*ApplyInfo
 	for _, v := range f.Apply {
 		if v.Type == APPLY_TYPE_WISH {
 			rs = append(rs, v)
@@ -541,18 +564,18 @@ func (f *FriendMod) GetWishApply() []*ApplyInfo {
 	return rs
 }
 
+// 同意心愿单申请
 func (f *FriendMod) ApplyWish(Uid int64) error {
 	for k, v := range f.Apply {
 		if v.Type == APPLY_TYPE_WISH && v.Uid == Uid {
-			r := make([]*ApplyInfo, len(f.Apply)-1)
+			f.Apply = append(f.Apply[:k], f.Apply[k+1:]...)
-			copy(r, f.Apply[:k])
-			f.Apply = append(r, f.Apply[k+1:]...)
 			return nil
 		}
 	}
 	return fmt.Errorf("wish apply not exist")
 }
 
+// 获取最后一次活动日志
 func (f *FriendMod) GetActLogLast() *ActLogInfo {
 	if len(f.ActivityLog) == 0 {
 		return nil
@@ -560,6 +583,7 @@ func (f *FriendMod) GetActLogLast() *ActLogInfo {
 	return f.ActivityLog[len(f.ActivityLog)-1]
 }
 
+// 增加待回复请求
 func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64, Items []*item.Item) *ReplyInfo {
 	f.AutoId++
 	ReplyInfo := &ReplyInfo{
@@ -567,7 +591,6 @@ func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64,
 		Uid:     Uid,
 		Type:    Type,
 		Param:   Param,
-		Status:  0,
 		AddTime: GoUtil.Now(),
 		EndTime: EndTime,
 		Items:   Items,
@@ -576,6 +599,7 @@ func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64,
 	return ReplyInfo
 }
 
+// 回复请求
 func (f *FriendMod) ReplyFriend(LogId int) *ReplyInfo {
 	for _, v := range f.ReplyList {
 		if v.Id == LogId {
@@ -587,21 +611,24 @@ func (f *FriendMod) ReplyFriend(LogId int) *ReplyInfo {
 	return nil
 }
 
+// 获取每日赞助次数
 func (f *FriendMod) GetSponsor() int {
 	return f.DailySponsor
 }
 
+// 获取每日赞助上限，随好友数量增加而减少
 func (f *FriendMod) GetDailySponsorLimit() int {
-	len := len(f.FriendList)
+	n := f.GetFriendNum()
-	if len < 5 {
+	if n < 5 {
 		return 3
 	}
-	if len <= 30 {
+	if n <= 30 {
 		return 2
 	}
 	return 1
 }
 
+// 获取好友赞助体力奖励
 func (f *FriendMod) GetSponsorReward() ([]*item.Item, error) {
 	if f.DailySponsor <= 0 {
 		return nil, fmt.Errorf("no sponsor left")
@@ -611,19 +638,20 @@ func (f *FriendMod) GetSponsorReward() ([]*item.Item, error) {
 	return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, itemNum)}, nil
 }
 
+// 增加好友推荐记录
 func (f *FriendMod) AddRecommend(Uid int) {
-	for _, v := range f.RecommendList {
+	now := GoUtil.Now()
-		if v.Uid == Uid {
+	if v, ok := f.RecommendList[Uid]; ok {
-			v.Time = GoUtil.Now()
+		v.Time = now
-			return
+		return
-		}
 	}
 	f.RecommendList[Uid] = &Recommend{
 		Uid:  Uid,
-		Time: GoUtil.Now(),
+		Time: now,
 	}
 }
 
+// 获取好友推荐时间
 func (f *FriendMod) GetRecommendTime(uid int) int64 {
 	if recommend, ok := f.RecommendList[uid]; ok {
 		return recommend.Time

src/server/game/mod/friend_treasure.go/friend_treasure.go

@@ -29,40 +29,45 @@ const (
 	GAME_STATUS_END   = 2 // 结束
 )
 
+// 初始化数据
 func (f *FriendTreasureMod) InitData() {
 	if f.List == nil {
 		f.List = make(map[int]*msg.TreasureInfo)
 	}
 }
 
+// 零点重置
 func (f *FriendTreasureMod) ZeroUpdate() {
 	f.Shift = 0
-	f.Pos = []int{}
+	f.Pos = nil
 	f.List = make(map[int]*msg.TreasureInfo)
-	f.List2 = []int32{}
+	f.List2 = nil
-	f.Uids = []int64{}
+	f.Uids = nil
 	f.Status = GAME_STATUS_IDLE
 }
 
+// 初始化游戏数据
 func (f *FriendTreasureMod) InitGame(List []*msg.TreasureInfo, List2 []int32) {
 	for _, v := range List {
 		f.List[int(v.Pos)] = v
 	}
 	f.List2 = List2
-	f.Status = 1
+	f.Status = GAME_STATUS_START
 }
 
+// 增加星级
 func (f *FriendTreasureMod) AddStar(Star int) {
 	f.Star = min(200, f.Star+Star)
 }
 
+// 翻牌
 func (f *FriendTreasureMod) Flip(Pos int) ([]*item.Item, int64, error) {
 	if f.Status == GAME_STATUS_IDLE {
 		return nil, 0, fmt.Errorf("game not start")
 	}
 	f.Shift++
 	Info := f.List[Pos]
-	//log.Debug("pos:%v, info:%v", Pos, Info)
+	Info.Status = GAME_STATUS_START
 	if Info.Uid != 0 {
 		log.Debug("uid:%v", Info.Uid)
 		f.Uids = append(f.Uids, Info.Uid)
@@ -70,17 +75,16 @@ func (f *FriendTreasureMod) Flip(Pos int) ([]*item.Item, int64, error) {
 	if Info.Type == FRIEND_TYPE_ALIVE {
 		ProbMap := friendTreasureCfg.GetChestProb()
 		Prob := GoUtil.RandMap(ProbMap)
-		Info.Status = GAME_STATUS_START
 		Items := friendTreasureCfg.GetChestItems(Prob)
-		if Items == nil {
+		if Items != nil {
 			f.BoxItems = append(f.BoxItems, Items...)
 		}
 		return Items, Info.Uid, nil
 	}
-	Info.Status = GAME_STATUS_START
 	return nil, 0, nil
 }
 
+// 结束游戏
 func (f *FriendTreasureMod) EndGame() ([]*item.Item, int, error) {
 	if f.Status == GAME_STATUS_IDLE {
 		return nil, 0, fmt.Errorf("game is over")
@@ -100,11 +104,12 @@ func (f *FriendTreasureMod) EndGame() ([]*item.Item, int, error) {
 	return Reward, FriendItemNum, nil
 }
 
+// 重置游戏数据
 func (f *FriendTreasureMod) ResetGame() {
 	f.Star = 0
 	f.Shift = 0
 	f.Status = GAME_STATUS_END
-	f.BoxItems = []*item.Item{}
+	f.BoxItems = nil
 }
 
 func (f *FriendTreasureMod) NotifyStar() *msg.ResFriendTreasureStar {
@@ -114,7 +119,7 @@ func (f *FriendTreasureMod) NotifyStar() *msg.ResFriendTreasureStar {
 }
 
 func (f *FriendTreasureMod) BackData() *msg.ResFriendTreasure {
-	TreasureInfoList := make([]*msg.TreasureInfo, 0)
+	TreasureInfoList := make([]*msg.TreasureInfo, 0, len(f.List))
 
 	for _, v := range f.List {
 		TreasureInfoList = append(TreasureInfoList, v)

src/server/game/mod/guess_color/guess_color.go

@@ -44,10 +44,9 @@ func (g *GuessColorMod) InitData() {
 	}
 	if g.Opponent.Name == "" {
 		g.Opponent = simplePlayer{
-			Name:     randnameCfg.GetRandName(),
+			Name:   randnameCfg.GetRandName(),
-			Face:     GoUtil.RandNum(1, 10),
+			Face:   GoUtil.RandNum(1, 10),
-			Avatar:   GoUtil.RandNum(1, 10),
+			Avatar: GoUtil.RandNum(1, 10),
-			Progress: 0,
 		}
 	}
 }
@@ -56,7 +55,7 @@ func (g *GuessColorMod) Login(Id int) int {
 	OldId := g.Id
 	if Id == 0 {
 		g.Id = 0
-		return g.Id
+		return 0
 	}
 	if g.Id == Id {
 		return 0
@@ -64,14 +63,13 @@ func (g *GuessColorMod) Login(Id int) int {
 	g.Id = Id
 	g.Pass = 1
 	g.Opponent = simplePlayer{
-		Name:     randnameCfg.GetRandName(),
+		Name:   randnameCfg.GetRandName(),
-		Face:     GoUtil.RandNum(1, 10),
+		Face:   GoUtil.RandNum(1, 10),
-		Avatar:   GoUtil.RandNum(1, 10),
+		Avatar: GoUtil.RandNum(1, 10),
-		Progress: 0,
 	}
 	g.Guess = 0
-	g.MapList = make([]map[int32]int32, 0)
+	g.MapList = nil
-	g.OMap = make(map[int32]int32)
+	g.OMap = nil
 	g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
 	return OldId
 }
@@ -88,6 +86,7 @@ func (g *GuessColorMod) FirstIn() []*item.Item {
 	return guesscolorCfg.GetFirstItem(g.Id)
 }
 
+// 进行猜色
 func (g *GuessColorMod) Take(Map map[int32]int32, OMap map[int32]int32) {
 	if len(Map) > 0 {
 		g.MapList = append(g.MapList, Map)
@@ -96,6 +95,7 @@ func (g *GuessColorMod) Take(Map map[int32]int32, OMap map[int32]int32) {
 	g.OMap = OMap
 }
 
+// 获取失败奖励
 func (g *GuessColorMod) GetLoseItem() []*item.Item {
 	Items := guesscolorCfg.GetLoseItem(g.Id)
 	Num := guesscolorCfg.GetPassNum(g.Pass)
@@ -110,11 +110,11 @@ func (g *GuessColorMod) GetLoseItem() []*item.Item {
 	return item.MutilItem(Items, Num)
 }
 
+// 获取奖励
 func (g *GuessColorMod) GetReward() ([]*item.Item, error) {
 	if g.Pass == 0 {
 		return nil, fmt.Errorf("not pass")
 	}
-	//	Num := guesscolorCfg.GetPassNum(g.Pass)
 	if g.Guess < g.WinTime {
 		return nil, fmt.Errorf("guess process not finish")
 	}
@@ -126,7 +126,7 @@ func (g *GuessColorMod) GetReward() ([]*item.Item, error) {
 	g.Pass++
 	g.Guess = 0
 	g.WinTime = guesscolorCfg.GetWinTime(g.Pass)
-	g.MapList = make([]map[int32]int32, 0)
+	g.MapList = nil
-	g.OMap = make(map[int32]int32)
+	g.OMap = nil
 	return Item, nil
 }

src/server/game/mod/guide/Guide.go

@@ -24,10 +24,7 @@ func (g *Guide) InitData() {
 
 func (g *Guide) GetReward(Id int) ([]*item.Item, error) {
 	Items, Num := guidecfg.GetGuideReward(Id)
-	n, ok := g.Reward[Id]
+	n := g.Reward[Id]
-	if !ok {
-		n = 0
-	}
 	if n >= Num {
 		return nil, fmt.Errorf("Guide GetReward Id:%v has been received", Id)
 	}
@@ -35,11 +32,6 @@ func (g *Guide) GetReward(Id int) ([]*item.Item, error) {
 	return Items, nil
 }
 
-func (g *Guide) CheckFinishFirstTask() bool {
-	_, ok := g.Reward[4]
-	return ok
-}
-
 func (g *Guide) BackData() *msg.ResGuideInfo {
 	return &msg.ResGuideInfo{
 		Reward: GoUtil.MapIntToInt32(g.Reward),

src/server/game/mod/guide_task/guide_task.go

@@ -56,6 +56,7 @@ func (gt *GuideTaskMod) Login() {
 	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 {
@@ -66,12 +67,14 @@ func (gt *GuideTaskMod) Unlock(lv int) bool {
 	return false
 }
 
+const guideTaskOpenSeconds = 96 * 3600 // 96小时内可以打开
+
 func (gt *GuideTaskMod) CheckOpen() bool {
 	// 检查是否可以打开引导任务
 	if gt.UnlockTime == 0 {
 		return false
 	}
-	return GoUtil.Now()-gt.UnlockTime <= 96*3600 // 96小时内可以打开
+	return GoUtil.Now()-gt.UnlockTime <= guideTaskOpenSeconds
 }
 
 func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
@@ -79,37 +82,36 @@ func (gt *GuideTaskMod) Trigger(Tr *quest.Trigger) bool {
 		return false
 	}
 	update := false
-	for k, v := range gt.Tasks {
+	for _, 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)
+		update = quest.TriggerQuestProgress(&v.Quest, Tr) || update
-		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 {
+	task, ok := gt.Tasks[Id]
-		if task.Status == quest.QUEST_STATUS_FINISH {
+	if !ok {
-			task.Status = quest.QUEST_STATUS_REWARD
+		return nil, fmt.Errorf("guide task %d not found", Id)
-			Active := GuideTaskCfg.GetTaskActive(Id)
-			gt.Active += Active
-			return GuideTaskCfg.GetTaskRewardById(Id), nil
-		}
 	}
-	return nil, fmt.Errorf("no task id %d", Id)
+	if task.Status != quest.QUEST_STATUS_FINISH {
+		return nil, fmt.Errorf("guide task %d not finished or already claimed", Id)
+	}
+	task.Status = quest.QUEST_STATUS_REWARD
+	gt.Active += GuideTaskCfg.GetTaskActive(Id)
+	return GuideTaskCfg.GetTaskRewardById(Id), nil
 }
 
+// 获取活跃度奖励
 func (gt *GuideTaskMod) GetActiveReward(Id int) ([]*item.Item, error) {
 	for _, v := range gt.Reward {
 		if v == Id {
@@ -131,7 +133,7 @@ func (gt *GuideTaskMod) BackData() *msg.ResGuideTask {
 	if !gt.CheckOpen() {
 		return nil
 	}
-	resTask := make(map[int32]*msg.GuideTask)
+	resTask := make(map[int32]*msg.GuideTask, len(gt.Tasks))
 	for k, v := range gt.Tasks {
 		resTask[int32(k)] = &msg.GuideTask{
 			Status:   int32(v.Status),

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

@@ -67,23 +67,23 @@ func (h *Handbook) CollectItem(Id string, AllChess []int) ([]*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("奖励不存在")
 	}
+	h.Collect[Id] = struct{}{}
 	return Reward, nil
 }
 
 func (h *Handbook) BackData() *msg.Handbook {
-	var BookList []*msg.HandbookInfo
+	BookList := make([]*msg.HandbookInfo, 0, len(h.BookList))
 	for k, v := range h.BookList {
 		BookList = append(BookList, &msg.HandbookInfo{
 			ChessId: int32(k),
 			Status:  int32(v),
 		})
 	}
-	Collect := []string{}
+	Collect := make([]string, 0, len(h.Collect))
 	for k := range h.Collect {
 		Collect = append(Collect, k)
 	}

src/server/game/mod/invite/invite.go

@@ -27,10 +27,11 @@ func (i *InviteMod) GetReward(Index int) ([]*item.Item, error) {
 	if Index <= i.GetIndex {
 		return nil, fmt.Errorf("index error")
 	}
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
-	for i.GetIndex < Index {
+	cur := i.GetIndex
-		i.GetIndex++
+	for cur < Index {
-		Need, Reward := inviteCfg.GetInviteReward(i.GetIndex)
+		cur++
+		Need, Reward := inviteCfg.GetInviteReward(cur)
 		if Need == 0 {
 			return nil, fmt.Errorf("invite reward not found")
 		}
@@ -39,6 +40,7 @@ func (i *InviteMod) GetReward(Index int) ([]*item.Item, error) {
 		}
 		Items = item.Merge(Items, Reward)
 	}
+	i.GetIndex = cur
 	return Items, nil
 }
 

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

@@ -23,7 +23,7 @@ const (
 	ITEM_FIVE_STAR_CARD_PACK  = 100008
 	ITEM_RACING_BATTERY_ID    = 100027
 	ITEM_LAUNCHER_ID          = 1602
-	ITEM_LAUNCHER_lOW_ID      = 1601
+	ITEM_LAUNCHER_LOW_ID      = 1601
 	ITEM_ENERGY_GIFT_ID       = 562
 	ITEM_DIAMOND_LV2_ID       = 502
 	ITEM_PLAYROOM_BOX_LOW_ID  = 101445
@@ -43,7 +43,7 @@ const (
 	ITEM_TYPE_BAG                     = 99  // 背包
 	ITEM_TYPE_CHESS                   = 100 // 棋子
 	ITEM_TYPE_CARD_PACK               = 101 // 卡包
-	ITEM_TYPE_LIMIED_TIME_EVENT       = 102 //限时事件
+	ITEM_TYPE_LIMITED_TIME_EVENT      = 102 //限时事件
 	ITEM_TYPE_PIGGY_BANK              = 103 // 猪猪银行
 	ITEM_TYPE_MASTER_CARD             = 104 // 万能卡
 	ITEM_TYPE_AVATAR                  = 105 // 头像框
@@ -70,10 +70,10 @@ func (i *ItemMod) InitData() {
 }
 
 func (i *ItemMod) AddItem(id, num int) error {
-	i.Data[id] += num
+	if i.Data[id]+num < 0 {
-	if i.Data[id] < 0 {
 		return fmt.Errorf("item %d not enough", id)
 	}
+	i.Data[id] += num
 	i.Cache[id] += num
 	return nil
 }
@@ -104,7 +104,7 @@ func (i *ItemMod) CheckItem(id, num int) bool {
 }
 
 func (i *ItemMod) BackData() *msg.ResItem {
-	var data = make(map[int32]int32)
+	data := make(map[int32]int32, len(i.Data))
 	for k, v := range i.Data {
 		data[int32(k)] = int32(v)
 	}
@@ -114,7 +114,7 @@ func (i *ItemMod) BackData() *msg.ResItem {
 }
 
 func (i *ItemMod) NotifyItem() *msg.ItemNotify {
-	var data = make(map[int32]int32)
+	data := make(map[int32]int32, len(i.Cache))
 	for k, v := range i.Cache {
 		data[int32(k)] = int32(v)
 	}
@@ -137,8 +137,9 @@ func ParseItem(item interface{}) []*Item {
 	if item == nil {
 		return nil
 	}
-	itemList := make([]*Item, 0)
+	raw := item.([]interface{})
-	for _, v := range item.([]interface{}) {
+	itemList := make([]*Item, 0, len(raw))
+	for _, v := range raw {
 		v1 := v.(map[string]interface{})
 		itemList = append(itemList, NewItem(int(v1["Id"].(float64)), int(v1["Num"].(float64))))
 	}
@@ -150,7 +151,7 @@ func ItemToMsg(items []*Item) []*msg.ItemInfo {
 	if items == nil {
 		return nil
 	}
-	itemList := make([]*msg.ItemInfo, 0)
+	itemList := make([]*msg.ItemInfo, 0, len(items))
 	for _, v := range items {
 		itemList = append(itemList, &msg.ItemInfo{
 			Id:  int32(v.Id),

src/server/game/mod/limited_time_event/limited_time_event.go

@@ -118,23 +118,7 @@ func (l *LimitedTimeEventMod) InitData(Lv int) {
 		SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
 		BonusLv := limitedTimeEventCfg.GetBonusLv(Lv)
 		RandMap := limitedTimeEventCfg.GetProgressRewardRand(BonusLv)
-		n := 0
+		l.fillProgressReward(RandMap, SelectNum)
-		r := make([]int, 0)
-		LastOption := l.LastOption
-		for n < 10 {
-			n++
-			r = GoUtil.RandMapNum(RandMap, SelectNum)
-			Id := 1
-			for _, v := range r {
-				l.ProgressReward[Id] = v
-				Id++
-			}
-
-			if !GoUtil.SliceEqual(LastOption, r) {
-				break
-			}
-		}
-		l.LastOption = r
 	}
 }
 
@@ -198,7 +182,11 @@ func (l *LimitedTimeEventMod) Trigger(Lv int) (int, []int, []int) {
 			continue
 		}
 		NowRemain := (v.StartT + v.Remian) - Now
-		Remain = GoUtil.IfTrue(Remain > 0, min(Remain, int(NowRemain)), int(NowRemain)).(int)
+		if Remain > 0 {
+			Remain = min(Remain, int(NowRemain))
+		} else {
+			Remain = int(NowRemain)
+		}
 	}
 	return Remain, TimeoutEvent, AddEvent
 }
@@ -364,25 +352,27 @@ func (l *LimitedTimeEventMod) SelectProgressReward(Id, Lv, Energy int) ([]*item.
 		// 参与猫咪大甩卖活动时，猫咪大甩卖事件不进池子
 		delete(RandMap, limitedTimeEventCfg.GetJackpotIdByType(EVENT_TYPE_CAT_DAY_SALE))
 	}
-	n := 0
+	l.fillProgressReward(RandMap, SelectNum)
-	r := make([]int, 0)
+	l.FirstReward = true
+	return Item, limitedTimeEventCfg.GetProgressRewardType(RewardId), OrderNum, RewardList, nil
+}
+
+// fillProgressReward 随机填充进度奖励（最多尝试10次避免与上次相同）
+func (l *LimitedTimeEventMod) fillProgressReward(RandMap map[int]int, SelectNum int) {
 	LastOption := l.LastOption
-	for n < 10 {
+	var r []int
-		n++
+	for n := 0; n < 10; n++ {
 		r = GoUtil.RandMapNum(RandMap, SelectNum)
 		Id := 1
 		for _, v := range r {
 			l.ProgressReward[Id] = v
 			Id++
 		}
-
 		if !GoUtil.SliceEqual(LastOption, r) {
 			break
 		}
 	}
 	l.LastOption = r
-	l.FirstReward = true
-	return Item, limitedTimeEventCfg.GetProgressRewardType(RewardId), OrderNum, RewardList, nil
 }
 
 func (l *LimitedTimeEventMod) RemoveSuperOrder() bool {
@@ -410,10 +400,10 @@ func (l *LimitedTimeEventMod) LuckyCat(ChessId int) error {
 }
 
 func (l *LimitedTimeEventMod) AddCatTrickEnergy(Energy int) {
-	if l.EventList[EVENT_TYPE_CAT_TRICK] == nil {
+	Event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
+	if !ok {
 		return
 	}
-	Event := l.EventList[EVENT_TYPE_CAT_TRICK]
 	if Event.Remian+Event.StartT <= GoUtil.Now() {
 		return
 	}
@@ -423,26 +413,15 @@ func (l *LimitedTimeEventMod) AddCatTrickEnergy(Energy int) {
 }
 
 func (l *LimitedTimeEventMod) SubPaybackDay() error {
-	// 2026.1.20 改版 不限制次数
-	// if l.EventList[EVENT_TYPE_PAYBACK_DAY] == nil {
-	// 	return fmt.Errorf("PaybackDay event not exist")
-	// }
-	// d := l.EventList[EVENT_TYPE_PAYBACK_DAY].D.(*PaybackDay)
-	// if d.count <= 0 {
-	// 	return fmt.Errorf("PaybackDay count is 0")
-	// }
-	// d.count--
-	// if d.count <= 0 {
-	// 	delete(l.EventList, EVENT_TYPE_PAYBACK_DAY)
-	// }
 	return nil
 }
 
 func (l *LimitedTimeEventMod) GetCatTrickReward() ([]*item.Item, error) {
-	if l.EventList[EVENT_TYPE_CAT_TRICK] == nil {
+	Event, ok := l.EventList[EVENT_TYPE_CAT_TRICK]
+	if !ok {
 		return nil, fmt.Errorf("CatTrick event not exist")
 	}
-	d := l.EventList[EVENT_TYPE_CAT_TRICK].D.(*CatTrick)
+	d := Event.D.(*CatTrick)
 	if d.Energy < 100 {
 		return nil, fmt.Errorf("CatTrick energy not enough")
 	}
@@ -463,14 +442,12 @@ func initEventInfo(E *LTEInfo, EventType int) {
 		}
 	case EVENT_TYPE_MONEY_CAT:
 		E.D = &MoneyCat{
-			Id:      1,
+			Id:  1,
-			EndTime: 0,
+			Mul: 1.1,
-			Mul:     1.1,
 		}
 	case EVENT_TYPE_LUCKY_CAT:
 		MaxEarning := limitedTimeEventCfg.GetLuckyCatMaxEarning(int(E.Remian))
 		E.D = &LuckyCat{
-			Earnings:   0,
 			MaxEarings: MaxEarning,
 		}
 	case EVENT_TYPE_PAYBACK_DAY:
@@ -511,7 +488,7 @@ func addEventInfo(E *LTEInfo, EventType, Duration int) {
 func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent {
 	Cd := 0
 	Mul := 0.0
-	Param := make(map[string]int32, 0)
+	Param := make(map[string]int32)
 	ShowTime := int32(e.StartT + e.Remian)
 	EndTime := int32(e.StartT + e.Remian)
 	switch t {
@@ -550,13 +527,14 @@ func getLimitEventMsg(t int, e *LTEInfo) *msg.LimitEvent {
 	}
 }
 
-func (l LimitedTimeEventMod) EndCatDaySale() {
+func (l *LimitedTimeEventMod) EndCatDaySale() {
 	delete(l.EventList, EVENT_TYPE_CAT_DAY_SALE)
 }
 
-func (l LimitedTimeEventMod) GetCatDaySaleEndTime() int64 {
+func (l *LimitedTimeEventMod) GetCatDaySaleEndTime() int64 {
-	if l.EventList[EVENT_TYPE_CAT_DAY_SALE] == nil {
+	v, ok := l.EventList[EVENT_TYPE_CAT_DAY_SALE]
+	if !ok {
 		return 0
 	}
-	return l.EventList[EVENT_TYPE_CAT_DAY_SALE].StartT + l.EventList[EVENT_TYPE_CAT_DAY_SALE].Remian
+	return v.StartT + v.Remian
 }

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

@@ -82,14 +82,12 @@ func (m *MailMod) SendMail(mail *MailStruct) int {
 	}
 	m.AutoId++
 	m.List[m.AutoId] = &MailInfo{
-		Title:    mail.Title,
+		Title:           mail.Title,
-		SubTitle: mail.SubTitle,
+		SubTitle:        mail.SubTitle,
-		Content:  mail.Content,
+		Content:         mail.Content,
-
+		TitleEn:         mail.TitleEn,
-		TitleEn:    mail.TitleEn,
+		SubTitleEn:      mail.SubTitleEn,
-		SubTitleEn: mail.SubTitleEn,
+		ContentEn:       mail.ContentEn,
-		ContentEn:  mail.ContentEn,
-
 		TitlePtBr:       mail.TitlePtBr,
 		SubTitlePtBr:    mail.SubTitlePtBr,
 		ContentPtBr:     mail.ContentPtBr,
@@ -99,7 +97,6 @@ func (m *MailMod) SendMail(mail *MailStruct) int {
 		Items:           mail.Items,
 		Send:            GoUtil.Now(),
 		Type:            mail.Type,
-		Status:          MAIL_STATUS_IDLE,
 	}
 	return m.AutoId
 }
@@ -146,59 +143,46 @@ func (m *MailMod) Del(id int) error {
 func (m *MailMod) BackData() *msg.ResMailList {
 	return &msg.ResMailList{}
 	res := &msg.ResMailList{
-		MailList: make(map[int32]*msg.MailInfo),
+		MailList: make(map[int32]*msg.MailInfo, len(m.List)),
 	}
 	for k, v := range m.List {
 		if v.Status == MAIL_STATUS_DEL {
 			continue
 		}
-		res.MailList[int32(k)] = &msg.MailInfo{
+		res.MailList[int32(k)] = mailInfoToMsg(k, v)
-			Id:           int32(k),
-			Title:        v.Title,
-			SubTitle:     v.SubTitle,
-			Content:      v.Content,
-			TitleEn:      v.TitleEn,
-			SubTitleEn:   v.SubTitleEn,
-			ContentEn:    v.ContentEn,
-			TitlePtBr:    v.TitlePtBr,
-			SubTitlePtBr: v.SubTitlePtBr,
-			ContentPtBr:  v.ContentPtBr,
-			TitleEsLa:    v.TitleEsLatam,
-			SubTitleEsLa: v.SubTitleEsLatam,
-			ContentEsLa:  v.ContentEsLatam,
-			Type:         int32(v.Type),
-			Items:        item.ItemToMsg(v.Items),
-			Status:       int32(v.Status),
-			Time:         int32(v.Send),
-		}
 	}
 	return res
 }
 
 func (m *MailMod) NotifyMail(Id int) *msg.MailNotify {
-	mailInfo := m.List[Id]
+	mailInfo, ok := m.List[Id]
+	if !ok {
+		return nil
+	}
 	return &msg.MailNotify{
-		Info: &msg.MailInfo{
+		Info: mailInfoToMsg(Id, mailInfo),
-			Id:         int32(Id),
+	}
-			Title:      mailInfo.Title,
+}
-			Content:    mailInfo.Content,
-			ContentEn:  mailInfo.ContentEn,
-			SubTitle:   mailInfo.SubTitle,
-			SubTitleEn: mailInfo.SubTitleEn,
-			TitleEn:    mailInfo.TitleEn,
 
-			TitlePtBr:    mailInfo.TitlePtBr,
+func mailInfoToMsg(id int, v *MailInfo) *msg.MailInfo {
-			SubTitlePtBr: mailInfo.SubTitlePtBr,
+	return &msg.MailInfo{
-			ContentPtBr:  mailInfo.ContentPtBr,
+		Id:           int32(id),
-
+		Title:        v.Title,
-			TitleEsLa:    mailInfo.TitleEsLatam,
+		SubTitle:     v.SubTitle,
-			SubTitleEsLa: mailInfo.SubTitleEsLatam,
+		Content:      v.Content,
-			ContentEsLa:  mailInfo.ContentEsLatam,
+		TitleEn:      v.TitleEn,
-			Type:         int32(mailInfo.Type),
+		SubTitleEn:   v.SubTitleEn,
-			Items:        item.ItemToMsg(mailInfo.Items),
+		ContentEn:    v.ContentEn,
-			Status:       int32(mailInfo.Status),
+		TitlePtBr:    v.TitlePtBr,
-			Time:         int32(mailInfo.Send),
+		SubTitlePtBr: v.SubTitlePtBr,
-		},
+		ContentPtBr:  v.ContentPtBr,
+		TitleEsLa:    v.TitleEsLatam,
+		SubTitleEsLa: v.SubTitleEsLatam,
+		ContentEsLa:  v.ContentEsLatam,
+		Type:         int32(v.Type),
+		Items:        item.ItemToMsg(v.Items),
+		Status:       int32(v.Status),
+		Time:         int32(v.Send),
 	}
 }
 

src/server/game/mod/mining/mining.go

@@ -31,10 +31,10 @@ func (m *MiningMod) Login(Id int) int {
 	}
 	m.Id = Id
 	m.Map = make(map[int32]string)
-	m.Gem = make([]int, 0)
+	m.Gem = nil
 	m.Pass = 1
 	m.Mining = 0
-	return m.Id
+	return OldId
 }
 
 func (m *MiningMod) ZeroUpdate(Id int) {
@@ -58,27 +58,27 @@ func (m *MiningMod) GetMining() int {
 }
 
 func (m *MiningMod) Take(Map map[int32]string, Gem int) ([]*item.Item, error) {
-	m.Map = Map
-	m.Mining++
 	AreaNum := miningCfg.GetPassArea(m.Pass)
 	if AreaNum == 0 {
 		return nil, fmt.Errorf("pass is not exist")
 	}
-	if m.Mining > AreaNum {
+	if m.Mining+1 > AreaNum {
 		return nil, fmt.Errorf("mining is full")
 	}
 	if Gem > 0 {
-		m.Gem = append(m.Gem, Gem)
 		GemList := miningCfg.GetPassGem(m.Pass)
-		if len(m.Gem) > len(GemList) {
+		if len(m.Gem)+1 > len(GemList) {
 			return nil, fmt.Errorf("gem is full")
 		}
-	} else {
+		m.Map = Map
-		Items := miningCfg.GetRandItem()
+		m.Mining++
-		return Items, nil
+		m.Gem = append(m.Gem, Gem)
+		return nil, nil
 	}
-
+	m.Map = Map
-	return nil, nil
+	m.Mining++
+	Items := miningCfg.GetRandItem()
+	return Items, nil
 }
 
 func (m *MiningMod) GetReward() ([]*item.Item, int, error) {
@@ -90,7 +90,7 @@ func (m *MiningMod) GetReward() ([]*item.Item, int, error) {
 	m.Pass++
 	Ming := m.Mining
 	m.Mining = 0
-	m.Map = make(map[int32]string)
+	m.Map = nil
-	m.Gem = make([]int, 0)
+	m.Gem = nil
 	return Items, Ming, nil
 }

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

@@ -53,6 +53,8 @@ const (
 	HANDLE_MOD_CHAMPSHIP_RANK_LIST = 20015 // 锦标赛排行榜
 	HANDLE_MOD_CHAMPSHIP_PRE_RANK  = 20016 // 锦标赛上期排名
 	HANDLE_MOD_CHAMPSHIP_GROUP     = 20017 // 锦标赛分组
+	HANDLE_MOD_DAILY_VAR_GET       = 20018 // 获取变量
+	HANDLE_MOD_DAILY_VAR_SET       = 20019 // 设置变量
 )
 
 const (

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

@@ -47,7 +47,7 @@ type Order struct {
 var PreheatItems = map[int][]*item.Item{
 	1: {item.NewItem(item.ITEM_ENERGY_GIFT_ID, 1)},
 	2: {item.NewItem(item.ITEM_DIAMOND_LV2_ID, 1)},
-	3: {item.NewItem(item.ITEM_LAUNCHER_lOW_ID, 1)},
+	3: {item.NewItem(item.ITEM_LAUNCHER_LOW_ID, 1)},
 }
 
 const (
@@ -379,7 +379,7 @@ func (o *OrderMod) CreateNormalOrderSeed(lv int, Emit []int, EnergyMul int, Diff
 			break
 		}
 		randNum++
-		mergeList, _, err = randOrderChessSeed(o, lv, Emit, EnergyMul, Diff)
+		mergeList, _, err = randOrderChessSeed(o, Emit, EnergyMul, Diff)
 		if err != nil {
 			continue
 		}
@@ -725,7 +725,7 @@ func (o *OrderMod) CreateComfortOrder(lv int, Emit []int, EnergyMul, Diff, Chess
 			break
 		}
 		randNum++
-		mergeList, _, err = randOrderChessWithDiff(o, lv, Emit, EnergyMul, Diff, ChessNum)
+		mergeList, _, err = randOrderChessWithDiff(o, Emit, EnergyMul, Diff, ChessNum)
 		if err != nil {
 			continue
 		}

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

@@ -1,7 +1,6 @@
 package order
 
 import (
-	"log"
 	"math"
 	mergeDataCfg "server/conf/merge_data"
 	orderCfg "server/conf/order"
@@ -90,17 +89,8 @@ type orderConfigInfo struct {
 	t      int
 }
 
-// 订单棋子数量
-// func getChessNumRand(OrderN int) map[int]int {
-// 	return map[int]int{
-// 		1: int(70 - 2*OrderN),
-// 		2: int(25 + OrderN),
-// 		3: int(5 + OrderN),
-// 	}
-// }
-
 // 根据上一个订单难度和系数 生成订单难度
-func getOrderDiffRand(Lv, Diff, OrderN int) map[int]int {
+func getOrderDiffRand(Lv, Diff int) map[int]int {
 	var d map[int]int
 	if Lv < 24 {
 		switch Diff {
@@ -167,7 +157,7 @@ func getChessByDiff(Lv, Diff, Type int) (int, int, int) {
 }
 
 // 根据订单难度生成棋子难度
-func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
+func getChessDiff(ChessNum, OrderDiff int) map[int]int {
 	var rs map[int]int
 	switch ChessNum {
 	case 1:
@@ -426,7 +416,7 @@ func GetVirtualEnergy(MergeList, EmitList []int) int {
 	return eneryg
 }
 
-// 随机生成超级订单棋子
+// randSuperOrderChess 随机生成超级订单棋子
 func randSuperOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
 	filterPool(o)
@@ -438,76 +428,25 @@ func randSuperOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff i
 	if err != nil {
 		return nil, DIFF_LOW, err
 	}
-	// 生成订单难度和棋子数量
 	ChessNum := GoUtil.RandMap(RandChessNum)
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
+	ChessDiff := getChessDiff(ChessNum, OrderDiff)
-	mergeList := make([]int, 0, len(ChessDiff))
+	return buildMergeListFromDiff(o, ChessDiff, Emit, EnergyMul, OrderDiff)
-	// 根据订单棋子难度生成棋子
-	for _, v := range ChessDiff {
-		ChessId := 0
-		Num := 0
-		for {
-			Num++
-			if Num > 50 {
-				break
-			}
-			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
-			if ChessId == 0 {
-				continue
-			}
-			if !GoUtil.InArray(ChessId, mergeList) {
-				break
-			}
-		}
-		mergeList = append(mergeList, ChessId)
-	}
-	return mergeList, OrderDiff, nil
 }
 
-// 随机生成超级订单棋子
+// randOrderChessWithDiff 随机生成订单棋子
-func randOrderChessWithDiff(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff, ChessNum int) ([]int, int, error) {
+func randOrderChessWithDiff(o *OrderMod, Emit []int, EnergyMul, OrderDiff, ChessNum int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
 	filterPool(o)
-	OrderN, err := userCfg.GetOrderNByLv(lv)
+	ChessDiff := getChessDiff(ChessNum, OrderDiff)
-	if err != nil {
+	return buildMergeListFromDiff(o, ChessDiff, Emit, EnergyMul, OrderDiff)
-		return nil, DIFF_LOW, err
-	}
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
-	mergeList := make([]int, 0, len(ChessDiff))
-	// 根据订单棋子难度生成棋子
-	for _, v := range ChessDiff {
-		ChessId := 0
-		Num := 0
-		for {
-			Num++
-			if Num > 50 {
-				break
-			}
-			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
-			if ChessId == 0 {
-				continue
-			}
-			if !GoUtil.InArray(ChessId, mergeList) {
-				break
-			}
-		}
-		mergeList = append(mergeList, ChessId)
-	}
-	return mergeList, OrderDiff, nil
 }
 
 // 随机生成订单棋子
 func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul, OrderType int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
 	filterPool(o)
-	OrderN, err := userCfg.GetOrderNByLv(lv)
-	//RandChessNum := getChessNumRand(OrderN)
-	if err != nil {
-		return nil, DIFF_LOW, err
-	}
 	// 生成订单难度和棋子数量
-	//ChessNum := GoUtil.RandMap(RandChessNum)
+	OrderDiffRand := getOrderDiffRand(lv, o.LastDiff)
-	OrderDiffRand := getOrderDiffRand(lv, o.LastDiff, OrderN)
 	OrderDiff := GoUtil.RandMap(OrderDiffRand)
 	if o.NextDiff != 0 {
 		OrderDiff = o.NextDiff
@@ -519,31 +458,21 @@ func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul, OrderType int) (
 	return mergeList, OrderDiff, nil
 }
 
-func randOrderChessSeed(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff int) ([]int, int, error) {
+func randOrderChessSeed(o *OrderMod, Emit []int, EnergyMul, OrderDiff int) ([]int, int, error) {
 	initReflectChess(Emit, EnergyMul)
 	filterPool(o)
-	OrderN, err := userCfg.GetOrderNByLv(lv)
+	ChessDiff := getChessDiff(2, OrderDiff)
-	if err != nil {
+	return buildMergeListFromDiff(o, ChessDiff, Emit, EnergyMul, OrderDiff)
-		return nil, DIFF_LOW, err
+}
-	}
+
-	// 生成订单难度和棋子数量
+// buildMergeListFromDiff 根据棋子难度映射表从池中取棋子（提取三处重复逻辑）
-	ChessNum := 2
+func buildMergeListFromDiff(o *OrderMod, ChessDiff map[int]int, Emit []int, EnergyMul, OrderDiff int) ([]int, int, error) {
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
 	mergeList := make([]int, 0, len(ChessDiff))
-	// 根据订单棋子难度生成棋子
 	for _, v := range ChessDiff {
 		ChessId := 0
-		Num := 0
+		for n := 0; n < 50; n++ {
-		for {
-			Num++
-			if Num > 50 {
-				break
-			}
 			ChessId = getChessFromPoolByDiff(o, v, Emit, EnergyMul)
-			if ChessId == 0 {
+			if ChessId != 0 && !GoUtil.InArray(ChessId, mergeList) {
-				continue
-			}
-			if !GoUtil.InArray(ChessId, mergeList) {
 				break
 			}
 		}
@@ -554,7 +483,7 @@ func randOrderChessSeed(o *OrderMod, lv int, Emit []int, EnergyMul, OrderDiff in
 
 // 筛选棋子池 从中剔除不符合难度的棋子
 func filterPool(o *OrderMod) {
-	NewPool := make([]int, 0)
+	var NewPool []int
 	for _, v := range o.ChessPool {
 		if _, ok := reflectChess[v]; ok {
 			NewPool = append(NewPool, v)
@@ -568,8 +497,8 @@ func ShuffleColor(List []string, Last string) []string {
 		return List
 	}
 	Break := 0
-	List2 := make([]string, len(List))
+	var List2 []string
-	List3 := make([]string, len(List))
+	var List3 []string
 	for _, v := range List {
 		if mergeDataCfg.GetEmitProductNumByColor(v) == 1 {
 			List3 = append(List3, v)
@@ -733,7 +662,7 @@ func GetOrderStar(ChessList []int, EmitList []int) int {
 func GetChessByDiff(EmitId, EnergyMul, Diff int, Color string) []int {
 	ChessMinLv, ChessMaxLv := getChesslvRange(EmitId, EnergyMul, false)
 	LvRange := getChessLvRange(ChessMinLv, ChessMaxLv, Diff)
-	ChessIds := []int{}
+	var ChessIds []int
 	for _, v := range LvRange {
 		NewLev1 := mergeDataCfg.DynamicLev(v, EmitId, Color)
 		MaxLev := mergeDataCfg.GetMaxLvByColor(Color)
@@ -744,7 +673,7 @@ func GetChessByDiff(EmitId, EnergyMul, Diff int, Color string) []int {
 	return GoUtil.UniqueInts(ChessIds)
 }
 func (o *OrderMod) getChessLvFromConfig1(MinEnergy, MaxEnergy, MinLv, MaxLv, LastEnergy int) []int {
-	rand := []int{}
+	var rand []int
 	t := 0
 	if LastEnergy > 0 {
 		t = 1
@@ -758,41 +687,9 @@ func (o *OrderMod) getChessLvFromConfig1(MinEnergy, MaxEnergy, MinLv, MaxLv, Las
 			}
 		}
 	}
-	if len(rand) == 0 {
-		return rand
-	}
 	return rand
 }
 
-// func (o *OrderMod) getChessLvFromConfig2(MinEnergy, MaxEnergy, MinLv, MaxLv, LastEnergy int) []int {
-// 	rand := []int{}
-// 	for _, v := range orderCfgMap {
-// 		if MinEnergy >= v.Min && MaxEnergy <= v.Max {
-// 			for _, info := range v.Pool {
-// 				if MinLv <= info.lv && MaxLv >= info.lv {
-// 					rand = append(rand, info.lv)
-// 				}
-// 			}
-
-// 		}
-// 	}
-// 	return rand
-// }
-// func (o *OrderMod) getChessLvFromConfig3(MinEnergy, MaxEnergy, MinLv, MaxLv, LastEnergy int) []int {
-// 	rand := []int{}
-// 	for _, v := range orderCfgMap {
-// 		if MinEnergy >= v.Min && MaxEnergy <= v.Max {
-// 			for _, info := range v.Pool {
-// 				if MinLv <= info.lv && MaxLv >= info.lv && LastEnergy+info.energy <= MaxEnergy && LastEnergy+info.energy >= MinEnergy {
-// 					rand = append(rand, info.lv)
-// 				}
-// 			}
-
-// 		}
-// 	}
-// 	return rand
-// }
-
 func (o *OrderMod) ChessPoolChess(Color string, Lv int) bool {
 	for _, v := range o.ChessPool2[Color] {
 		if v > Lv {
@@ -830,7 +727,7 @@ func (o *OrderMod) getFromPool(Emit int, Color string, Lv int) {
 	}
 }
 
-func (o *OrderMod) getChessIdPool(Emit []int, Color string, EnergyMul, Lv, MinEnergy, MaxEnergy, OrderDiff, LastEnergy int) (int, int) {
+func (o *OrderMod) getChessIdPool(Emit []int, Color string, EnergyMul, MinEnergy, MaxEnergy, OrderDiff, LastEnergy int) (int, int) {
 	ChessLv := 0
 	EmitChessId := getEmitBySeries(Emit, Color)
 	ChessMinLv, ChessMaxLv := getChesslvRange(EmitChessId, EnergyMul, o.IsCharge)
@@ -873,27 +770,24 @@ func getChessFromPoolByEnergy(o *OrderMod, MinEnergy, MaxEnergy, ChessNum int, E
 		ColorArr = append(ColorArr, getEmitSeries(o, Emit, OrderType))
 	}
 	if len(ColorArr) == 2 && ColorArr[0] == ColorArr[1] {
-		log.Default()
 	}
-	ChessArr := make([]int, 0)
 	if len(ColorArr) == 1 {
-		Chess, _ := o.getChessIdPool(Emit, ColorArr[0], EnergyMul, 0, MinEnergy, MaxEnergy, OrderDiff, 0)
+		Chess, _ := o.getChessIdPool(Emit, ColorArr[0], EnergyMul, MinEnergy, MaxEnergy, OrderDiff, 0)
 		if Chess == 0 {
 			Chess = mergeDataCfg.GetChessIdByLvAndColor(6, ColorArr[0])
 		}
 		return []int{Chess}
 	}
 	if len(ColorArr) == 2 {
-		Chess1, Chess1Lv := o.getChessIdPool(Emit, ColorArr[0], EnergyMul, 0, MinEnergy, MaxEnergy, OrderDiff, 0)
+		Chess1, Chess1Lv := o.getChessIdPool(Emit, ColorArr[0], EnergyMul, MinEnergy, MaxEnergy, OrderDiff, 0)
 		if Chess1 == 0 {
 			Chess1 = mergeDataCfg.GetChessIdByLvAndColor(6, ColorArr[0])
 		}
 		Energy := int(math.Pow(2, float64(Chess1Lv-1)))
-		Chess2, _ := o.getChessIdPool(Emit, ColorArr[1], EnergyMul, 0, MinEnergy, MaxEnergy, OrderDiff, Energy)
+		Chess2, _ := o.getChessIdPool(Emit, ColorArr[1], EnergyMul, MinEnergy, MaxEnergy, OrderDiff, Energy)
 		return []int{Chess1, Chess2}
 	}
-
+	return nil
-	return ChessArr
 }
 
 // 从棋子池中获取棋子

src/server/game/mod/pass/Pass.go

@@ -22,17 +22,18 @@ func (p *PassMod) ZeroUpdate(Id int) {
 }
 
 func (p *PassMod) GetRewardItems() ([]*item.Item, []int) {
-	NewLevel := passCfg.GetNewLevel(passCfg.GetTemplate(p.Id), p.Num, p.Reward)
+	template := passCfg.GetTemplate(p.Id)
+	NewLevel := passCfg.GetNewLevel(template, p.Num, p.Reward)
 	if len(NewLevel) == 0 {
 		return nil, nil
 	}
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
-	Items = append(Items, passCfg.GetFreeChargeItems(passCfg.GetTemplate(p.Id), p.Reward)...)
+	Items = append(Items, passCfg.GetFreeChargeItems(template, p.Reward)...)
 	if p.LowPass != 0 {
-		Items = append(Items, passCfg.GetLowChargeItems(passCfg.GetTemplate(p.Id), p.Reward)...)
+		Items = append(Items, passCfg.GetLowChargeItems(template, p.Reward)...)
 	}
 	if p.HighPass != 0 {
-		Items = append(Items, passCfg.GetHighChargeItems(passCfg.GetTemplate(p.Id), p.Reward)...)
+		Items = append(Items, passCfg.GetHighChargeItems(template, p.Reward)...)
 	}
 	p.Reward = append(p.Reward, NewLevel...)
 	return Items, NewLevel
@@ -51,8 +52,8 @@ func (p *PassMod) Login(Id int) int {
 	p.LowPass = 0
 	p.HighPass = 0
 	p.Num = 0
-	p.Reward = make([]int, 0)
+	p.Reward = nil
-	return p.Id
+	return OldId
 }
 
 func (p *PassMod) GetLowChargeItems() []*item.Item {

src/server/game/mod/piggy_bank/piggy_bank.go

@@ -20,9 +20,6 @@ const (
 )
 
 func (p *PiggyBankMod) InitData() {
-	if p.List == nil {
-		p.List = make([]int, 0)
-	}
 }
 
 func (p *PiggyBankMod) AddPiggyBank(Type int) {
@@ -34,13 +31,11 @@ func (p *PiggyBankMod) Fire(ChargeId int) []*item.Item {
 	if ChargeId != PiggyBankChargeId && ChargeId != 0 {
 		return nil
 	}
-	// Now := GoUtil.Now()
+	reward := []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, p.Diamond)}
-	// if p.EndTime < Now {
+	p.Diamond = 0
-	// 	return nil
-	// }
 	p.EndTime = 0
 	p.TimeOut()
-	return []*item.Item{item.NewItem(item.ITEM_DIAMOND_ID, p.Diamond)}
+	return reward
 }
 
 func (p *PiggyBankMod) TimeOut() int64 {

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

@@ -182,7 +182,6 @@ func (p *PlayroomMod) InitData() {
 			p.NewCollect[v] = &CollectInfo{
 				Id:      v,
 				AddTime: GoUtil.Now(),
-				EndTime: 0,
 				Num:     1,
 			}
 		}
@@ -192,7 +191,6 @@ func (p *PlayroomMod) InitData() {
 			p.NewCollect[k] = &CollectInfo{
 				Id:      k,
 				AddTime: GoUtil.Now(),
-				EndTime: 0,
 				Num:     v,
 			}
 		}
@@ -214,18 +212,12 @@ func (p *PlayroomMod) InitData() {
 	if p.Physiology == nil {
 		p.Physiology = make(map[int]*Physiology)
 	}
-	if p.Reward == nil {
-		p.Reward = make([]*item.Item, 0)
-	}
 	if p.HasVisit == nil {
 		p.HasVisit = make(map[int]int64)
 	}
 	if p.GameReward == nil {
 		p.GameReward = make(map[int]*item.Item)
 	}
-	if p.LoseItem == nil {
-		p.LoseItem = make([]*item.Item, 0)
-	}
 	if p.Flip == nil {
 		p.Flip = make(map[int]int)
 	}
@@ -236,7 +228,7 @@ func (p *PlayroomMod) InitData() {
 		p.DailyTask = make(map[int]*DailyTask)
 	}
 	if len(p.NewPetAir) == 0 {
-		p.NewPetAir = make(map[int]*PetAirInfo, 0)
+		p.NewPetAir = make(map[int]*PetAirInfo)
 		InitPetAir := playroomCfg.GetInitAirList()
 		for _, v := range InitPetAir {
 			p.NewPetAir[v] = &PetAirInfo{
@@ -255,7 +247,7 @@ func (p *PlayroomMod) InitData() {
 				Num:     1,
 			}
 		}
-		p.PetAir = make([]int, 0)
+		p.PetAir = nil
 	}
 	if p.NewDress == nil {
 		p.NewDress = make(map[int]*DressInfo)
@@ -268,8 +260,6 @@ func (p *PlayroomMod) InitData() {
 				Id:      v,
 				Part:    Part,
 				AddTime: GoUtil.Now(),
-				EndTime: 0,
-				Label:   "",
 				Num:     1,
 			}
 		}
@@ -283,13 +273,11 @@ func (p *PlayroomMod) InitData() {
 					Id:      id,
 					Part:    Part,
 					AddTime: GoUtil.Now(),
-					EndTime: 0,
-					Label:   "",
 					Num:     1,
 				}
 			}
 		}
-		p.Dress = make(map[int][]int)
+		p.Dress = nil
 	}
 	if p.ADItem == nil {
 		p.ADItem = make(map[int]*ItemInfo)
@@ -303,9 +291,9 @@ func (p *PlayroomMod) ZeroUpdate() {
 	p.TodayFlip = false
 	p.LastFlip = 0
 	p.JackpotNum = playroomCfg.GetJackpotNum()
-	p.UpvoteList = make([]int, 0)
+	p.UpvoteList = nil
-	p.DailyTaskReward = make([]int, 0)
+	p.DailyTaskReward = nil
-	p.TodayVisitedUsers = make([]int, 0)
+	p.TodayVisitedUsers = nil
 	p.ADItem = make(map[int]*ItemInfo)
 	p.InitDailyTask()
 }
@@ -319,7 +307,6 @@ func (p *PlayroomMod) InitDailyTask() {
 		Quest, _ := quest.ParseQuest(v)
 		p.DailyTask[k] = &DailyTask{
 			Items:  Items,
-			Status: 0,
 			Quest:  Quest,
 			UnLock: true,
 			Index:  Index,
@@ -332,7 +319,6 @@ func (p *PlayroomMod) InitDailyTask() {
 		Quest, _ := quest.ParseQuest(v)
 		p.DailyTask[k] = &DailyTask{
 			Items:  Items,
-			Status: 0,
 			Quest:  Quest,
 			UnLock: false,
 			Index:  Index,
@@ -351,10 +337,7 @@ func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
 		if v.Status != quest.QUEST_STATUS_UNFINISH {
 			continue
 		}
-		up := quest.TriggerQuestProgress(&v.Quest, Tr)
+		update = quest.TriggerQuestProgress(&v.Quest, Tr) || update
-		if up {
-			update = true
-		}
 
 		if v.Quest.Status {
 			v.Status = quest.QUEST_STATUS_FINISH
@@ -396,7 +379,6 @@ func (p *PlayroomMod) GetDailyTaskReward(Id int) ([]*item.Item, error) {
 		return nil, fmt.Errorf("GetDailyTaskReward Status is not finish")
 	}
 	v.Status = quest.QUEST_STATUS_REWARD
-	p.DailyTask[Id] = v
 	return v.Items, nil
 }
 
@@ -471,9 +453,6 @@ func (p *PlayroomMod) SetTarget(Target int) {
 }
 
 func (p *PlayroomMod) SetGameId(GameId int) {
-	// if (p.GameId == GAME_TYPE_HOOK || p.GameId == GAME_TYPE_HIDE) && GameId == GAME_TYPE_HOOK {
-	// 	return
-	// }
 	p.GameId = GameId
 }
 
@@ -481,7 +460,6 @@ func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) {
 	if Star == 0 {
 		return
 	}
-	p.Reward = make([]*item.Item, 0)
 	FoodItem := playroomCfg.GetFoodItem()
 	CleanItem := playroomCfg.GetCleanItem()
 	ToyItem := playroomCfg.GetToyItem()
@@ -495,17 +473,18 @@ func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) {
 		Id  []int
 		Num int
 	}
-	sortList := make([]d, 0)
+	sortList := []d{
-	sortList = append(sortList, d{Id: FoodItem, Num: FoodItemNum})
+		{Id: FoodItem, Num: FoodItemNum},
-	sortList = append(sortList, d{Id: CleanItem, Num: CleanItemNum})
+		{Id: CleanItem, Num: CleanItemNum},
-	sortList = append(sortList, d{Id: ToyItem, Num: ToyItemNum})
+		{Id: ToyItem, Num: ToyItemNum},
-	sortList = append(sortList, d{Id: DailyItem, Num: DailyItemNum})
+		{Id: DailyItem, Num: DailyItemNum},
+	}
 	sort.Slice(sortList, func(i, j int) bool {
 		return sortList[i].Num < sortList[j].Num
 	})
 
 	Prob := GoUtil.RandSlice(sortList[0].Id)
-	p.Reward = append(p.Reward, &item.Item{Id: Prob, Num: 1})
+	p.Reward = []*item.Item{{Id: Prob, Num: 1}}
 }
 
 func (p *PlayroomMod) GetReward() []*item.Item {
@@ -538,7 +517,7 @@ func (p *PlayroomMod) AddInteractNum(Lv int) {
 func (p *PlayroomMod) AddMood(Id, Num int) {
 	_, ok := p.MoodInfo[Id]
 	if !ok {
-		p.MoodInfo[Id] = &Mood{Id: Id, Num: 0}
+		p.MoodInfo[Id] = &Mood{Id: Id}
 	}
 	p.MoodInfo[Id].Num = max(0, min(p.MoodInfo[Id].Num+Num, 100))
 	if p.MoodInfo[Id].Num != 0 && p.MoodInfo[Id].Time == 0 {
@@ -560,7 +539,8 @@ func (p *PlayroomMod) GetMoodNum(MoodType int) int {
 func (p *PlayroomMod) AddPhysiology(Id, Num int) {
 	Phy := p.GetPhysiology(Id)
 	if Phy == nil {
-		Phy = &Physiology{Id: Id, Num: 0, Time: 0}
+		Phy = &Physiology{Id: Id}
+		p.Physiology[Id] = Phy
 	}
 	Max := playroomCfg.GetPhysiologyMax(Id)
 	Phy.Num = max(0, min(Phy.Num+Num, Max))
@@ -601,7 +581,6 @@ func (p *PlayroomMod) AddDress(Id int, Label string) {
 			Id:      Id,
 			Part:    Part,
 			AddTime: GoUtil.Now(),
-			EndTime: 0,
 			Label:   Label,
 			Num:     1,
 		}
@@ -624,7 +603,7 @@ func (p *PlayroomMod) GetGameId() int {
 }
 
 func (p *PlayroomMod) ResetLose() {
-	p.LoseItem = make([]*item.Item, 0)
+	p.LoseItem = nil
 }
 
 func (p *PlayroomMod) SetGameReward(Chess1, Chess2, Star int) {
@@ -654,7 +633,7 @@ func (p *PlayroomMod) SelectReward(Id int) []*item.Item {
 	if !ok {
 		return nil
 	}
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
 	Items = append(Items, v)
 	if Id < 3 {
 		Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 5))
@@ -765,7 +744,7 @@ func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
 }
 
 func (p *PlayroomMod) NotifyLose() *msg.NotifyPlayroomLose {
-	ChipMessage := make([]*msg.ChipInfo, 0)
+	ChipMessage := make([]*msg.ChipInfo, 0, len(p.ChipList))
 	for _, v := range p.ChipList {
 		ChipMessage = append(ChipMessage, &msg.ChipInfo{
 			Uid: int64(v.Uid),
@@ -794,11 +773,11 @@ func (p *PlayroomMod) NotifyStatus() *msg.NofiPlayroomStatus {
 }
 
 func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
-	Mood := make(map[int32]int32, 0)
+	Mood := make(map[int32]int32)
 	for k, v := range p.MoodInfo {
 		Mood[int32(k)] = int32(v.Num)
 	}
-	resAdItems := make([]*msg.AdItem, 0)
+	var resAdItems []*msg.AdItem
 	for k, v := range p.ADItem {
 		resAdItems = append(resAdItems, &msg.AdItem{
 			ItemId:    int32(k),
@@ -830,14 +809,14 @@ func (p *PlayroomMod) RemoveChip(Uids []int64) ([]*item.Item, int, error) {
 		return nil, 0, fmt.Errorf("RemoveChip Uids is 0")
 	}
 	if len1 == len2 {
-		p.ChipList = make([]*ChipInfo, 0)
+		p.ChipList = nil
 	} else {
 		uidCount := make(map[int64]int)
 		for _, uid := range Uids {
 			uidCount[uid]++
 		}
 
-		newChipList := make([]*ChipInfo, 0)
+		var newChipList []*ChipInfo
 		for _, chip := range p.ChipList {
 			if uidCount[int64(chip.Uid)] > 0 {
 				uidCount[int64(chip.Uid)]--
@@ -885,7 +864,7 @@ func (p *PlayroomMod) FlipCard(Pos int) (int, error) {
 
 func (p *PlayroomMod) GetFlipReward() ([]*item.Item, int, int, error) {
 	check := make(map[int]int)
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
 	T := p.Target
 	Result := FLIP_TYPE_COPPER
 	for _, v := range p.Flip {
@@ -924,14 +903,12 @@ func (p *PlayroomMod) UnLock(Lv int) bool {
 	if Lv < UnlockLv || len(p.Physiology) != 0 {
 		return false
 	}
-	if len(p.Physiology) == 0 {
+	Now := GoUtil.Now()
-		Now := GoUtil.Now()
+	p.Physiology = make(map[int]*Physiology)
-		p.Physiology = make(map[int]*Physiology)
+	TypeList := playroomCfg.GetPhysiologyTypeList()
-		TypeList := playroomCfg.GetPhysiologyTypeList()
+	for _, v := range TypeList {
-		for _, v := range TypeList {
+		Max := playroomCfg.GetPhysiologyMax(v)
-			Max := playroomCfg.GetPhysiologyMax(v)
+		p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now}
-			p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now}
-		}
 	}
 	if len(p.MoodInfo) == 0 {
 		p.MoodInfo = make(map[int]*Mood)
@@ -966,8 +943,6 @@ func (p *PlayroomMod) UnlockDress(Type, Id int) error {
 		Id:      Id,
 		Part:    Type,
 		AddTime: GoUtil.Now(),
-		EndTime: 0,
-		Label:   "",
 		Num:     1,
 	}
 	return nil
@@ -987,7 +962,7 @@ func (p *PlayroomMod) UnlockPetAir(Id int) {
 
 func (p *PlayroomMod) PlayroomDressSet(DressSet map[int]int) ([]int, map[int]int, error) {
 	// 判断服装是否存在
-	Part := make([]int, 0)
+	var Part []int
 	Diff := GoUtil.DiffMap(DressSet, p.DressSet)
 	for Type, Id := range DressSet {
 		if Id == 0 {
@@ -1038,7 +1013,7 @@ func (p *PlayroomMod) Unlock(Id int) error {
 }
 
 func (p *PlayroomMod) GetUnlockIds() []int32 {
-	UnlockIds := make([]int32, 0)
+	UnlockIds := make([]int32, 0, len(p.UnlockList))
 	for k := range p.UnlockList {
 		UnlockIds = append(UnlockIds, int32(k))
 	}
@@ -1062,7 +1037,7 @@ func (p *PlayroomMod) GetPetAir() map[int]*PetAirInfo {
 }
 
 func (p *PlayroomMod) BackDataTask() []*msg.DailyTask {
-	DailyTask := make([]*msg.DailyTask, 0)
+	DailyTask := make([]*msg.DailyTask, 0, len(p.DailyTask))
 	for k, v := range p.DailyTask {
 		DailyTask = append(DailyTask, &msg.DailyTask{
 			Status:   int32(v.Status),
@@ -1089,7 +1064,7 @@ func (p *PlayroomMod) Guide(Type int) error {
 
 func (p *PlayroomMod) AdWatch(Id int) error {
 	if _, ok := p.ADItem[Id]; !ok {
-		p.ADItem[Id] = &ItemInfo{Watch: 0, LastTime: 0}
+		p.ADItem[Id] = &ItemInfo{}
 	}
 	p.ADItem[Id].Watch++
 	p.ADItem[Id].LastTime = GoUtil.Now()

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

@@ -58,7 +58,7 @@ type Trigger struct {
 func ParseQuest(s string) (QuestProgress, error) {
 	sArr := strings.Split(s, "=")
 	if len(sArr) < 2 {
-		return QuestProgress{}, fmt.Errorf("quest string not legel")
+		return QuestProgress{}, fmt.Errorf("quest string not legal")
 	}
 	target, _ := strconv.Atoi(sArr[1])
 	return QuestProgress{
@@ -87,7 +87,7 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 		Lv := GoUtil.Int(Tr.A[0])
 		TargetLv, _ := strconv.Atoi(q.A[0].(string))
 		if TargetLv == Lv {
-			q.Num += 1
+			q.Num++
 		}
 	case TRIGGER_LABEL_GUIDE_LOGIN: // 引导任务登录
 		LoginDay := GoUtil.Int(Tr.A[0])
@@ -95,15 +95,12 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 	case TRIGGER_LABEL_MERGETIME, // 合成x次
 		TRIGGER_LABEL_FINISHORDER,
 		TRIGGER_LABEL_BUBBLE: // 完成x次订单
-		q.Num += 1
+		q.Num++
 	case TRIGGER_LABEL_INTERACT: // 互动x类型y次
 		InteractId := GoUtil.Int(Tr.A[0])
-		Ids := make([]int, 0)
+		Ids := GoUtil.IntSliceInterface(q.A)
-		for _, v := range q.A {
-			Ids = append(Ids, GoUtil.Int(v))
-		}
 		if GoUtil.InArray(InteractId, Ids) {
-			q.Num += 1
+			q.Num++
 		}
 	case TRIGGER_LABEL_PETDRESS: // 换装x次
 		if len(q.A) == 0 {
@@ -116,11 +113,11 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 		arg := GoUtil.IntSlice(Tr.A[0])
 		for _, t := range arg {
 			if GoUtil.InArray(t, Ids) {
-				q.Num += 1
+				q.Num++
 			}
 		}
 	default:
-		q.Num += 1
+		q.Num++
 	}
 	if q.Num >= q.Target {
 		q.Num = q.Target

src/server/game/mod/race/race.go

@@ -81,13 +81,11 @@ func (r *RaceMod) GetReward() ([]*item.Item, error) {
 	if r.Rank != 1 {
 		return nil, fmt.Errorf("you are not the first")
 	}
-	Items := make([]*item.Item, 0)
+	var Items []*item.Item
-	Reward := raceCfg.GetReward(r.Pass)
+	Items = append(Items, raceCfg.GetReward(r.Pass)...)
-	Items = append(Items, Reward...)
 	Now := GoUtil.Now()
 	if Now <= r.EndTime {
-		ExtraReward := raceCfg.GetExtraReward(r.Pass)
+		Items = append(Items, raceCfg.GetExtraReward(r.Pass)...)
-		Items = append(Items, ExtraReward...)
 	}
 	r.Pass++
 	r.Progress -= Need
@@ -108,12 +106,12 @@ func (r *RaceMod) GetReward() ([]*item.Item, error) {
 }
 
 func randOpponents(OpponentNum int) []*Opponent {
-	Opponent := make([]*Opponent, 0, OpponentNum-1)
+	opponents := make([]*Opponent, 0, OpponentNum-1)
 	names := randnameCfg.GetRandNames(OpponentNum)
 	for i := 1; i < OpponentNum; i++ {
-		Opponent = append(Opponent, randOpponent(i, names[i]))
+		opponents = append(opponents, randOpponent(i, names[i]))
 	}
-	return Opponent
+	return opponents
 }
 func randOpponent(Id int, name string) *Opponent {
 	return &Opponent{

src/server/game/mod/seven_login/seven_login.go

@@ -43,6 +43,7 @@ func (s *SevenLoginMod) ZeroUpdate(Add, LastLoginTime int) {
 
 	if Now > s.MonthResetTime+GoUtil.MONTHDAYS {
 		s.MonthReward = randMonthReward()
+		s.Active = 0
 		s.MonthResetTime = s.MonthResetTime + (Now-s.MonthResetTime)/GoUtil.MONTHDAYS*GoUtil.MONTHDAYS
 	}
 	s.DayR++

src/server/game/mod/seven_login/seven_login_func.go

@@ -25,14 +25,17 @@ func randWeekReward(Add, Type int) map[int]Reward {
 	sort.Slice(jackpot, func(i, j int) bool {
 		return jackpot[i].Diamond < jackpot[j].Diamond
 	})
-	RI := make([]int, 0)
+	RI := make([]int, 0, len(RewardList))
 	for _, v := range RewardList {
 		RI = append(RI, v.Id)
 	}
 	CardPackIds := GoUtil.RandSliceNumNonAdjacent(RI, 3)
 	result := make(map[int]Reward)
 	LastType := 0
-	EnergyMul := float64(GoUtil.IfTrue(Type == BACK_REWARD, 2, 1).(int))
+	EnergyMul := 1.0
+	if Type == BACK_REWARD {
+		EnergyMul = 2.0
+	}
 	for _, v := range RewardList {
 		v.Diamond = int(float64(v.Diamond) * (1 + float64(Add)/100))
 		Reward := randReward(v, LastType, jackpot, CardPackIds, 0.5, EnergyMul)
@@ -85,7 +88,7 @@ func randReward(RewardData *gamedata.SevenLoginRewardData, LastType int, jackpot
 		Item2 = NewJackpot[Index].Items
 		RemainDiamond -= NewJackpot[Index].Diamond
 	}
-	Item3 := make([]*item.Item, 0)
+	var Item3 []*item.Item
 	if RewardData.RewardNum == 3 {
 		RemainDiamond += 5
 		NewJackpot3 := make([]*gamedata.SevenLoginJackpotData, 0, len(jackpot))
@@ -121,20 +124,3 @@ func randMonthReward() map[int]Reward {
 	}
 	return result
 }
-
-func F() map[int]Reward {
-	RewardList := sevenLoginCfg.GetSevenLoginMonthReward()
-	sort.Slice(RewardList, func(i, j int) bool {
-		return RewardList[i].Id < RewardList[j].Id
-	})
-	jackpot := sevenLoginCfg.GetSevenLoginJackpot(1)
-	sort.Slice(jackpot, func(i, j int) bool {
-		return jackpot[i].Diamond < jackpot[j].Diamond
-	})
-	result := make(map[int]Reward)
-	for _, v := range RewardList {
-		Reward := randReward(v, 0, jackpot, []int{}, 0.65, 1)
-		result[v.Id] = Reward
-	}
-	return result
-}

src/server/game/mod/var/var.go

@@ -36,7 +36,7 @@ func (v *Var) SetDailyVar(key int, value interface{}) {
 func (v *Var) GetDailyVar(key int) (interface{}, error) {
 	val, ok := v.DailyVar[key]
 	if !ok {
-		return nil, fmt.Errorf("key not exist")
+		return nil, fmt.Errorf("key %d not exist", key)
 	}
 	return val, nil
 }
@@ -48,7 +48,7 @@ func (v *Var) SetWeeklyVar(key int, value interface{}) {
 func (v *Var) GetWeeklyVar(key int) (interface{}, error) {
 	val, ok := v.WeeklyVar[key]
 	if !ok {
-		return nil, fmt.Errorf("key not exist")
+		return nil, fmt.Errorf("key %d not exist", key)
 	}
 	return val, nil
 }
@@ -60,7 +60,7 @@ func (v *Var) SetMonthVar(key int, value interface{}) {
 func (v *Var) GetMonthVar(key int) (interface{}, error) {
 	val, ok := v.MonthVar[key]
 	if !ok {
-		return nil, fmt.Errorf("key not exist")
+		return nil, fmt.Errorf("key %d not exist", key)
 	}
 	return val, nil
 }
@@ -72,7 +72,7 @@ func (v *Var) SetVar(key int, value interface{}) {
 func (v *Var) GetVar(key int) (interface{}, error) {
 	val, ok := v.Var[key]
 	if !ok {
-		return nil, fmt.Errorf("key not exist")
+		return nil, fmt.Errorf("key %d not exist", key)
 	}
 	return val, nil
 }

src/server/game/mod_factory.go

@@ -10,6 +10,7 @@ import (
 	limitedTimeEvent "server/game/mod/limited_time_event"
 	"server/game/mod/mail"
 	"server/game/mod/playroom"
+	sevenLogin "server/game/mod/seven_login"
 )
 
 func (p *Player) GetChessMod() *chess.ChessBorad {
@@ -47,3 +48,7 @@ func (p *Player) GetChargeMod() *charge.ChargeMod {
 func (p *Player) GetMailMod() *mail.MailMod {
 	return p.PlayMod.getMailMod()
 }
+
+func (p *Player) GetSevenLoginMod() *sevenLogin.SevenLoginMod {
+	return p.PlayMod.getSevenLoginMod()
+}

src/server/game/notification.go

@@ -0,0 +1,84 @@
+package game
+
+import (
+	"fmt"
+	languageCfg "server/conf/language"
+	notification_cfg "server/conf/notification"
+	GoUtil "server/game_util"
+	"server/msg"
+)
+
+const (
+	NOTIFY_TYPE_FRIEND_APPLY = 1
+	NOTIFY_TYPE_PETROOM_GAME = 2
+)
+
+/*
+对方来petroom游戏的通知
+每天最多通知3次
+*/
+func NotifyPetroomGame(PlayerId int) {
+	PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(PlayerId)
+	if !checkLogout(PlayerSimpleData) {
+		return
+	}
+	count, last := GetPetroomGameNotification(PlayerId)
+	cooldown, dailyLimit := notification_cfg.GetPetroomGameNotificationCooldown()
+	if count >= dailyLimit {
+		return
+	}
+	if GoUtil.Now()-last < int64(cooldown*onehour) {
+		return
+	}
+	titlekey, infokey := notification_cfg.GetPetroomGameNotificationMsg()
+	title := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), titlekey)
+	info := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), infokey)
+	GoUtil.NotifyPlayer(GoUtil.Int(PlayerSimpleData.Account), NOTIFY_TYPE_PETROOM_GAME, fmt.Sprintf(title, PlayerSimpleData.PetName), fmt.Sprintf(info, PlayerSimpleData.PetName))
+	SetPetroomGameNotification(PlayerId, count+1)
+}
+
+/*
+好友申请通知
+好友申请累计两次
+*/
+func NotifyFriendApply(PlayerId, FriendId int) {
+	PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(PlayerId)
+	if !checkLogout(PlayerSimpleData) {
+		return
+	}
+	FriendSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(FriendId)
+	if FriendSimpleData == nil {
+		return
+	}
+	count := GetFriendApplyNotification(PlayerId)
+	if count > 0 {
+		return
+	}
+	titlekey, infokey := notification_cfg.GetFriendApplyNotificationMsg()
+	title := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), titlekey)
+	info := languageCfg.GetLanguage(msg.LANG_TYPE(PlayerSimpleData.Lang), infokey)
+	GoUtil.NotifyPlayer(GoUtil.Int(PlayerSimpleData.Account), NOTIFY_TYPE_FRIEND_APPLY, title, fmt.Sprintf(info, FriendSimpleData.Name))
+	SetFriendApplyNotification(PlayerId, count+1)
+}
+
+/*
+玩家需处于离线状态
+玩家离线时间少于10分钟时，不发送消息
+若用户已连续7天未登入游戏，不再发送通知
+*/
+func checkLogout(PlayerSimpleData *PlayerSimpleData) bool {
+	if PlayerSimpleData == nil {
+		return false
+	}
+	if PlayerSimpleData.Loginout == 0 {
+		return false
+	}
+	now := GoUtil.Now()
+	if now-PlayerSimpleData.Loginout > 7*24*3600 {
+		return false
+	}
+	if now-PlayerSimpleData.Loginout < 600 {
+		return false
+	}
+	return true
+}

src/server/game/player_back.go

@@ -25,9 +25,7 @@ func (p *Player) PlayroomBackData() {
 	r.Status = int32(PlayroomMod.Status)
 	r.Items = item.ItemToMsg(PlayroomMod.Reward)
 
-	// 预分配切片容量，避免动态扩容
+	Opponent := make([]*proto.RoomOpponent, 0, len(PlayroomMod.Visitor))
-	visitorCount := len(PlayroomMod.Visitor)
-	Opponent := make([]*proto.RoomOpponent, 0, visitorCount)
 	FriendList := make([]*proto.FriendRoom, 0, len(FriendMod.GetFriendList()))
 	if PlayroomMod.Target == 0 {
 		PlayroomMod.SetTarget(p.GetVisitorPlayer())
@@ -78,7 +76,6 @@ func (p *Player) PlayroomBackData() {
 	r.Friend = FriendList
 	r.Target = TargerRoom
 
-	// 预分配装饰品切片容量
 	collectList := PlayroomMod.GetCollect()
 	Collect := make([]*proto.PlayroomCollectInfo, 0, len(collectList))
 	for _, v := range collectList {
@@ -104,7 +101,6 @@ func (p *Player) PlayroomBackData() {
 		})
 		Dress[int32(v.Part)] = PlayroomDress
 	}
-	// 预分配芯片列表容量
 	ChipMessage := make([]*proto.ChipInfo, 0, len(PlayroomMod.ChipList))
 	for _, v := range PlayroomMod.ChipList {
 		ChipMessage = append(ChipMessage, &proto.ChipInfo{
@@ -112,7 +108,6 @@ func (p *Player) PlayroomBackData() {
 			EmojiId: int32(v.Emoji),
 		})
 	}
-	// 预分配广告列表容量
 	AdWatch := make([]*proto.AdItem, 0, len(PlayroomMod.ADItem))
 	for k, v := range PlayroomMod.ADItem {
 		AdWatch = append(AdWatch, &proto.AdItem{
@@ -124,7 +119,6 @@ func (p *Player) PlayroomBackData() {
 
 	r.Dress = Dress
 	r.DressSet = GoUtil.MapIntToInt32(PlayroomMod.GetDressSet())
-	// 预分配宠物空气列表容量
 	petAirList := PlayroomMod.GetPetAir()
 	PetAir := make([]*proto.PlayroomAirInfo, 0, len(petAirList))
 	for _, v := range petAirList {
@@ -180,6 +174,10 @@ func (p *Player) PlayroomVisit(Uid int) {
 	PlayroomMod := p.PlayMod.getPlayroomMod()
 	r := &proto.ResPlayroomInfo{}
 	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
+	if PlayerData == nil {
+		p.PushClientRes(&proto.ResPlayroomInfo{})
+		return
+	}
 	Now := GoUtil.Now()
 	Work := false
 	if PlayerData.WorkStart > 0 && PlayerData.WorkStart+86400 > Now {
@@ -194,7 +192,7 @@ func (p *Player) PlayroomVisit(Uid int) {
 	r.Defense = Work
 	r.Emoji = GoUtil.MapIntToInt32(PlayerData.Emoji)
 	r.PetName = PlayerData.PetName
-	Items := make(map[int32]*proto.ItemInfo, 0)
+	Items := make(map[int32]*proto.ItemInfo)
 	for k, v := range PlayroomMod.GameReward {
 		Items[int32(k)] = &proto.ItemInfo{
 			Id:  int32(v.Id),
@@ -242,7 +240,7 @@ func (p *Player) BackUserInfo() {
 
 func (p *Player) ChargeBackData() {
 	c := p.PlayMod.getChargeMod()
-	LimitedEvnetMod := p.PlayMod.getLimitedTimeEventMod()
+	LimitedEventMod := p.PlayMod.getLimitedTimeEventMod()
 	SpecialShop := make(map[int32]*proto.ResSpecialShop)
 	ChessShop := make(map[int32]*proto.ResChessShop)
 	for k, v := range c.SpecialShop {
@@ -270,7 +268,7 @@ func (p *Player) ChargeBackData() {
 	WeeklyDiscount := make(map[int32]*proto.WeeklyDiscountInfo)
 	WeeklyDiscountInfo := chargeCfg.GetWeeklyInfoAll()
 	// 优惠日开启或者猫咪闪促开启
-	if c.IsWeeklyDiscountDay() || LimitedEvnetMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_DAY_SALE) {
+	if c.IsWeeklyDiscountDay() || LimitedEventMod.CheckExist(limitedTimeEvent.EVENT_TYPE_CAT_DAY_SALE) {
 		for k, v := range WeeklyDiscountInfo {
 			LimitNum := c.WeeklyDiscount[k]
 			WeeklyDiscount[int32(k)] = &proto.WeeklyDiscountInfo{
@@ -280,7 +278,7 @@ func (p *Player) ChargeBackData() {
 			}
 		}
 	}
-	CatDaySaleEndTime := LimitedEvnetMod.GetCatDaySaleEndTime()
+	CatDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime()
 	p.PushClientRes(&proto.ResCharge{
 		Charge:            float32(c.Charge),
 		Total:             int32(c.Total),
@@ -318,7 +316,6 @@ func (p *Player) GetChampshipRank() (int, int) {
 func (p *Player) FriendListBackData() {
 	FriendMod := p.PlayMod.getFriendMod()
 	friendList := FriendMod.GetFriendList()
-	// 预分配切片容量
 	fl := make([]*proto.ResPlayerSimple, 0, len(friendList))
 	for k, v := range friendList {
 		if k == int(p.M_DwUin) {
@@ -331,7 +328,6 @@ func (p *Player) FriendListBackData() {
 			fl = append(fl, ps)
 		}
 	}
-	// 预分配申请列表容量
 	ReqFriendList := make([]int64, 0, len(FriendMod.SendApply))
 	for k := range FriendMod.SendApply {
 		ReqFriendList = append(ReqFriendList, int64(k))
@@ -346,7 +342,6 @@ func (p *Player) FriendListBackData() {
 
 func (p *Player) FriendApplyBackData() {
 	FriendMod := p.PlayMod.getFriendMod()
-	// 预分配切片容量
 	al := make([]*proto.ResFriendApplyInfo, 0, len(FriendMod.ApplyList))
 	for k, v := range FriendMod.ApplyList {
 		ps := G_GameLogicPtr.GetResSimplePlayerByUid(k)
@@ -364,7 +359,6 @@ func (p *Player) FriendApplyBackData() {
 
 func (p *Player) FriendLogBackData() {
 	FriendMod := p.PlayMod.getFriendMod()
-	// 预分配切片容量
 	log := make([]*proto.ResFriendLog, 0, len(FriendMod.Log))
 	for _, v := range FriendMod.Log {
 		ps := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
@@ -382,7 +376,6 @@ func (p *Player) FriendLogBackData() {
 			Upvote: v.Upvote,
 		})
 	}
-	// 预分配回复列表容量
 	reply := make([]*proto.ResFriendReply, 0, len(FriendMod.ReplyList))
 	for _, v := range FriendMod.ReplyList {
 		ps := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
@@ -409,11 +402,9 @@ func (p *Player) FriendLogBackData() {
 
 func (p *Player) FriendCardBackData() {
 	FriendMod := p.PlayMod.getFriendMod()
-	// 预分配切片容量
 	msgList := make([]*proto.ResFriendCard, 0, len(FriendMod.Card))
 	for _, v := range FriendMod.Card {
-		m := GetCardInfoMsg(v)
+		msgList = append(msgList, GetCardInfoMsg(v))
-		msgList = append(msgList, m)
 	}
 	p.PushClientRes(&proto.ResFriendCardMsg{
 		MsgList: msgList,

src/server/game/player_chess_mod.go

@@ -129,24 +129,6 @@ func (p *PlayerChessData) UpdateChessData(player *Player, MChessData map[string]
 	return nil
 }
 
-func (p *PlayerChessData) UpdateChessDataTest(player *Player, MChessData map[string]int32) error {
-	p.Data.MChessData = MChessData
-	if true {
-		res := &msg.ResUpdatePlayerChessData{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "棋子数据不一致",
-		}
-		log.Debug("棋子数据不一致, %v---%v", p.Data.MChessData, player.PlayMod.getChessMod().GetChessList())
-		player.SendErrClienRes(res)
-		player.TeLog("outsync_event", map[string]interface{}{
-			"outsync_event": "UpdatePlayerChessDataFunc",
-		})
-		return fmt.Errorf("棋子数据不一致")
-	}
-	player.PlayMod.getChessMod().ChessMap = MChessData
-	return nil
-}
-
 // 检查棋子数据是否一致
 func (p *PlayerChessData) checkChessEqual(player *Player) bool {
 	if len(p.Data.MChessData) == 0 && conf.Server.GameName == "Merge_Pet_Local" {
@@ -156,12 +138,11 @@ func (p *PlayerChessData) checkChessEqual(player *Player) bool {
 	if len(ChessList) != len(p.Data.MChessData) {
 		return false
 	}
-	aCopy := make([]int, len(ChessList))
+	aCopy := make([]int, 0, len(ChessList))
-	bCopy := make([]int, len(p.Data.MChessData))
+	bCopy := make([]int, 0, len(p.Data.MChessData))
 	for _, v := range ChessList {
 		aCopy = append(aCopy, int(v))
 	}
-
 	for _, v := range p.Data.MChessData {
 		bCopy = append(bCopy, int(v))
 	}
@@ -181,8 +162,8 @@ func (p *PlayerChessData) checkChessEqual(player *Player) bool {
 		bMap[v]++
 	}
 
-	extra := make([]int, 0)
+	var extra []int
-	missing := make([]int, 0)
+	var missing []int
 
 	// 找出aCopy多的元素
 	for k, v := range aMap {
@@ -219,10 +200,10 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 	var addChessCostEnergy int
 	var buyChess int
 	LimitPush := false // 限时事件推送
-	TriggerList := make([]*quest.Trigger, 0)
+	var TriggerList []*quest.Trigger
-	itemList := make([]*item.Item, 0)
+	var itemList []*item.Item
-	AddChessList := make([]int, 0)
+	var AddChessList []int
-	AddNewEmit := make([]int, 0)
+	var AddNewEmit []int
 	EmitList := ChessMod.GetEmitList()
 	for _, v := range handle_list {
 		ChessId := int(v.ChessId)
@@ -253,8 +234,7 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 			if err != nil {
 				return nil, nil, err
 			}
-			HandbookMod := player.PlayMod.getHandbookMod() // 添加图鉴
+			b := HandbookMod.SetHandbook(NewChessId) // 添加图鉴
-			b := HandbookMod.SetHandbook(NewChessId)
 			if b {
 				AddNewEmit = append(AddNewEmit, NewChessId)
 			}
@@ -322,12 +302,12 @@ func (p *PlayerChessData) HandleChess(player *Player, handle_list []*msg.ChessHa
 		return nil, nil, err
 	}
 	NewEmitList := ChessMod.GetEmitList()
-	EmitProductList := make([]string, 0)
+	var EmitProductList []string
 	for _, v := range EmitList {
 		ColorList := mergeDataCfg.GetEmitProduceType(v)
 		EmitProductList = append(EmitProductList, ColorList...)
 	}
-	NewEmitProductList := make([]string, 0)
+	var NewEmitProductList []string
 	for _, v := range NewEmitList {
 		ColorList := mergeDataCfg.GetEmitProduceType(v)
 		NewEmitProductList = append(NewEmitProductList, ColorList...)

src/server/game/player_data.go

@@ -682,7 +682,7 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 			}
 
 			p.PushClientRes(ChessMod.BackData())
-		case item.ITEM_TYPE_LIMIED_TIME_EVENT: // 限时事件
+		case item.ITEM_TYPE_LIMITED_TIME_EVENT: // 限时事件
 			EffectList := itemCfg.GetItemEffectList(v.Id)
 			LimitedTimeEventMod := p.PlayMod.getLimitedTimeEventMod()
 			if len(EffectList) < 2 {
@@ -892,6 +892,7 @@ func (p *Player) LoginBackData() {
 		HandleType: MsgMod.HANDLE_MOD_PLAYER_LOGIN,
 		Extra:      conf.Server.ServerID,
 	})
+	SetFriendApplyNotification(int(p.M_DwUin), 0)
 	p.PushClientRes(p.PlayMod.mod_list.Base.BackData())
 	p.PushClientRes(p.PlayMod.mod_list.Handbook.BackData())
 	p.PushClientRes(p.PlayMod.mod_list.Base.BackData())
@@ -1001,7 +1002,8 @@ func (p *Player) UpdateUserInfo() {
 	simple.CardInfo = CardMod.GetCardList()
 	simple.ActLog = p.PlayMod.getFriendMod().GetActLogLast()
 	simple.Physiology = p.PlayMod.getPlayroomMod().GetPhysiologyList()
-
+	simple.Lang = int(p.PlayMod.getBaseMod().Lang)
+	simple.Account = p.PlayMod.getBaseMod().Account
 	//TODO 存储到redis 在新版本中将优化成gob进行压缩
 	value, _ := json.Marshal(simple)
 	IdStr := GoUtil.String(p.M_DwUin)
@@ -1060,7 +1062,7 @@ func (p *Player) AddLog(Uid int, Type int, Param string, Time int64) {
 			Id:     int32(Id),
 			Time:   int32(Time),
 		},
-		Bubble: FriendMod.GetBubbble(Id),
+		Bubble: FriendMod.GetBubble(Id),
 	})
 }
 
@@ -1246,3 +1248,15 @@ func (p *Player) DispatcherHandle() {
 		}
 	}()
 }
+
+func CheckPlayerLose(Uid int) bool {
+	FriendSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
+	if FriendSimpleData == nil {
+		return true
+	}
+	now := GoUtil.Now()
+	if now-FriendSimpleData.Loginout > sevendays {
+		return true
+	}
+	return false
+}

src/server/game/register_network_func.go

@@ -246,10 +246,12 @@ func RegHandbookAllReward(player *Player, buf []byte) error {
 	player.PushClientRes(&msg.ResHandbookAllReward{
 		Code: msg.RES_CODE_SUCCESS,
 	})
+	now := GoUtil.Now()
 	NotifyAllFriend(player, &MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_HANDBOOK_COLLECTION,
 		From:  int(player.M_DwUin),
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 		Extra: MsqMod.HandbookMsg{
 			Type: req.Type,
 		},
@@ -1076,6 +1078,7 @@ func ReqChessEx(player *Player, buf []byte) error {
 	return nil
 }
 
+// 领取资源宝箱
 func ReqSourceChest(player *Player, buf []byte) error {
 	req := &msg.ReqSourceChest{}
 	err := proto.Unmarshal(buf, req)
@@ -1880,6 +1883,7 @@ func ReqApplyFriend(player *Player, buf []byte) error {
 		})
 		return fmt.Errorf("already applied")
 	}
+	now := GoUtil.Now()
 	if req.Type == 1 {
 		Items, err := FriendMod.GetSponsorReward()
 		if err != nil {
@@ -1899,12 +1903,13 @@ func ReqApplyFriend(player *Player, buf []byte) error {
 			})
 			return err
 		}
-		player.AddLog(int(req.Uid), friend.LOG_TYPE_FRIEND_SPONSOR, "", GoUtil.Now())
+		player.AddLog(int(req.Uid), friend.LOG_TYPE_FRIEND_SPONSOR, "", now)
 		FriendMgrSend(&MsqMod.Msg{
 			Type:  MsqMod.HANDLE_TYPE_FRIEND_SPONSOER,
 			From:  int(player.M_DwUin),
 			To:    Uid,
-			SendT: GoUtil.Now(),
+			SendT: now,
+			End:   now + sevendays,
 		})
 		player.PushClientRes(BaseMod.BackData())
 		player.TeLog("friend_invite_reward", map[string]interface{}{
@@ -1915,7 +1920,8 @@ func ReqApplyFriend(player *Player, buf []byte) error {
 		Type:  MsqMod.HANDLE_TYPE_APPLY,
 		From:  int(player.M_DwUin),
 		To:    Uid,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 	}
 	FriendMgrSend(m)
 	player.PushClientRes(&msg.ResApplyFriend{
@@ -1951,7 +1957,7 @@ func ReqAgreeFriend(player *Player, buf []byte) error {
 	}
 	// 新好友才可以打招呼
 	if !FriendMod.CheckAddBefore(Uid) {
-		FriendMod.AddReplyInfo(Uid, friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+24*3600, nil)
+		FriendMod.AddReplyInfo(Uid, friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+oneday, nil)
 	}
 	FriendMod.AddFriend(Uid)
 	player.PushClientRes(&msg.ResAgreeFriend{
@@ -2022,11 +2028,13 @@ func ReqRefuseFriend(player *Player, buf []byte) error {
 		Code: msg.RES_CODE_SUCCESS,
 		Uid:  req.Uid,
 	})
+	now := GoUtil.Now()
 	m := &MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_REFUSE,
 		From:  int(player.M_DwUin),
 		To:    Uid,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + 86400*7,
 	}
 	FriendMgrSend(m)
 	player.FriendApplyBackData()
@@ -2069,13 +2077,6 @@ func ReqCardGive(player *Player, buf []byte) error {
 		})
 		return fmt.Errorf("card id empty")
 	}
-	// err = player.SubCard(CardId)
-	// if err != nil {
-	// 	player.SendErrClienRes(&msg.ResCardGive{
-	// 		Code: msg.RES_CODE_FAIL,
-	// 		Msg:  err.Error(),
-	// 	})
-	// }
 	Id := GoUtil.CreateCardId(int(player.M_DwUin), 0, int(req.CardId))
 	for _, v := range req.Uid {
 		Uid := int(v)
@@ -2203,11 +2204,13 @@ func ReqRefuseCardGive(player *Player, buf []byte) error {
 	player.TeLog("ReqRefuseCardGive", map[string]interface{}{
 		"card_id": CardInfo.CardId,
 	})
+	now := GoUtil.Now()
 	m := &MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_REG_CARD_REFUSE,
 		From:  int(player.M_DwUin),
 		To:    CardInfo.AUid,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + 86400,
 		Extra: *CardInfo,
 	}
 	FriendMgrSend(m)
@@ -3109,12 +3112,14 @@ func ReqFriendTLUpvote(player *Player, buf []byte) error {
 		})
 		return err
 	}
+	now := GoUtil.Now()
 	// 添加时间线
 	m := &MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_HANDBOOK_UPVOTE,
 		From:  int(player.M_DwUin),
 		To:    int(FUid),
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 	}
 	FriendMod.AddActLog(friend.ACT_LOG_TYPE_VISIT_UPVOTE, "")
 	player.UpdateUserInfo()
@@ -3304,11 +3309,13 @@ func ReqSelfInvited(player *Player, buf []byte) error {
 	if err != nil {
 		return err
 	}
+	now := GoUtil.Now()
 	FriendMgrSend(&MsqMod.Msg{
 		Type:  MsqMod.HANDLE_TYPE_INVITE_FRIEND,
 		From:  int(player.M_DwUin),
 		To:    int(req.InviterId),
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + 86400,
 	})
 	player.PushClientRes(&msg.ResSelfInvited{
 		ResultCode: 1,
@@ -3887,11 +3894,13 @@ func ReqPlayroomGame(player *Player, buf []byte) error {
 		})
 		return err
 	}
+	now := GoUtil.Now()
 	FriendMgrSend(&MsqMod.Msg{
 		From:  int(player.M_DwUin),
 		To:    Target,
 		Type:  MsqMod.HANDLE_TYPE_PLAYROOM_GAME,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 		Extra: GameResult{
 			T:     PlayroomMod.GetGameId(),
 			Emoji: int(req.EmojiId),
@@ -3947,11 +3956,13 @@ func ReqPlayroomSelectReward(player *Player, buf []byte) error {
 		})
 		return fmt.Errorf("no game or target")
 	}
+	now := GoUtil.Now()
 	FriendMgrSend(&MsqMod.Msg{
 		From:  int(player.M_DwUin),
 		To:    Target,
 		Type:  MsqMod.HANDLE_TYPE_PLAYROOM_LOSE,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 		Item:  Items,
 		Extra: GameResult{
 			T:     PlayroomMod.GetGameId(),
@@ -3975,6 +3986,7 @@ func ReqPlayroomSelectReward(player *Player, buf []byte) error {
 	PlayroomMod.ResetGame()
 	player.PlayerDecoSetLog("emoji", int(req.EmojiId), "playroom_select_reward")
 	player.PlayroomBackData()
+	go NotifyPetroomGame(Target)
 	player.PlayMod.save()
 	player.PushClientRes(&msg.ResPlayroomSelectReward{
 		Code: msg.RES_CODE_SUCCESS,
@@ -4180,11 +4192,13 @@ func ReqPlayroomFlipReward(player *Player, buf []byte) error {
 		FriendMod.AddActLog(friend.ACT_LOG_TYPE_GET_VISIT_GAME_PRIZE, "")
 		player.UpdateUserInfo()
 	}
+	now := GoUtil.Now()
 	FriendMgrSend(&MsqMod.Msg{
 		From:  int(player.M_DwUin),
 		To:    Target,
 		Type:  MsqMod.HANDLE_TYPE_PLAYROOM_LOSE,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 		Item:  Items,
 		Extra: GameResult{
 			T:     playroom.GAME_TYPE_FILP,
@@ -4270,17 +4284,20 @@ func ReqPlayroomUpvote(player *Player, buf []byte) error {
 			Msg:  err.Error(),
 		})
 	}
+	now := GoUtil.Now()
 	FriendMgrSend(&MsqMod.Msg{
 		From:  int(player.M_DwUin),
 		To:    int(req.Id),
 		Type:  MsqMod.HANDLE_TYPE_PLAYROOM_UPVOTE,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 	})
 	FriendMgrSend(&MsqMod.Msg{
 		From:  int(player.M_DwUin),
 		To:    int(req.Id),
 		Type:  MsqMod.HANDLE_TYPE_PLAYROOM_KISS,
-		SendT: GoUtil.Now(),
+		SendT: now,
+		End:   now + sevendays,
 	})
 	player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_PLAYROOM_UPVOTE})
 	player.AddPlayroomUpvote(int(req.Id))
@@ -4597,13 +4614,15 @@ func ReqFriendTreasureFilp(player *Player, buf []byte) error {
 		)
 		return err
 	}
+	now := GoUtil.Now()
 	if Uid != 0 && Items != nil {
 		FriendMgrSend(&MsqMod.Msg{
 			From:  int(player.M_DwUin),
 			To:    int(Uid),
 			Type:  MsqMod.HANDLE_TYPE_TREASURE_RESULT,
 			Extra: Items[0].Num,
-			SendT: GoUtil.Now(),
+			SendT: now,
+			End:   now + sevendays,
 		})
 	}
 
@@ -4641,6 +4660,7 @@ func ReqFriendTreasureEnd(player *Player, buf []byte) error {
 		)
 		return err
 	}
+	now := GoUtil.Now()
 	for _, v := range FriendTreasureMod.List {
 		ItemNum := 0
 		if v.Status == 1 {
@@ -4650,7 +4670,8 @@ func ReqFriendTreasureEnd(player *Player, buf []byte) error {
 			From:  int(player.M_DwUin),
 			To:    int(v.Uid),
 			Type:  MsqMod.FRIEND_TREASURE_HANDLE,
-			SendT: GoUtil.Now(),
+			SendT: now,
+			End:   now + sevendays,
 			Extra: []*item.Item{item.NewItem(item.ITEM_STAR_ID, ItemNum)},
 		})
 	}
@@ -5050,8 +5071,8 @@ func ReqAddNpc(player *Player, buf []byte) error {
 	player.TeLog("add_npc", map[string]interface{}{
 		"NpcId": int(req.NpcId),
 	})
-	FriendMod.AddReplyInfo(int(req.NpcId), friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+24*3600, nil)
+	FriendMod.AddReplyInfo(int(req.NpcId), friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+oneday, nil)
-	FriendMod.AddReplyInfo(int(req.NpcId), friend.REPLY_TYPE_GREETING_Get, "", GoUtil.Now()+24*3600, nil)
+	FriendMod.AddReplyInfo(int(req.NpcId), friend.REPLY_TYPE_GREETING_Get, "", GoUtil.Now()+oneday, nil)
 	player.AddLog(int(req.NpcId), friend.LOG_TYPE_FRIEND_BECOME_NPC, GoUtil.String(req.NpcId), GoUtil.Now())
 	player.PushClientRes(&msg.ResAddNpc{
 		Code:  msg.RES_CODE_SUCCESS,
@@ -5772,6 +5793,7 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
 		return fmt.Errorf("reply info not exist")
 	}
 	ErrType := msg.FRIEND_REPLY_HANDLE_ERR_TYPE_NONE
+	now := GoUtil.Now()
 	if req.Type == 1 && ReplyInfo.Uid > 10000 {
 		switch ReplyInfo.Type {
 		case friend.REPLY_TYPE_GREETING:
@@ -5784,7 +5806,8 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
 				From:  int(player.M_DwUin),
 				To:    int(ReplyInfo.Uid),
 				Type:  MsqMod.HANDLE_TYPE_FRIEND_GREETING_REPLY,
-				SendT: GoUtil.Now(),
+				SendT: now,
+				End:   now + sevendays,
 				Extra: ReplyData,
 			})
 		case friend.REPLY_TYPE_CATNIP: // 猫草大作战同意邀请
@@ -5796,7 +5819,7 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
 			err := player.SetCatnipPartner(GameId, ReplyInfo.Uid, activityInfo.EndT)
 			if err == nil {
 				CatnipMod := player.PlayMod.getCatnipMod()
-				ActivityId := player.GetActivityId(activity.ACT_TYPE_MINING)
+				ActivityId := player.GetActivityId(activity.ACT_TYPE_CATNIP)
 				UserList, _ := CatnipMod.Agree(GameId, ReplyInfo.Uid)
 				player.TeLog("catnip_agree", map[string]interface{}{
 					"Id": int(GameId),
@@ -5809,7 +5832,8 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
 						ActivityId: ActivityId,
 						GameId:     int(GameId),
 					},
-					SendT: GoUtil.Now(),
+					SendT: now,
+					End:   now + sevendays,
 				})
 
 				for _, v := range UserList {
@@ -5821,7 +5845,8 @@ func ReqFriendReplyHandle(player *Player, buf []byte) error {
 							ActivityId: ActivityId,
 							GameId:     int(GameId),
 						},
-						SendT: GoUtil.Now(),
+						SendT: now,
+						End:   now + sevendays,
 					})
 				}
 				player.CatnipBackData()

src/server/game/trigger_func.go

@@ -195,11 +195,7 @@ func (p *Player) TriggerSeed() {
 		}
 	}
 	BaseMod := p.PlayMod.getBaseMod()
-	if !b {
+	BaseMod.SetSeed(b)
-		BaseMod.SetSeed(false)
-	} else {
-		BaseMod.SetSeed(true)
-	}
 }
 
 func (p *Player) TriggerSeedSource() {
@@ -207,9 +203,7 @@ func (p *Player) TriggerSeedSource() {
 	if !BaseMod.GetSeed() {
 		return
 	}
-	Total := 0
+	Total := BaseMod.GetEnergy()
-	Energy := BaseMod.GetEnergy()
-	Total += Energy
 
 	ChessMod := p.PlayMod.getChessMod()
 	ChessList := ChessMod.GetUnlockChessList()
@@ -308,17 +302,17 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 				}
 			}
 			Q += max(Q1-Q2-Q3, 0)
-			Order.Q = Q
-			MaxQ = max(MaxQ, Q)
-			MinQ = min(MinQ, Q)
 		}
+		Order.Q = Q
+		MaxQ = max(MaxQ, Q)
+		MinQ = min(MinQ, Q)
 	}
 
 	if E > MaxQ {
 		return nil
 	}
 	// 生成订单
-	ProduceChessList := []int{}
+	var ProduceChessList []int
 	for _, v := range AllChess {
 		Type := mergeDataCfg.GetTypeById(v)
 		if Type != "Product" {
@@ -333,13 +327,13 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 				break
 			}
 		}
-		EmitTypeList := []string{}
+		var EmitTypeList []string
 		for _, v := range NewOrder.MergeId {
 			Color := mergeDataCfg.GetColorById(v)
 			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
 			EmitTypeList = append(EmitTypeList, EmitType)
 		}
-		ChessList := []int{}
+		var ChessList []int
 		for _, v := range ProduceChessList {
 			Color := mergeDataCfg.GetColorById(v)
 			EmitType := mergeDataCfg.GetEmitTypeByColor(Color)
@@ -373,7 +367,7 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 	if E < MinQ {
 		for _, Order := range OrderMod.OrderPool {
 			if Order.Q == MinQ {
-				ChessList := []int{}
+				var ChessList []int
 				for _, v := range ProduceChessList {
 					Lv := mergeDataCfg.GetLvById(v)
 					if Lv < 5 {
@@ -390,7 +384,7 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 	}
 
 	if E > MinQ && E < MaxQ {
-		L1 := []*order.Order{}
+		var L1 []*order.Order
 		for _, Order := range OrderMod.OrderPool {
 			if Order.Q > E {
 				L1 = append(L1, Order)
@@ -412,7 +406,7 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 		if NeedScore > Smax {
 			for _, Order := range OrderMod.OrderPool {
 				if Order.Q == MinQ {
-					ChessList := []int{}
+					var ChessList []int
 					for _, v := range ProduceChessList {
 						Lv := mergeDataCfg.GetLvById(v)
 						if Lv < 5 {
@@ -442,7 +436,7 @@ func (p *Player) TriggerSeedOrder() *order.Order {
 				}
 			}
 		}
-		L2 := []*order.Order{}
+		var L2 []*order.Order
 		for _, Order := range L1 {
 			if Order.S > NeedScore {
 				L2 = append(L2, Order)

src/server/game/var.go

@@ -28,7 +28,16 @@ func (p *Player) GetVarData(key string) interface{} {
 	return cache.D
 }
 
-func (p *Player) GetUserVarData(key string, PlayerId int) interface{} {
+func GetDailyVarData(key string) interface{} {
+	cache := &VarExpireData{}
+	err := LoadCacheVarData(key, cache)
+	if err != nil {
+		return nil
+	}
+	return cache.D
+}
+
+func GetUserVarData(key string, PlayerId int) interface{} {
 	cache := map[string]*VarExpireData{}
 	err := LoadCacheVarData(GoUtil.GetVarKey(int(PlayerId)), &cache)
 	if err != nil {
@@ -39,24 +48,18 @@ func (p *Player) GetUserVarData(key string, PlayerId int) interface{} {
 	if !ok {
 		return nil
 	}
+	if data.T > 0 && data.T < GoUtil.Now() {
+		return nil
+	}
 	return data.D
 }
 
-// func GetServerVarData(key string) interface{} {
+func OpDailyVarDataAsync(PlayerId int, key string, value interface{}, opType int) {
-// 	data, err := GetServerData(key)
-// 	if err != nil {
-// 		log.Error("GetServerVarData err : %s", err)
-// 		return nil
-// 	}
-// 	return data.Extra
-// }
-
-func (p *Player) OpVarDataAsync(PlayerId int, key string, value interface{}, opType int) {
 	SendMsgToCenterAsync(&msg.Msg{
-		From:       int(p.M_DwUin),
+		From:       0,
 		To:         PlayerId,
 		SendT:      GoUtil.Now(),
-		HandleType: msg.HANDLE_MOD_USER_VAR_SET,
+		HandleType: msg.HANDLE_MOD_DAILY_VAR_SET,
 		Extra: msg.VarData{
 			Key:     key,
 			Value:   value,
@@ -65,12 +68,28 @@ func (p *Player) OpVarDataAsync(PlayerId int, key string, value interface{}, opT
 	})
 }
 
-func (p *Player) OpVarDataSync(PlayerId int, key string, value interface{}, opType int) (*msg.Msg, error) {
+func (p *Player) OpVarDataAsync(PlayerId int, key string, value interface{}, opType int, end int64) {
+	SendMsgToCenterAsync(&msg.Msg{
+		From:       int(p.M_DwUin),
+		To:         PlayerId,
+		SendT:      GoUtil.Now(),
+		HandleType: msg.HANDLE_MOD_USER_VAR_SET,
+		End:        end,
+		Extra: msg.VarData{
+			Key:     key,
+			Value:   value,
+			SetType: opType,
+		},
+	})
+}
+
+func (p *Player) OpVarDataSync(PlayerId int, key string, value interface{}, opType int, end int64) (*msg.Msg, error) {
 	return SendMsgToCenterSync(&msg.Msg{
 		From:       int(p.M_DwUin),
 		To:         PlayerId,
 		SendT:      GoUtil.Now(),
 		HandleType: msg.HANDLE_MOD_USER_VAR_SET,
+		End:        end,
 		Extra: msg.VarData{
 			Key:     key,
 			Value:   value,
@@ -93,56 +112,56 @@ func (p *Player) OpServerVarDataSync(key string, Value interface{}, opType int)
 	})
 }
 
-func (p *Player) SetVarDataAsync(key string, value interface{}, PlayerId int) {
+func (p *Player) SetVarDataAsync(key string, value interface{}, PlayerId int, end int64) {
-	p.OpVarDataAsync(PlayerId, key, value, msg.VAR_OP_SET)
+	p.OpVarDataAsync(PlayerId, key, value, msg.VAR_OP_SET, end)
 }
 
-func (p *Player) AddVarDataAsync(key string, PlayerId int) {
+func (p *Player) AddVarDataAsync(key string, PlayerId int, end int64) {
-	p.OpVarDataAsync(PlayerId, key, nil, msg.VAR_OP_ADD)
+	p.OpVarDataAsync(PlayerId, key, nil, msg.VAR_OP_ADD, end)
 }
 
-func (p *Player) SubVarDataAsync(key string, PlayerId int) {
+func (p *Player) SubVarDataAsync(key string, PlayerId int, end int64) {
-	p.OpVarDataAsync(PlayerId, key, nil, msg.VAR_OP_SUB)
+	p.OpVarDataAsync(PlayerId, key, nil, msg.VAR_OP_SUB, end)
 }
 
 func (p *Player) AddPlayroomUpvote(PlayerId int) {
-	p.AddVarDataAsync(VAR_PLAYROOM_UPVOTE, PlayerId)
+	p.AddVarDataAsync(VAR_PLAYROOM_UPVOTE, PlayerId, 0)
 }
 
 func (p *Player) AddPlayroomChip(PlayerId int) {
-	p.AddVarDataAsync(VAR_PLAYROOM_CHIP, PlayerId)
+	p.AddVarDataAsync(VAR_PLAYROOM_CHIP, PlayerId, 0)
 }
 
 func (p *Player) SubPlayroomChip(PlayerId int) {
-	p.SubVarDataAsync(VAR_PLAYROOM_CHIP, PlayerId)
+	p.SubVarDataAsync(VAR_PLAYROOM_CHIP, PlayerId, 0)
 }
 
 func (p *Player) GetPlayroomUpvote(PlayerId int) int {
-	data := p.GetUserVarData(VAR_PLAYROOM_UPVOTE, PlayerId)
+	data := GetUserVarData(VAR_PLAYROOM_UPVOTE, PlayerId)
 	if data == nil {
 		return 0
 	}
-	return data.(int)
+	return GoUtil.Int(data)
 }
 
 func (p *Player) GetPlayroomChip(PlayerId int) int {
-	data := p.GetUserVarData(VAR_PLAYROOM_CHIP, PlayerId)
+	data := GetUserVarData(VAR_PLAYROOM_CHIP, PlayerId)
 	if data == nil {
 		return 0
 	}
-	return data.(int)
+	return GoUtil.Int(data)
 }
 
 func (p *Player) SetPlayroomKiss(Kiss int, PlayerId int) {
-	p.SetVarDataAsync(VAR_PLAYROOM_KISS, Kiss, PlayerId)
+	p.SetVarDataAsync(VAR_PLAYROOM_KISS, Kiss, PlayerId, 0)
 }
 
 func (p *Player) GetPlayroomKiss(PlayerId int) int {
-	data := p.GetUserVarData(VAR_PLAYROOM_KISS, PlayerId)
+	data := GetUserVarData(VAR_PLAYROOM_KISS, PlayerId)
 	if data == nil {
 		return 0
 	}
-	return data.(int)
+	return GoUtil.Int(data)
 }
 
 func (p *Player) GetGoldCard() *VarGoldCard {
@@ -150,7 +169,11 @@ func (p *Player) GetGoldCard() *VarGoldCard {
 	if data == nil {
 		return &VarGoldCard{}
 	}
-	return data.(*VarGoldCard)
+	i, ok := data.(*VarGoldCard)
+	if !ok {
+		return &VarGoldCard{}
+	}
+	return i
 }
 
 func (p *Player) GetCatnipPartner(Uid int) []int {
@@ -184,3 +207,43 @@ func LoadCacheVarData(key string, value interface{}) error {
 	}
 	return GoUtil.GobUnmarshal(data, value)
 }
+
+const (
+	notifyKeyFriendApply = "friend_apply_n"
+	notifyKeyPetroomGame = "petroom_game_n"
+)
+
+func GetFriendApplyNotification(PlayerId int) int {
+	data := GetUserVarData(notifyKeyFriendApply, PlayerId)
+	if data == nil {
+		return 0
+	}
+	return GoUtil.Int(data)
+}
+
+func SetFriendApplyNotification(PlayerId int, Count int) {
+	p := new(Player)
+	p.SetVarDataAsync(notifyKeyFriendApply, Count, PlayerId, 0)
+}
+
+func GetPetroomGameNotification(PlayerId int) (int, int64) {
+	data := GetUserVarData(notifyKeyPetroomGame, PlayerId)
+	if data == nil {
+		return 0, 0
+	}
+	info, ok := data.(map[string]interface{})
+	if !ok {
+		return 0, 0
+	}
+	return GoUtil.Int(info["count"]), GoUtil.Int64(info["send"])
+}
+
+func SetPetroomGameNotification(PlayerId int, Count int) {
+	p := new(Player)
+	end := GoUtil.ZeroTimestamp() + oneday
+	value := map[string]interface{}{
+		"count": Count,
+		"send":  GoUtil.Now(),
+	}
+	p.SetVarDataAsync(notifyKeyPetroomGame, value, PlayerId, end)
+}

src/server/game/var_mgr.go

@@ -1,7 +1,6 @@
 package game
 
 import (
-	"encoding/gob"
 	"fmt"
 	"server/game/mod/card"
 	"server/game/mod/msg"
@@ -22,6 +21,7 @@ type VarData struct {
 
 	NewVar    map[string]*VarExpireData
 	NewUseVar map[int]map[string]*VarExpireData
+	DailyVar  map[string]*VarExpireData
 	ZeroTime  int64
 	Version   int64
 	mu        sync.Mutex
@@ -36,8 +36,6 @@ const (
 )
 
 func (f *VarMgr) Init() {
-	gob.Register(&VarGoldCard{})
-	gob.Register(&VarExpireData{})
 	f.key = VAR_MGR_KEY
 	f.data = &VarData{
 		NewVar:    map[string]*VarExpireData{},
@@ -47,14 +45,17 @@ func (f *VarMgr) Init() {
 	f.init()
 	// 版本更新 重构
 	f.version()
-	if f.data.(*VarData).NewVar == nil {
+	if f.getData().NewVar == nil {
-		f.data.(*VarData).NewVar = make(map[string]*VarExpireData)
+		f.getData().NewVar = make(map[string]*VarExpireData)
 	}
-	if f.data.(*VarData).UserVar == nil {
+	if f.getData().UserVar == nil {
-		f.data.(*VarData).UserVar = make(map[string]*VarUserData)
+		f.getData().UserVar = make(map[string]*VarUserData)
 	}
-	if f.data.(*VarData).VarExpire == nil {
+	if f.getData().VarExpire == nil {
-		f.data.(*VarData).VarExpire = make(map[string]*VarExpireData)
+		f.getData().VarExpire = make(map[string]*VarExpireData)
+	}
+	if f.getData().DailyVar == nil {
+		f.getData().DailyVar = make(map[string]*VarExpireData)
 	}
 	if f.getData().ZeroTime == GoUtil.ZeroTimestamp() {
 		f.ZeroUpdate()
@@ -72,7 +73,7 @@ func (f *VarMgr) fixbug() {
 		if v != nil {
 			del := true
 			for _, ved := range v {
-				if ved.D.(int) != 0 {
+				if n, ok := ved.D.(int); ok && n != 0 {
 					del = false
 				}
 			}
@@ -92,13 +93,13 @@ func (f *VarMgr) version() {
 		data.mu.Lock()
 		defer data.mu.Unlock()
 		// set to next version
-		for k, v := range data.UserVar {
+		for k, userData := range data.UserVar {
-			if v != nil {
+			if userData != nil {
 				uidStr := strings.Split(k, "_")[2]
 				uid := GoUtil.Int(uidStr)
-				f.SetUserVar(uid, VAR_PLAYROOM_UPVOTE, v.Upvote)
+				f.SetUserVar(uid, VAR_PLAYROOM_UPVOTE, userData.Upvote)
-				f.SetUserVar(uid, VAR_PLAYROOM_CHIP, v.Chip)
+				f.SetUserVar(uid, VAR_PLAYROOM_CHIP, userData.Chip)
-				f.SetUserVar(uid, VAR_PLAYROOM_KISS, v.Kiss)
+				f.SetUserVar(uid, VAR_PLAYROOM_KISS, userData.Kiss)
 				delete(data.UserVar, k)
 			}
 		}
@@ -111,18 +112,23 @@ func (f *VarMgr) version() {
 }
 
 func (f *VarMgr) ZeroUpdate() {
-	f.getData().ZeroTime = GoUtil.ZeroTimestamp()
+	data := f.getData()
+	data.mu.Lock()
+	defer data.mu.Unlock()
+	data.ZeroTime = GoUtil.ZeroTimestamp()
 	// 随机生成两个金卡
 	Card1, Card2 := card.RankGoldCard()
 	f.SetVar(VAR_GOLD_CARD, &VarGoldCard{
 		Four: Card1,
 		Five: Card2,
 	})
-	for k, v := range f.getData().NewVar {
+	for k, v := range data.NewVar {
 		if v.T < GoUtil.ZeroTimestamp() {
-			delete(f.getData().Var, k)
+			delete(data.NewVar, k)
 		}
 	}
+	// 清空每日变量
+	data.DailyVar = make(map[string]*VarExpireData)
 	f.mDispatr.AfterFunc(time.Duration(GoUtil.NextZeroTimestampDuration())*time.Second, func() {
 		f.ZeroUpdate()
 	})
@@ -163,7 +169,6 @@ func (f *VarMgr) SetUserVar(uid int, key string, value interface{}) {
 	}
 	ved.D = value
 	varData[key] = ved
-	f.getData().NewUseVar[uid] = varData
 	SaveCacheVarData(GoUtil.GetVarKey(uid), varData)
 }
 
@@ -171,7 +176,6 @@ func (f *VarMgr) GetUserVar(uid int, key string) *VarExpireData {
 	varData := f.getData().NewUseVar[uid]
 	if varData == nil {
 		varData = make(map[string]*VarExpireData)
-		//f.getData().NewUseVar[uid] = varData
 	}
 	ved, ok := varData[key]
 	if !ok {
@@ -200,38 +204,20 @@ func SetVarDataHandler(m *msg.Msg) (interface{}, error) {
 	data := getVarData()
 	data.mu.Lock()
 	defer data.mu.Unlock()
-	if v, ok := m.Extra.(msg.VarData); ok {
+	v, ok := m.Extra.(msg.VarData)
-		ved, ok := data.NewVar[v.Key]
+	if !ok {
-		if !ok {
+		return nil, fmt.Errorf("invalid parameters for setting var data")
-			ved = &VarExpireData{}
-		}
-		switch v.SetType {
-		case msg.VAR_OP_SET:
-			ved.D = v.Value
-		case msg.VAR_OP_ADD:
-			if num, ok := ved.D.(int); ok {
-				ved.D = num + 1
-			} else {
-				ved.D = 1
-			}
-		case msg.VAR_OP_SUB:
-			if num, ok := ved.D.(int); ok {
-				if num > 0 {
-					ved.D = num - 1
-				} else {
-					ved.D = 0
-				}
-			} else {
-				ved.D = 0
-			}
-		}
-		ved.U = time.Now().Unix()
-		if m.End > 0 {
-			ved.T = m.End
-		}
-		data.NewVar[v.Key] = ved
-		SaveCacheVarData(v.Key, ved)
 	}
+	ved, ok := data.NewVar[v.Key]
+	if !ok {
+		ved = &VarExpireData{}
+	}
+	varDataOperation(ved, v.SetType, v.Value)
+	if m.End > 0 {
+		ved.T = m.End
+	}
+	data.NewVar[v.Key] = ved
+	SaveCacheVarData(v.Key, ved)
 	return nil, nil
 }
 
@@ -257,53 +243,69 @@ func SetUserVarDataHandler(m *msg.Msg) (interface{}, error) {
 	data := getVarData()
 	data.mu.Lock()
 	defer data.mu.Unlock()
-	if v, ok := m.Extra.(msg.VarData); ok {
+	v, ok := m.Extra.(msg.VarData)
-		varData := data.NewUseVar[m.To]
+	if !ok {
-		if varData == nil {
+		return nil, fmt.Errorf("invalid parameters for setting var data")
-			varData = make(map[string]*VarExpireData)
-			data.NewUseVar[m.To] = varData
-		}
-		ved, ok := varData[v.Key]
-		if !ok {
-			ved = &VarExpireData{}
-		}
-		switch v.SetType {
-		case msg.VAR_OP_SET:
-			ved.D = v.Value
-		case msg.VAR_OP_ADD:
-			if num, ok := ved.D.(int); ok {
-				ved.D = num + 1
-			} else {
-				ved.D = 1
-			}
-		case msg.VAR_OP_SUB:
-			if num, ok := ved.D.(int); ok {
-				if num > 0 {
-					ved.D = num - 1
-				} else {
-					ved.D = 0
-				}
-			} else {
-				ved.D = 0
-			}
-		}
-		ved.U = time.Now().Unix()
-		if m.End > 0 {
-			ved.T = m.End
-		}
-		varData[v.Key] = ved
-		data.NewUseVar[m.To] = varData
-		SaveCacheVarData(GoUtil.GetVarKey(m.To), data.NewUseVar[m.To])
 	}
-	// 保存到缓存中
+	varData := data.NewUseVar[m.To]
+	if varData == nil {
+		varData = make(map[string]*VarExpireData)
+		data.NewUseVar[m.To] = varData
+	}
+	ved := varData[v.Key]
+	if ved == nil {
+		ved = &VarExpireData{}
+	}
+	varDataOperation(ved, v.SetType, v.Value)
+	if m.End > 0 {
+		ved.T = m.End
+	}
+	varData[v.Key] = ved
+	SaveCacheVarData(GoUtil.GetVarKey(m.To), varData)
 	return nil, nil
 }
 
 func GetVarDataHandler(m *msg.Msg) (interface{}, error) {
+	data := getVarData()
+	varData := &VarExpireData{}
+	info, ok := m.Extra.(msg.VarData)
+	if !ok {
+		return nil, fmt.Errorf("invalid parameters for getting var data")
+	}
+	varData, _ = data.NewVar[info.Key]
+	if varData == nil {
+		varData = &VarExpireData{}
+	}
+	ReplyPlayerMsgASync(m, varData.D)
+	return varData, nil
+}
+
+func SetDailyVarDataHandler(m *msg.Msg) (interface{}, error) {
+	data := getVarData()
+	data.mu.Lock()
+	defer data.mu.Unlock()
+	info, ok := m.Extra.(msg.VarData)
+	if !ok {
+		return nil, fmt.Errorf("invalid parameters for getting daily var data")
+	}
+	varData := data.DailyVar[info.Key]
+	if varData == nil {
+		varData = &VarExpireData{}
+	}
+	varDataOperation(varData, info.SetType, info.Value)
+	if m.End > 0 {
+		varData.T = m.End
+	}
+	data.DailyVar[info.Key] = varData
+	SaveCacheVarData(GoUtil.GetVarKey(m.To), varData)
+	return nil, nil
+}
+
+func GetDailyVarDataHandler(m *msg.Msg) (interface{}, error) {
 	data := getVarData()
 	varData := &VarExpireData{}
 	if v, ok := m.Extra.(msg.VarData); ok {
-		varData, _ = data.NewVar[v.Key]
+		varData, _ = data.DailyVar[v.Key]
 		if varData == nil {
 			varData = &VarExpireData{}
 		}
@@ -312,3 +314,28 @@ func GetVarDataHandler(m *msg.Msg) (interface{}, error) {
 	}
 	return nil, fmt.Errorf("invalid parameters for getting var data")
 }
+
+func varDataOperation(varData *VarExpireData, setType int, value interface{}) *VarExpireData {
+	switch setType {
+	case msg.VAR_OP_SET:
+		varData.D = value
+	case msg.VAR_OP_ADD:
+		if num, ok := varData.D.(int); ok {
+			varData.D = num + 1
+		} else {
+			varData.D = 1
+		}
+	case msg.VAR_OP_SUB:
+		if num, ok := varData.D.(int); ok {
+			if num > 0 {
+				varData.D = num - 1
+			} else {
+				varData.D = 0
+			}
+		} else {
+			varData.D = 0
+		}
+	}
+	varData.U = GoUtil.Now()
+	return varData
+}

src/server/game_util/GoUtil.go

@@ -6,12 +6,16 @@ import (
 	"crypto/cipher"
 	"crypto/md5"
 	crand "crypto/rand"
+	"crypto/sha256"
 	"encoding/base64"
 	"encoding/gob"
+	"encoding/hex"
 	"fmt"
 	"io"
 	"math/rand"
+	"net/http"
 	"reflect"
+	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 	"strings"
 	"sync"
@@ -321,6 +325,11 @@ func Rand6DigitNumber() string {
 	return fmt.Sprintf("%06d", n)
 }
 
+func Rand8DigitNumber() string {
+	n := rand.Intn(100000000)
+	return fmt.Sprintf("%08d", n)
+}
+
 func UniqueInts(input []int) []int {
 	seen := make(map[int]struct{})
 	result := make([]int, 0, len(input))
@@ -547,3 +556,70 @@ func GetISOCodeByIP(ip string) (string, error) {
 func GetVarKey(Uid int) string {
 	return fmt.Sprintf("var_%d", Uid)
 }
+
+const (
+	PROJECT_ID              = "20659"
+	ACCESS_ID               = "a3d8c1f0e5b72a49"
+	NOTIFICATION_SECRET_KEY = "K8pYrR6fXcVzWbAqN3mHsD4gJtL9iUvO1"
+)
+
+func NotifyPlayer(uid, pushid int, title, content string) {
+
+	url := "https://tygapi-new.tuyooglobal.com/api/push/ga/push_message/project_trigger"
+	method := "POST"
+	executeId := fmt.Sprintf("%s_%s", PROJECT_ID, Rand8DigitNumber()+Rand8DigitNumber())
+	payload := strings.NewReader(`[
+    {
+        "projectId": "` + PROJECT_ID + `",
+        "platform": "firebasepush",
+        "pushId": "` + PROJECT_ID + `_` + fmt.Sprintf("%08d", pushid) + `",
+		"executeId": "` + executeId + `",
+        "environment": "production",
+        "title": "` + title + `",
+        "body": "` + content + `",
+        "userId": [
+            "` + strconv.Itoa(uid) + `"
+        ]
+    }
+]`)
+
+	client := &http.Client{}
+	req, err := http.NewRequest(method, url, payload)
+
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	d, _ := time.ParseDuration("30m")
+	timestamp := time.Now().Add(d).Unix()
+
+	var strBuilder strings.Builder
+	strBuilder.WriteString("Access-Id=" + ACCESS_ID + "&Random=a2dS8Iyak03Ma91JC1xR&Secret-Type=forever&Sign-Type=sha256&Timestamp=")
+	strBuilder.WriteString(strconv.Itoa(int(timestamp)))
+	strBuilder.WriteString(":" + NOTIFICATION_SECRET_KEY)
+
+	m := sha256.New()
+	m.Write([]byte(strBuilder.String()))
+	signature := hex.EncodeToString(m.Sum(nil))
+
+	req.Header.Add("Access-Id", ACCESS_ID)
+	req.Header.Add("Secret-Type", "forever")
+	req.Header.Add("Sign-Type", "sha256")
+	req.Header.Add("Random", "a2dS8Iyak03Ma91JC1xR")
+	req.Header.Add("Timestamp", strconv.Itoa(int(timestamp)))
+	req.Header.Add("Signature", signature)
+	req.Header.Add("Content-Type", "application/json")
+	res, err := client.Do(req)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	log.Debug("notification send uid %d, type %d , res %s", uid, pushid, string(body))
+}

src/server/game_util/feishu.go

@@ -17,6 +17,9 @@ const (
 
 // AAqFpbuPhFSEx
 func SendFeishuFatal(PlayerId int, FuncName string, msg string) error {
+	if conf.Server.GameName == "pet_home_local" {
+		return nil
+	}
 	// 创建请求体
 	stack := make([]byte, 1024)
 	length := runtime.Stack(stack, false)

src/server/test/config_test.go

@@ -6,6 +6,7 @@ import (
 	baseCfg "server/conf/base"
 	friendCfg "server/conf/friend"
 	languageCfg "server/conf/language"
+	notification_cfg "server/conf/notification"
 	playroomCfg "server/conf/playroom"
 	userCfg "server/conf/user"
 	GoUtil "server/game_util"
@@ -42,3 +43,26 @@ func TestGetEnergyByADNum(t *testing.T) {
 	r := baseCfg.GetEnergyByADNum()
 	fmt.Println("r:", r)
 }
+
+func TestGetFriendApplyNotificationCooldown(t *testing.T) {
+	Cooldown := notification_cfg.GetFriendApplyNotificationCooldown()
+	fmt.Println("Cooldown:", Cooldown)
+}
+
+func TestGetPetroomGameNotificationCooldown(t *testing.T) {
+	Cooldown, dailyLimit := notification_cfg.GetPetroomGameNotificationCooldown()
+	fmt.Println("Cooldown:", Cooldown)
+	fmt.Println("dailyLimit:", dailyLimit)
+}
+
+func TestGetPetroomGameNotificationMsg(t *testing.T) {
+	titlekey, infokey := notification_cfg.GetPetroomGameNotificationMsg()
+	fmt.Println("titlekey:", titlekey)
+	fmt.Println("infokey:", infokey)
+}
+
+func TestGetFriendApplyNotificationMsg(t *testing.T) {
+	titlekey, infokey := notification_cfg.GetFriendApplyNotificationMsg()
+	fmt.Println("titlekey:", titlekey)
+	fmt.Println("infokey:", infokey)
+}

src/server/test/fix_test.go

@@ -3,8 +3,12 @@ package test
 import (
 	"fmt"
 	decorateCfg "server/conf/decorate"
+	languageCfg "server/conf/language"
+	notification_cfg "server/conf/notification"
 	"server/db"
 	"server/game"
+	GoUtil "server/game_util"
+	"server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"testing"
 )
@@ -91,8 +95,18 @@ func TestRandInt(t *testing.T) {
 func TestEndless(t *testing.T) {
 	p1 := new(game.Player)
 	p1.InitPlayer("3625212")
-	BaseMod := p1.GetBaseMod()
+	MailMod := p1.GetMailMod()
-	ChargeMod := p1.GetChargeMod()
+	MailMod.BackData()
-	EndlessMod := p1.GetEndlessMod()
+}
-	EndlessMod.ZeroUpdate(ChargeMod.GetMaxCharge(), BaseMod.GetLevel())
+
+// 10130 10165
+func TestNotify(t *testing.T) {
+	titlekey, infokey := notification_cfg.GetFriendApplyNotificationMsg()
+	title := languageCfg.GetLanguage(msg.LANG_TYPE(1), titlekey)
+	info := languageCfg.GetLanguage(msg.LANG_TYPE(1), infokey)
+	// titlekey, infokey := notification_cfg.GetPetroomGameNotificationMsg()
+	// title := languageCfg.GetLanguage(msg.LANG_TYPE(1), titlekey)
+	// info := languageCfg.GetLanguage(msg.LANG_TYPE(1), infokey)
+	GoUtil.NotifyPlayer(10130, 2, title, fmt.Sprintf(info, "猫猫"))
+	// GoUtil.NotifyPlayer(19246, 1, "Test Notification", "This is a test notification from the server.")
 }