Merge branch 'develop' into sdk

.gitignore

@@ -19,3 +19,4 @@ src/server/test/logs/*
 src/server/test/teLog/*
 src/server/*.exe*
 src/server/msg/Gameapi.pb.go
+src/server/gen-go

src/server/backend/server.go

@@ -0,0 +1,24 @@
+package backend
+
+func Start() {
+	// addr := net.JoinHostPort("localhost", "9090")
+	// handler := NewGameServiceHandler()
+
+	// //创建处理器
+	// processor := backend.NewGameAdminServiceProcessor(handler)
+
+	// transportFactory := thrift.NewTBufferedTransportFactory(8192)
+	// protocolFactory := thrift.NewTBinaryProtocolFactoryConf(&thrift.TConfiguration{})
+
+	// tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
+	// if err != nil {
+	// 	fmt.Printf("Failed to resolve address %s: %v\n", addr, err)
+	// 	return
+	// }
+	// serverTransport := thrift.NewTServerSocketFromAddrTimeout(tcpAddr, 0)
+	// server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
+	// fmt.Printf("Starting the server on %s...\n", addr)
+	// if err := server.Serve(); err != nil {
+	// 	fmt.Printf("Error starting the server: %v\n", err)
+	// }
+}

src/server/backend/sever_handler.go

@@ -0,0 +1,135 @@
+package backend
+
+// type GameServiceHandler struct{}
+
+// func NewGameServiceHandler() *GameServiceHandler {
+// 	return &GameServiceHandler{}
+// }
+
+// func (h *GameServiceHandler) ReqPlayerInfo(ctx context.Context, id int64) (*backend.ResAdminInfo, error) {
+// 	player := game.G_GameLogicPtr.GetPlayer(int64(id))
+// 	online := true
+// 	if player == nil {
+// 		player = new(game.Player)
+// 		player.M_DwUin = int64(id)
+// 		player.InitPlayerOnly()
+// 		player.ZeroUpdate(nil)
+// 		online = false
+// 	}
+// 	res := &backend.ResAdminInfo{}
+// 	res.Name = player.GetBaseMod().NickName
+// 	res.UID = player.M_DwUin
+// 	res.AreaId = int32(player.GetDecorateMod().GetAreaId())
+// 	res.Face = int32(player.GetFaceMod().SetId)
+// 	res.Charge = player.GetChargeMod().Charge
+// 	res.MaxCharge = player.GetChargeMod().MaxCharge
+// 	res.Level = int32(player.GetPlayerBaseMod().GetLevel())
+// 	res.Diamond = int32(player.GetPlayerBaseMod().GetDiamond())
+// 	res.Star = int32(player.GetPlayerBaseMod().GetStar())
+// 	res.Energy = int32(player.GetPlayerBaseMod().GetEnergy())
+// 	res.UserName = player.GetPlayerBaseMod().GetName()
+// 	res.LoginTime = player.GetBaseMod().LoginTime
+// 	res.Cumulative = int32(player.GetBaseMod().Cumulative)
+// 	res.RegisterTime = int32(player.GetPlayerBaseMod().GetRegisterTime())
+// 	res.TodayCumulative = int32(player.GetBaseMod().TodayCumulative)
+// 	res.Ban = int8(db.GetPlayerBan(player.GetBaseMod().Account))
+// 	if online {
+// 		res.Cumulative = int32(int64(player.GetBaseMod().Cumulative) + GoUtil.Now() - int64(player.GetBaseMod().LoginTime))
+// 		res.TodayCumulative = int32(int64(player.GetBaseMod().TodayCumulative) + GoUtil.Now() - int64(player.GetBaseMod().LoginTime))
+// 	}
+// 	res.Code = player.GetBaseMod().AddCode
+// 	res.ChessMap = player.GetChessMod().ChessMap
+// 	resActLog := make([]*backend.Actlog, 0, len(player.GetFriendMod().ActivityLog))
+// 	for _, log := range player.GetFriendMod().ActivityLog {
+// 		resActLog = append(resActLog, &backend.Actlog{
+// 			Type:  int8(log.Type),
+// 			Time:  log.Time,
+// 			Param: log.Param,
+// 		})
+// 	}
+// 	res.ActLog = resActLog
+// 	friendList := player.GetFriendMod().NewFriendList
+// 	type friendInfo struct {
+// 		Uid        int64
+// 		NickName   string
+// 		Avatar     int
+// 		Level      int
+// 		LogoutTime int64
+// 		LoginTime  int64
+// 	}
+// 	resFriendList := make([]*backend.FriendInfo, 0, len(friendList))
+// 	for v := range friendList {
+// 		ps := game.G_GameLogicPtr.GetSimplePlayerByUid(v)
+// 		if ps == nil {
+// 			continue
+// 		}
+// 		resFriendList = append(resFriendList, &backend.FriendInfo{
+// 			UID:        int64(v),
+// 			NickName:   ps.Name,
+// 			Face:       int32(ps.Face),
+// 			Level:      int32(ps.Level),
+// 			LogoutTime: ps.Loginout,
+// 			LoginTime:  ps.Login,
+// 		})
+// 	}
+// 	res.FriendList = resFriendList
+// 	OrderMap := make(map[int32]*backend.OrderInfo)
+// 	Index := 0
+// 	for k, v := range player.GetOrderMod().OrderList {
+// 		OrderMap[int32(Index)] = &backend.OrderInfo{
+// 			ID:      int32(k),
+// 			Type:    int32(v.Type),
+// 			Time:    v.Timestamp,
+// 			ChessId: GoUtil.IntSliceToString(v.MergeId),
+// 			Diff:    int8(v.Diff),
+// 		}
+// 		Index++
+// 	}
+// 	res.OrderList = OrderMap
+// 	return res, nil
+// }
+
+// func (h *GameServiceHandler) ReqReloadServerMail(ctx context.Context) (*backend.ResMessage, error) {
+// 	game.G_GameLogicPtr.MailMgrCall(&msg.Msg{Type: msg.HANDLE_TYPE_MAIL_RELOAD})
+// 	game.G_GameLogicPtr.NotifyAll(&msg.Msg{Type: msg.HANDLE_TYPE_MAIL})
+// 	log.Debug("ReqReloadServerMail success")
+// 	return &backend.ResMessage{
+// 		Code: 0,
+// 	}, nil
+// }
+
+// func (h *GameServiceHandler) ReqConfigReload(ctx context.Context) (*backend.ResMessage, error) {
+// 	gamedata.Reload()
+// 	return &backend.ResMessage{
+// 		Code: 0,
+// 	}, nil
+// }
+
+// func (h *GameServiceHandler) ReqAdminGm(ctx context.Context, uid int64, command string) (*backend.ResMessage, error) {
+// 	player := game.G_GameLogicPtr.GetPlayer(uid)
+// 	if player == nil {
+// 		return &backend.ResMessage{
+// 			Code: 1,
+// 			Msg:  "player not online",
+// 		}, nil
+// 	}
+// 	player.Lock()
+// 	defer player.UnLock()
+// 	err := game.ReqGmCommand_(player, command)
+// 	if err != nil {
+// 		return &backend.ResMessage{
+// 			Code: 1,
+// 			Msg:  err.Error(),
+// 		}, nil
+// 	}
+// 	return &backend.ResMessage{
+// 		Code: 0,
+// 	}, nil
+// }
+
+// func (h *GameServiceHandler) ReqAdminBan(ctx context.Context, uid int64, banTime int64) (*backend.ResMessage, error) {
+// 	db.UpdatePlayerBan(uid, banTime)
+// 	return &backend.ResMessage{
+// 		Code: 0,
+// 	}, nil
+// }

src/server/cluster/Cluster.go

@@ -95,7 +95,7 @@ func (a *Agent) Run() {
 		m := msg.Msg{}
 		err = GoUtil.GobUnmarshal(data, &m)
 		if err != nil {
-			log.Debug("decode err: %v", err)
+			log.Debug("decode err: %v, data: %s", err, string(data))
 			return
 		}
 		err = processMsg(a, &m)

src/server/conf/activity/activity_cfg.go

@@ -90,6 +90,42 @@ func GetActivityList() []*gamedata.ActivityData {
 	}
 	return List
 }
+func GetActivityListOrigin() []*gamedata.ActivityData {
+	data, err := gamedata.GetData(CFG_ACTIVITY)
+	if err != nil {
+		log.Debug("GetActivityList err:%v", err)
+		return nil
+	}
+	List := make([]*gamedata.ActivityData, 0, len(data))
+
+	for k, v := range data {
+		StartTimeStr := gamedata.GetStringValue(v, "StartTime")
+		EndTimeStr := gamedata.GetStringValue(v, "EndTime")
+		StartTime := GoUtil.ParseTime(StartTimeStr)
+		EndTime := GoUtil.ParseTime(EndTimeStr)
+		Id, err := strconv.Atoi(k)
+		if err != nil {
+			log.Debug("GetActivityList parse id err:%v, key:%s", err, k)
+			continue
+		}
+		Type := gamedata.GetIntValue(v, "Type")
+		Name := gamedata.GetStringValue(v, "Name")
+		Title := gamedata.GetStringValue(v, "Title")
+		Level := gamedata.GetIntValue(v, "Level")
+		ActivityData := &gamedata.ActivityData{
+			Id:        Id,
+			Type:      Type,
+			AType:     gamedata.GetIntValue(v, "AType"),
+			Name:      Name,
+			Title:     Title,
+			Level:     Level,
+			StartTime: StartTime,
+			EndTime:   EndTime,
+		}
+		List = append(List, ActivityData)
+	}
+	return List
+}
 
 func GetActivityRewardItems(ActId int) []*item.Item {
 	data, err := gamedata.GetData(CFG_ACTIVITY_GIFT)

src/server/conf/champship/champship_cfg.go

@@ -5,6 +5,7 @@ import (
 	GoUtil "server/game_util"
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
+	"strings"
 )
 
 const (
@@ -12,6 +13,7 @@ const (
 	CFG_CHAMPSHIP_RANK    = "ChampshipRank"
 	CFG_CHAMPSHIP_JACKPOT = "ChampshipJackpot"
 	CFG_CHAMPSHIP_GROUP   = "ChampshipGroup"
+	CFG_CHAMPSHIP_CONST   = "ChampshipConst"
 )
 
 func init() {
@@ -19,6 +21,7 @@ func init() {
 	gamedata.InitCfg(CFG_CHAMPSHIP_RANK)
 	gamedata.InitCfg(CFG_CHAMPSHIP_JACKPOT)
 	gamedata.InitCfg(CFG_CHAMPSHIP_GROUP)
+	gamedata.InitCfg(CFG_CHAMPSHIP_CONST)
 }
 
 func GetGroupId(N int) int {
@@ -44,7 +47,7 @@ func GetChessScore(ChessLv int) int {
 	return gamedata.GetIntValue(data, "Score")
 }
 
-func GetReward(Reward, Score int) (int, []*item.Item) {
+func GetReward(Reward, Score, activityId int) (int, []*item.Item) {
 	data, err := gamedata.GetData(CFG_CHAMPSHIP_JACKPOT)
 	if err != nil {
 		log.Debug("GetReward err:%v, Reward=%d, Score=%d", err, Reward, Score)
@@ -52,8 +55,12 @@ func GetReward(Reward, Score int) (int, []*item.Item) {
 	}
 	r := make([]*item.Item, 0, len(data))
 	NewReward := Reward
-	for k, v := range data {
+	for _, v := range data {
-		Id := GoUtil.Int(k)
+		rewardGroupType := gamedata.GetIntValue(v, "RewardGroupType")
+		if rewardGroupType != activityId {
+			continue
+		}
+		Id := gamedata.GetIntValue(v, "Step")
 		if Reward >= Id {
 			continue
 		}
@@ -84,14 +91,14 @@ func GetRewardTotalScore(Reward int) int {
 	return gamedata.GetIntValue(data, "Total")
 }
 
-func GetRankReward(Rank int) []*item.Item {
+func GetRankReward(Rank, yesterdayActivityId int) []*item.Item {
 	data, err := gamedata.GetData(CFG_CHAMPSHIP_RANK)
 	if err != nil {
-		log.Debug("GetRankReward err:%v, Rank=%d", err, Rank)
+		log.Debug("GetRankReward err:%v, Rank=%d, yesterdayActivityId=%d", err, Rank, yesterdayActivityId)
 		return nil
 	}
 	for _, v := range data {
-		if Rank >= gamedata.GetIntValue(v, "Min") && Rank <= gamedata.GetIntValue(v, "Max") {
+		if Rank >= gamedata.GetIntValue(v, "Min") && Rank <= gamedata.GetIntValue(v, "Max") && yesterdayActivityId == gamedata.GetIntValue(v, "RewardGroupType") {
 			return gamedata.GetItemList(v, "Items")
 		}
 	}
@@ -113,3 +120,20 @@ func GetMaxRewardId() int {
 	}
 	return MaxId
 }
+
+func GetChampshipActivityId() []int {
+	data, err := gamedata.GetDataByKey(CFG_CHAMPSHIP_CONST, "RewardGroupType_const")
+	if err != nil {
+		log.Debug("GetChampshipActivityId err:%v", err)
+		return nil
+	}
+	value := gamedata.GetStringValue(data, "Value")
+	var res []int
+	for _, v := range strings.Split(value, "|") {
+		id := GoUtil.Int(v)
+		if id > 0 {
+			res = append(res, id)
+		}
+	}
+	return res
+}

src/server/conf/daily_task/daily_task_cfg.go

@@ -5,6 +5,7 @@ import (
 	"server/gamedata"
 	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
+	"strings"
 )
 
 const (
@@ -12,6 +13,7 @@ const (
 	DAILY_TASK         = "DailyTask"
 	DAILY_TASK_ACTIVE  = "DailyTaskActive"
 	DAILY_TASK_JACKPOT = "DailyTaskJackpot"
+	DAILY_TASK_REWARD  = "DailyTaskReward"
 )
 
 func init() {
@@ -19,6 +21,67 @@ func init() {
 	gamedata.InitCfg(DAILY_TASK)
 	gamedata.InitCfg(DAILY_TASK_ACTIVE)
 	gamedata.InitCfg(DAILY_TASK_JACKPOT)
+	gamedata.InitCfg(DAILY_TASK_REWARD)
+}
+
+func GetDailyTaskReward(Id, factory, activityId int) []*item.Item {
+	data, err := gamedata.GetData(DAILY_TASK_REWARD)
+	if err != nil {
+		log.Debug("GetDailyTaskReward err:%v", err)
+		return nil
+	}
+	for _, v := range data {
+		sortId := gamedata.GetIntValue(v, "SortId")
+		rewardGroupType := gamedata.GetIntValue(v, "RewardGroupType")
+		if sortId == Id && rewardGroupType == activityId {
+			items := gamedata.GetItemList(v, "ItemID")
+			petCoinBase := gamedata.GetIntValue(v, "PetCoinBase")
+			if petCoinBase > 0 {
+				petCoinNum := int(float64(petCoinBase) * (float64(factory)/1000 + 1))
+				petCoinNum = (petCoinNum/5 + 1) * 5 // 向上取整到5的倍数
+				items = append(items, &item.Item{
+					Id:  item.ITEM_STAR_ID,
+					Num: petCoinNum,
+				})
+			}
+			return items
+		}
+	}
+	return nil
+}
+
+func GetDailyTaskScore(Id, activityId int) int {
+	data, err := gamedata.GetData(DAILY_TASK_REWARD)
+	if err != nil {
+		log.Debug("GetDailyTaskScore err:%v", err)
+		return 0
+	}
+	for _, v := range data {
+		sortId := gamedata.GetIntValue(v, "SortId")
+		rewardGroupType := gamedata.GetIntValue(v, "RewardGroupType")
+		if sortId == Id && rewardGroupType == activityId {
+			return gamedata.GetIntValue(v, "ScoreReward")
+		}
+	}
+	return 0
+}
+
+func GetActivityIds() []int {
+	data, err := gamedata.GetDataByKey(DAILY_TASK_CONST, "RewardGroupType_const")
+	if err != nil {
+		log.Debug("GetActivityIds err:%v", err)
+		return nil
+	}
+	str := gamedata.GetStringValue(data, "Value")
+	strArr := strings.Split(str, "|")
+	result := make([]int, 0, len(strArr))
+	for _, v := range strArr {
+		a, _ := strconv.Atoi(v)
+		if a != 0 {
+			result = append(result, a)
+		}
+	}
+	return result
 }
 
 // 获取任务列表

src/server/conf/friend/friend_cfg.go

@@ -41,3 +41,30 @@ func GetFriendLimitNum() int {
 	}
 	return gamedata.GetIntValue(data, "Value")
 }
+
+func GetDailyRecommendLimit() int {
+	data, err := gamedata.GetDataByKey(CFG_CONST, "friend_daily_recommend_limit")
+	if err != nil {
+		log.Debug("GetDailyRecommendLimit err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetApplyListLimit() int {
+	data, err := gamedata.GetDataByKey(CFG_CONST, "friend_apply_list_limit")
+	if err != nil {
+		log.Debug("GetApplyListLimit err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetDailyGetApplyLimit() int {
+	data, err := gamedata.GetDataByKey(CFG_CONST, "friend_daily_get_apply_limit")
+	if err != nil {
+		log.Debug("GetDailyGetApplyLimit err:%v", err)
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}

src/server/conf/fur/fur_cfg.go

@@ -0,0 +1,73 @@
+package fur_cfg
+
+import (
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_FUR_CONST = "FurShopConst"
+	CFG_FUR_SHOP  = "FurShop"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_FUR_CONST)
+	gamedata.InitCfg(CFG_FUR_SHOP)
+}
+
+func GetFurShopCost(id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_FUR_SHOP, id)
+	if err != nil {
+		return nil
+	}
+	return gamedata.GetItemList(data, "Cost")
+}
+
+func GetFurShopFreeTimes() int {
+	data, err := gamedata.GetDataByKey(CFG_FUR_CONST, "free_unlock")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetFurShopTag(id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_FUR_SHOP, id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "TAG")
+}
+
+func GetFurShopName(id int) string {
+	data, err := gamedata.GetDataByIntKey(CFG_FUR_SHOP, id)
+	if err != nil {
+		return ""
+	}
+	return gamedata.GetStringValue(data, "Name")
+}
+
+func GetFurShopItem(id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_FUR_SHOP, id)
+	if err != nil {
+		return nil
+	}
+	itemId := gamedata.GetIntValue(data, "ItemID")
+	if itemId == 0 {
+		return nil
+	}
+	return []*item.Item{
+		{
+			Id:  itemId,
+			Num: 1,
+		},
+	}
+}
+
+func GetFurShopCostNum(id int) int {
+	item := GetFurShopCost(id)
+	if len(item) == 0 {
+		return 0
+	}
+	return item[0].Num
+}

src/server/conf/mining/mining_cfg.go

@@ -88,10 +88,35 @@ func GetRandItem() []*item.Item {
 	return gamedata.GetItemList(Info, "Items")
 }
 
-func GetPassItem(Id int) []*item.Item {
+func GetPassItem(Id int, needStar int) []*item.Item {
 	data, err := gamedata.GetDataByIntKey(CFG_MINING_PASS, Id)
 	if err != nil {
 		return nil
 	}
-	return gamedata.GetItemList(data, "Items")
+	items := gamedata.GetItemList(data, "Items")
+	starReward := gamedata.GetIntValue(data, "StarReward")
+	var starnum int
+	if starReward > 0 {
+		starnum = int(needStar * starReward / 100)
+		if starnum > 0 {
+			items = append(items, &item.Item{
+				Id:  item.ITEM_STAR_ID,
+				Num: starnum,
+			})
+		}
+	}
+	return items
+}
+
+func GetPassItemList(needStar int) map[int][]*item.Item {
+	data, err := gamedata.GetData(CFG_MINING_PASS)
+	if err != nil {
+		return nil
+	}
+	result := make(map[int][]*item.Item)
+	for k := range data {
+		Id := GoUtil.Int(k)
+		result[Id] = GetPassItem(Id, needStar)
+	}
+	return result
 }

src/server/conf/seven_login/seven_login_cfg.go

@@ -40,7 +40,7 @@ func GetSevenLoginReward() []*gamedata.SevenLoginRewardData {
 	return result
 }
 
-func GetSevenLoginMonthReward() []*gamedata.SevenLoginRewardData {
+func GetSevenLoginMonthReward(nowMonth int) []*gamedata.SevenLoginRewardData {
 	data, err := gamedata.GetData(CFG_SEVEN_LOGIN_MONTH)
 	if err != nil {
 		log.Debug("GetSevenLoginReward err:%v", err)
@@ -48,6 +48,10 @@ func GetSevenLoginMonthReward() []*gamedata.SevenLoginRewardData {
 	}
 	var result []*gamedata.SevenLoginRewardData
 	for k, v := range data {
+		month := gamedata.GetIntValue(v, "Month")
+		if month != nowMonth {
+			continue
+		}
 		Id, _ := strconv.Atoi(k)
 		Diamond := gamedata.GetIntValue(v, "Diamond")
 		RewardNum := gamedata.GetIntValue(v, "RewardNum")

src/server/db/Mysql.go

@@ -442,3 +442,13 @@ func GetCommendPlayerFromDb(uid, login int64, level int) ([]int, error) {
 	}
 	return res, nil
 }
+
+func GetDebugPlayer(uid int) ([]int, error) {
+	sqlStr := "SELECT dwUin FROM t_player_baseinfo WHERE dwUin != ? ORDER BY login_time DESC LIMIT 1000"
+	var res []int
+	if err := SqlDb.Select(&res, sqlStr, uid); err != nil {
+		log.Debug("table: %s, sql :%s, exec failed, err:%v\n", "PlayerBaseInfo", sqlStr, err)
+		return nil, err
+	}
+	return res, nil
+}

src/server/game/GameLogic.go

@@ -212,6 +212,7 @@ func (ad *GameLogic) NewAccountInsertDataToDB() bool {
 	player := new(Player)
 	BaseMod := player.PlayMod.getBaseMod()
 	BaseMod.Account = ad.Db_AccountInfo.UserName
+	BaseMod.RegisterTime = time.Now().Unix()
 	player.TeLog("register", nil)
 
 	return true
@@ -454,6 +455,7 @@ func (ad *GameLogic) GetResFriendPlayerByUid(Id int) *msg.ResFriendPlayerSimple
 		Physiology: GoUtil.MapIntToInt32(player.Physiology),
 		Last:       last,
 		PetName:    player.PetName,
+		PetFur:     int32(player.PetFur),
 	}
 }
 
@@ -640,6 +642,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqKv", ReqKv)                                 // 保存客户端数据
 	RegisterMsgProcessFunc("ReqGetEnergyByAD", ReqGetEnergyByAD)           // 看广告获取能量
 	RegisterMsgProcessFunc("ReqBuyEnergy", ReqBuyEnergy)                   // 购买能量
+	RegisterMsgProcessFunc("ReqAdWatch", ReqAdWatch)                       // 观看广告
 	// #region 棋盘
 	RegisterMsgProcessFunc("ReqPlayerChessData", ReqPlayerChessDataFunc)
 	RegisterMsgProcessFunc("UpdatePlayerChessData", UpdatePlayerChessDataFunc) // 更新棋盘数据
@@ -840,6 +843,9 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqPlayroomTaskReward", ReqPlayroomTaskReward)         // 领取任务奖励
 	RegisterMsgProcessFunc("ReqPlayroomGameShowReward", ReqPlayroomGameShowReward) // 展示游戏结果数据
 	RegisterMsgProcessFunc("ReqPlayroomGuide", ReqPlayroomGuide)                   // 展示游戏结果数据
+	RegisterMsgProcessFunc("ReqPetFur", ReqPetFur)                                 // 宠物毛皮信息
+	RegisterMsgProcessFunc("ReqPetFurBuy", ReqPetFurBuy)                           // 宠物毛皮商店购买
+	RegisterMsgProcessFunc("ReqFurSet", ReqFurSet)                                 //宠物毛皮设置
 	// 宠物宝藏
 	RegisterMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure)           // 请求好友宝藏数据
 	RegisterMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始游戏

src/server/game/activity_func.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	activityCfg "server/conf/activity"
 	catnipCfg "server/conf/catnip"
+	champshipCfg "server/conf/champship"
+	dailyTaskCfg "server/conf/daily_task"
 	guesscolorCfg "server/conf/guess_color"
 	languageCfg "server/conf/language"
 	miningCfg "server/conf/mining"
@@ -185,16 +187,24 @@ func (p *Player) MiningBackData() {
 	}
 	Status := p.GetActivityStatus(activity.ACT_TYPE_MINING)
 	Template := miningCfg.GetTemplate(ActivityInfo.Id)
+	DecorateMod := p.PlayMod.getDecorateMod()
+	needStar := DecorateMod.GetNextNeedStar()
+	passRewardList := miningCfg.GetPassItemList(needStar)
+	resPassRewardList := make(map[int32]*msg.ItemList)
+	for k, v := range passRewardList {
+		resPassRewardList[int32(k)] = item.ItemListToMsg(v)
+	}
 	MiningMod := p.PlayMod.getMiningMod()
 	p.PushClientRes(&msg.ResMining{
-		Id:       int32(ActivityInfo.Id),
+		Id:         int32(ActivityInfo.Id),
-		Status:   int32(Status),
+		Status:     int32(Status),
-		EndTime:  int32(ActivityInfo.EndT),
+		EndTime:    int32(ActivityInfo.EndT),
-		Template: int32(Template),
+		Template:   int32(Template),
-		Pass:     int32(MiningMod.GetPass()),
+		Pass:       int32(MiningMod.GetPass()),
-		Gem:      GoUtil.IntToInt32(MiningMod.GetGem()),
+		Gem:        GoUtil.IntToInt32(MiningMod.GetGem()),
-		Map:      MiningMod.GetMap(),
+		Map:        MiningMod.GetMap(),
-		Mining:   int32(MiningMod.GetMining()),
+		Mining:     int32(MiningMod.GetMining()),
+		PassReward: resPassRewardList,
 	})
 }
 
@@ -422,3 +432,49 @@ func (p *Player) CatnipBackData() {
 	}
 	p.PushClientRes(res)
 }
+
+func (p *Player) GetChampshipActivityId() (int, int) {
+	var todayActivityId int
+	var yesterdayActivityId int
+	activiyCfgList := activityCfg.GetActivityListOrigin()
+	Now := GoUtil.Now()
+	YesterDay := GoUtil.ZeroTimestamp() - 1
+	level := p.GetBaseMod().GetLevel()
+	champshipActivityIds := champshipCfg.GetChampshipActivityId()
+	for _, v := range activiyCfgList {
+		if !GoUtil.InArray(v.Id, champshipActivityIds) {
+			continue
+		}
+		if v.Level > level {
+			continue
+		}
+		if v.StartTime <= Now && v.EndTime >= Now {
+			todayActivityId = v.Id
+		}
+		if v.StartTime <= YesterDay && v.EndTime >= YesterDay {
+			yesterdayActivityId = v.Id
+		}
+	}
+	return todayActivityId, yesterdayActivityId
+}
+
+func (p *Player) GetDailyTaskActivityId() int {
+	var activityId int
+	activiyCfgList := activityCfg.GetActivityListOrigin()
+	Now := GoUtil.Now()
+	level := p.GetBaseMod().GetLevel()
+	activityIds := dailyTaskCfg.GetActivityIds()
+	for _, v := range activiyCfgList {
+		if !GoUtil.InArray(v.Type, activityIds) {
+			continue
+		}
+		if v.Level > level {
+			continue
+		}
+		if v.StartTime <= Now && v.EndTime >= Now {
+			activityId = v.Id
+			break
+		}
+	}
+	return activityId
+}

src/server/game/admin.go

@@ -33,7 +33,8 @@ var AdminFuncMap = map[string]func([]interface{}) error{
 func AdminProcess(Func string, args []interface{}) {
 	defer func() {
 		if r := recover(); r != nil {
-			GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", r))
+			log.Error("uid : %d, func : %s, fatal : %s", 0, Func, r)
+			//GoUtil.SendFeishuFatal(0, Func, fmt.Sprintf("fatal : %s", r))
 		}
 	}()
 	if f, ok := AdminFuncMap[Func]; ok {
@@ -171,7 +172,6 @@ func AdminPlayerInfo(args []interface{}) error {
 	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
 	res["Star"] = player.GetPlayerBaseMod().GetStar()
 	res["Energy"] = player.GetPlayerBaseMod().GetEnergy()
-	res["Diamond"] = player.GetPlayerBaseMod().GetDiamond()
 	res["Mac"] = player.GetPlayerBaseMod().GetName()
 	res["Login"] = player.PlayMod.getBaseMod().LoginTime
 	res["Cumulative"] = player.PlayMod.getBaseMod().Cumulative

src/server/game/champship_mgr.go

@@ -94,7 +94,7 @@ func (c *ChampshipMgr) Init() {
 	Remain1 := 1800 - Remain%1800
 
 	c.mDispatr.AfterFunc(time.Duration(Remain1)*time.Second, func() { // 30分钟后重新分组
-		c.group()
+		c.group(false)
 	})
 
 	c.mDispatr.AfterFunc(time.Duration(60)*time.Second, func() {
@@ -116,6 +116,7 @@ func (c *ChampshipMgr) NotifyAll() (interface{}, error) {
 }
 
 func (c *ChampshipMgr) ZeroUpdate() (interface{}, error) {
+	c.group(true)
 	log.Debug("ChampshipMgr ZeroUpdate")
 	data := c.getData()
 	data.mu.Lock()
@@ -282,6 +283,7 @@ func (c *ChampshipMgr) GetPreRankMsg(Uid int) *proto.ResChampshipPreRank {
 				Avatar: int32(Robot.Avatar),
 				Face:   int32(Robot.Face),
 				Level:  int32(Robot.Level),
+				Type:   int32(v.Type),
 			}
 		} else {
 			SimplePlayer := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
@@ -340,6 +342,7 @@ func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank {
 				Avatar: int32(Robot.Avatar),
 				Face:   int32(Robot.Face),
 				Level:  int32(Robot.Level),
+				Type:   int32(v.Type),
 			}
 		} else {
 			SimplePlayer := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
@@ -353,6 +356,7 @@ func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank {
 				Avatar: int32(SimplePlayer.Avatar),
 				Face:   int32(SimplePlayer.Face),
 				Level:  int32(SimplePlayer.Level),
+				Type:   int32(v.Type),
 			}
 		}
 	}
@@ -365,22 +369,22 @@ func (c *ChampshipMgr) GetRankMsg(Uid int) *proto.ResChampshipRank {
 }
 
 // 分组
-func (c *ChampshipMgr) group() (interface{}, error) {
+func (c *ChampshipMgr) group(iszero bool) (interface{}, error) {
-	c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() { // 30分钟后重新分组
-		c.group()
-	})
 	Now := GoUtil.Now()
 	Zero := GoUtil.ZeroTimestamp()
-	if Now-Zero < 1800 { // 0点30分钟内不分组
+	if Now-Zero < 1800 && !iszero { // 0点30分钟内不分组
 		return nil, nil
 	}
+	c.mDispatr.AfterFunc(time.Duration(1800)*time.Second, func() { // 30分钟后重新分组
+		c.group(false)
+	})
 	ChampshipData := c.getData()
 	ChampshipData.mu.Lock()
 	defer ChampshipData.mu.Unlock()
+	log.Debug("ChampshipMgr group, player num:%d", len(ChampshipData.Pool))
 	if len(ChampshipData.Pool) == 0 { // 未分配玩家池为空
 		return nil, nil
 	}
-	log.Debug("ChampshipMgr group, player num:%d", len(ChampshipData.Pool))
 	g := make(map[int][]int, 0)
 	for k, v := range ChampshipData.Pool { // step 1:根据数值分配玩家
 		x := 0

src/server/game/friend_func.go

@@ -1,6 +1,7 @@
 package game
 
 import (
+	"math"
 	"server/db"
 	"server/game/mod/msg"
 	GoUtil "server/game_util"
@@ -156,43 +157,153 @@ func GetRecommendPlayer(p *Player, Num int) []int {
 			candidateList = append(candidateList, Uid)
 		}
 	}
-	baseList := make([]*PlayerSimpleData, 0, len(candidateList))
+	levelFilterList := make([]*PlayerSimpleData, 0, len(candidateList))
 	for _, uid := range candidateList {
 		ps := G_GameLogicPtr.GetSimplePlayerByUid(uid)
 		if ps != nil {
-			baseList = append(baseList, ps)
+			levelFilterList = append(levelFilterList, ps)
 		}
 	}
-	if len(baseList) == 0 {
+	if len(levelFilterList) == 0 {
 		return nil
 	}
 	BaseMod := p.PlayMod.getBaseMod()
 	level := BaseMod.GetLevel()
 	diffLimit := 10
-	filtered := make([]int, 0, len(baseList))
+	chargeFilterList := make([]*PlayerSimpleData, 0, len(levelFilterList))
 	breakNum := 100
+	/*
+		等级筛选：检索与玩家等级差绝对值小于等于10的用户，若大于5人，则进入下一步筛查，否则逐步放宽等级差限制，直到等级差绝对值小于等于100，仍然无法筛选出5人，则进入下一步筛查
+	*/
 	for breakNum > 0 {
 		breakNum--
-		filtered = filtered[:0]
+		chargeFilterList = chargeFilterList[:0]
-		for _, ps := range baseList {
+		for _, ps := range levelFilterList {
 			if ps == nil {
 				continue
 			}
-			diff := level - ps.Level
+			diff := math.Abs(float64(level - ps.Level))
-			if diff < 0 {
+			if diff <= float64(diffLimit) {
-				diff = -diff
+				chargeFilterList = append(chargeFilterList, ps)
-			}
-			if diff <= diffLimit {
-				filtered = append(filtered, ps.Uid)
 			}
 		}
-		if len(filtered) >= 5 {
+		if len(chargeFilterList) >= 5 {
 			break
 		}
 		diffLimit++
 	}
-	candidateList = filtered
+	/*
-	recommendList := GoUtil.RandSliceNum(candidateList, Num)
+		付费筛查，判断自身是否为付费用户，若是，则优先推荐付费用户，若不是，则优先推荐非付费用户
+	*/
+	endFilterList := make([]int, 0, len(chargeFilterList))
+	chargeFilterFunc := func(filterlist []*PlayerSimpleData, maxCharge float64) []int {
+		var res []int
+		type sortData struct {
+			uid       int
+			maxCharge float64
+		}
+		var filterList2 []sortData
+		var notChargeList []int
+		var allList []int
+		for _, ps := range filterlist {
+			if ps == nil {
+				continue
+			}
+			allList = append(allList, ps.Uid)
+			if ps.MaxCharge > 0 {
+				filterList2 = append(filterList2, sortData{ps.Uid, math.Abs(maxCharge - ps.MaxCharge)})
+			} else {
+				notChargeList = append(notChargeList, ps.Uid)
+			}
+		}
+		sort.Slice(filterList2, func(i, j int) bool {
+			return filterList2[i].maxCharge < filterList2[j].maxCharge
+		})
+		if len(filterList2) >= 1 {
+			res = append(res, filterList2[0].uid)
+		}
+		if len(filterList2) >= 2 {
+			res = append(res, filterList2[1].uid)
+		}
+		if len(notChargeList) >= 1 {
+			res = append(res, notChargeList[0])
+		}
+		if len(res) < 3 {
+			dlist := GoUtil.SubSlices(allList, res)
+			res = append(res, GoUtil.RandSliceNum(dlist, 3-len(res))...)
+		}
+		return res
+	}
+	notChargeWatchAdFilterFunc := func(filterlist []*PlayerSimpleData) []int {
+		var res []int
+		var notChargeList []int
+		var chargeList []int
+		var allList []int
+		for _, ps := range filterlist {
+			if ps == nil {
+				continue
+			}
+			allList = append(allList, ps.Uid)
+			if ps.MaxCharge > 0 {
+				chargeList = append(chargeList, ps.Uid)
+			} else {
+				if ps.AdWatch > 5 {
+					notChargeList = append(notChargeList, ps.Uid)
+				}
+			}
+		}
+		if len(notChargeList) >= 1 {
+			res = append(res, notChargeList[0])
+		}
+		if len(notChargeList) >= 2 {
+			res = append(res, notChargeList[1])
+		}
+		if len(chargeList) >= 1 {
+			res = append(res, chargeList[0])
+		}
+		if len(res) < 3 {
+			dlist := GoUtil.SubSlices(allList, res)
+			res = append(res, GoUtil.RandSliceNum(dlist, 3-len(res))...)
+		}
+		return res
+	}
+	notChargeNotWatchAdFilterFunc := func(filterlist []*PlayerSimpleData) []int {
+		var res []int
+		var notChargeList []int
+		var chargeList []int
+		var allList []int
+		for _, ps := range filterlist {
+			if ps == nil {
+				continue
+			}
+			allList = append(allList, ps.Uid)
+			if ps.MaxCharge > 0 {
+				chargeList = append(chargeList, ps.Uid)
+			} else {
+				notChargeList = append(notChargeList, ps.Uid)
+			}
+		}
+		if len(chargeList) >= 1 {
+			res = append(res, chargeList[0])
+		}
+		dlist := GoUtil.SubSlices(allList, res)
+		res = append(res, GoUtil.RandSliceNum(dlist, 3-len(res))...)
+		return res
+	}
+	if diffLimit == 10 && len(chargeFilterList) >= 5 {
+		MaxCharge := p.GetChargeMod().GetMaxCharge()
+		if MaxCharge > 0 {
+			endFilterList = chargeFilterFunc(chargeFilterList, MaxCharge)
+		} else {
+			if p.GetChargeMod().GetAdWatch() > 5 {
+				endFilterList = notChargeWatchAdFilterFunc(chargeFilterList)
+			} else {
+				endFilterList = notChargeNotWatchAdFilterFunc(chargeFilterList)
+			}
+		}
+	}
+
+	recommendList := GoUtil.RandSliceNum(endFilterList, Num)
 	for _, Uid := range recommendList {
 		FriendMod.AddRecommend(Uid)
 	}

src/server/game/game_type.go

@@ -39,6 +39,9 @@ type PlayerSimpleData struct {
 	Physiology  map[int]int
 	Lang        int
 	Account     string
+	PetFur      int
+	MaxCharge   float64
+	AdWatch     int
 }
 
 type VarGoldCard struct {

src/server/game/gm_handler.go

@@ -134,6 +134,7 @@ func ReqGmCommand_(player *Player, Command string) error {
 	case "setSevenLoginActive":
 		num, _ := strconv.Atoi(arg[1])
 		player.PlayMod.getSevenLoginMod().Active = num
+		player.PushClientRes(player.PlayMod.getSevenLoginMod().BackData())
 	case "pay":
 		ChargeId, _ := strconv.Atoi(arg[1])
 		player.TeLog("pay", map[string]interface{}{
@@ -409,13 +410,13 @@ func ReqGmCommand_(player *Player, Command string) error {
 	case "resetFriend":
 		FriendMod := player.PlayMod.getFriendMod()
 		FriendMod.FriendList = make(map[int]struct{})
-		FriendMod.ApplyList = make(map[int]int64)
+		FriendMod.NewApplyList = make(map[int]*friend.ApplyInfo)
 		FriendMod.Card = make(map[string]*card.CardInfo)
 		FriendMod.SendApply = make(map[int]int64)
 		FriendMod.NewFriendList = make(map[int]*friend.FriendInfo)
-		FriendMod.Npc = []int{}
+		FriendMod.Npc = nil
 		FriendMod.Id = 0
-		FriendMod.Log = make([]*friend.LogInfo, 0)
+		FriendMod.Log = nil
 		FriendMod.InitData()
 		player.FriendListBackData()
 		player.FriendLogBackData()
@@ -618,7 +619,32 @@ func ReqGmCommand_(player *Player, Command string) error {
 		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))
-
+	case "resetWeekReward":
+		SevenMod := player.PlayMod.getSevenLoginMod()
+		SevenMod.MonthResetTime = 0
+		PlayerBaseMod := player.GetPlayerBaseMod()
+		SevenMod.ZeroUpdate(PlayerBaseMod.GetSevenLoginAdd(), PlayerBaseMod.GetLastLoginTime())
+	case "debugLogoutMsg":
+		ToUid, _ := strconv.Atoi(arg[1])
+		uidList, err := db.GetDebugPlayer(ToUid)
+		if err != nil {
+			log.Error("GetDebugPlayer err:%s", err.Error())
+			return err
+		}
+		for _, uid := range uidList {
+			FriendMgrSend(&MsgMod.Msg{
+				Type:  MsgMod.HANDLE_TYPE_APPLY,
+				SendT: GoUtil.Now(),
+				From:  uid,
+				To:    ToUid,
+			})
+			FriendMgrSend(&MsgMod.Msg{
+				Type:  MsgMod.HANDLE_TYPE_HANDBOOK_COLLECTION,
+				SendT: GoUtil.Now(),
+				From:  uid,
+				To:    ToUid,
+			})
+		}
 	default:
 		return fmt.Errorf("Player %d ReqGmCommand:%v not found", player.M_DwUin, arg)
 	}

src/server/game/mail_mgr.go

@@ -57,7 +57,11 @@ func (m *MailMgr) Init() {
 }
 
 func (m *MailMgr) AddMail(msg *msg.Msg) (interface{}, error) {
-	ServerMail := msg.Extra.(*ServerMail)
+	ServerMail, ok := msg.Extra.(*ServerMail)
+	if !ok {
+		log.Error("AddMail error: invalid mail data")
+		return nil, nil
+	}
 	m.list[ServerMail.Id] = ServerMail
 	return nil, nil
 }

src/server/game/message_handler.go

@@ -62,7 +62,12 @@ func (p *Player) handle(m *msg.Msg) error {
 	switch m.Type {
 	case msg.HANDLE_TYPE_APPLY: // 好友申请
 		FriendMod := p.PlayMod.getFriendMod()
-		ok := FriendMod.AddFriendApply(m.From)
+		var addType int
+		info, ok := m.Extra.(map[string]interface{})
+		if ok {
+			addType = GoUtil.Int(info["type"])
+		}
+		ok = FriendMod.AddFriendApply(m.From, addType, m.SendT)
 		// 已申请
 		if ok {
 			return nil
@@ -520,7 +525,57 @@ func (p *Player) handle(m *msg.Msg) error {
 	case msg.HANDLE_TYPE_FRIEND_SPONSOER:
 		p.AddLog(m.From, friend.LOG_TYPE_FRIEND_SPONSOR_GET, "", m.SendT)
 	case msg.SERVER_PLAYER_SYNC_LOGOUT_MSG:
-		//p.LoginBackData()
+		info, ok := m.Extra.(map[string]interface{})
+		if !ok {
+			return nil
+		}
+		applyUids, ok := info["apply_uids"].([]int64)
+		p.TeLog("login_recive_logout_msg", map[string]interface{}{
+			"apply_uids":  applyUids,
+			"other_uids":  info["other_uids"],
+			"apply_count": info["apply_count"],
+			"other_count": info["other_count"],
+		})
+		if ok && len(applyUids) > 0 {
+			var faceList []int
+			var name string
+			var facebookPic []string
+			for _, v := range applyUids {
+				ps := G_GameLogicPtr.GetSimplePlayerByUid(int(v))
+				if ps != nil {
+					faceList = append(faceList, ps.Face)
+					name = ps.Name
+					facebookPic = append(facebookPic, ps.FaceBookPic)
+				}
+			}
+			p.PushClientRes(&proto.ResPlayerLougouMsg{
+				Name:        name,
+				Face:        GoUtil.IntToInt32(faceList),
+				Count:       GoUtil.Int32(info["apply_count"]),
+				FacebookPic: facebookPic,
+			})
+		}
+		otherUids, ok := info["other_uids"].([]int64)
+		if ok && len(otherUids) > 0 {
+			var faceList []int
+			var name string
+			var facebookPic []string
+			for _, v := range otherUids {
+				ps := G_GameLogicPtr.GetSimplePlayerByUid(int(v))
+				if ps != nil {
+					faceList = append(faceList, ps.Face)
+					name = ps.Name
+					facebookPic = append(facebookPic, ps.FaceBookPic)
+				}
+			}
+			p.PushClientRes(&proto.ResPlayerLougouMsg{
+				Type:        1,
+				Name:        name,
+				Face:        GoUtil.IntToInt32(faceList),
+				Count:       GoUtil.Int32(info["other_count"]),
+				FacebookPic: facebookPic,
+			})
+		}
 	default:
 		log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
 	}
@@ -827,7 +882,7 @@ func (player *Player) AddOrder() {
 			NewChessId := mergeDataCfg.GetChessIdByLvAndColor(BaseMod.GetEnergyMul()+PreheatStep+1, ChessColor)
 			Items, ok := order.PreheatItems[OrderMod.PreheatStep[ChessColor]]
 			if !ok {
-				Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetOrderEmit()))}
+				Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetStarEmitList()))}
 			}
 			OrderMod.AddPreheatOrder([]int{NewChessId}, order.DIFF_LOW, order.Preheat_type, Items)
 		}
@@ -869,7 +924,7 @@ func (player *Player) FixOrderBug() {
 		OrderMod.PreheatStep[k]++
 		Items, ok := order.PreheatItems[OrderMod.PreheatStep[k]]
 		if !ok {
-			Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetOrderEmit()))}
+			Items = []*item.Item{item.NewItem(item.ITEM_STAR_ID, order.GetOrderStar([]int{NewChessId}, ChessMod.GetStarEmitList()))}
 		}
 		OrderMod.AddPreheatOrder([]int{NewChessId}, order.DIFF_LOW, order.Preheat_type, Items)
 	}
@@ -997,7 +1052,7 @@ func (player *Player) CreateNormalOrder() {
 				if v.Type != order.COMFORT_TYPE {
 					continue
 				}
-				Star := order.GetOrderStar(v.MergeId, ChessMod.GetOrderEmit())
+				Star := order.GetOrderStar(v.MergeId, ChessMod.GetStarEmitList())
 				Star = int(float64(Star)*float64(OrderFactor)/1000) * 10
 				v.Items = []*item.Item{{Id: item.ITEM_STAR_ID, Num: Star}}
 				OrderMod.OrderList[k] = v

src/server/game/message_mgr.go

@@ -103,32 +103,32 @@ func (m *MessageMgr) MessageMgrInit() {
 }
 
 func FixBug() {
-	messageMgrData := getMessageData()
+	// messageMgrData := getMessageData()
-	// 先更新 PlayerList（需要加锁）
+	// // 先更新 PlayerList（需要加锁）
-	messageMgrData.mu.Lock()
+	// messageMgrData.mu.Lock()
-	defer messageMgrData.mu.Unlock()
+	// defer messageMgrData.mu.Unlock()
-	now := GoUtil.Now()
+	// now := GoUtil.Now()
-	for k, v := range messageMgrData.MessageList {
+	// for k, v := range messageMgrData.MessageList {
-		if k < 100000 {
+	// 	if k < 100000 {
-			delete(messageMgrData.MessageList, k)
+	// 		delete(messageMgrData.MessageList, k)
-			continue
+	// 		continue
-		}
+	// 	}
-		isLose := CheckPlayerLose(int(k))
+	// 	isLose := CheckPlayerLose(int(k))
-		// 反向遍历以安全删除元素
+	// 	// 反向遍历以安全删除元素
-		for i := len(v.Messages) - 1; i >= 0; i-- {
+	// 	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) {
+	// 		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:]...)
+	// 			v.Messages = append(v.Messages[:i], v.Messages[i+1:]...)
-			}
+	// 		}
-			if isLose && v.Messages[i].Type == msg.HANDLE_TYPE_CHAMPSHIP_RESULT {
+	// 		if isLose && v.Messages[i].Type == msg.HANDLE_TYPE_CHAMPSHIP_RESULT {
-				// 删除消息
+	// 			// 删除消息
-				v.Messages = append(v.Messages[:i], v.Messages[i+1:]...)
+	// 			v.Messages = append(v.Messages[:i], v.Messages[i+1:]...)
-			}
+	// 		}
-		}
+	// 	}
-		if len(v.Messages) == 0 {
+	// 	if len(v.Messages) == 0 {
-			delete(messageMgrData.MessageList, k)
+	// 		delete(messageMgrData.MessageList, k)
-		}
+	// 	}
-	}
+	// }
 }
 
 // 注册处理器
@@ -147,7 +147,7 @@ func (m *MessageMgr) NodeRegister() {
 func (m *MessageMgr) CenterRegister() {
 	if conf.Server.ServerType == "center" {
 		m.RegisterHandler(msg.HANDLE_MOD_PLAYER_LOGIN, MessageHandlerFunc(PlayerLoginHandler))
-		m.RegisterHandler(msg.HANDLE_MDO_PLAYER_LOGOUT, MessageHandlerFunc(PlayerLogoutHandler))
+		m.RegisterHandler(msg.HANDLE_MOD_PLAYER_LOGOUT, MessageHandlerFunc(PlayerLogoutHandler))
 		m.RegisterHandler(msg.HANDLE_MOD_PLAYER_MSG, MessageHandlerFunc(CenterPlayerMsgHandler))
 		m.RegisterHandler(msg.HANDLE_MOD_COMSUME_MSG, MessageHandlerFunc(ComsumerMsgHandler))
 		m.RegisterHandler(msg.HANDLE_MOD_VAR_SET, MessageHandlerFunc(SetVarDataHandler))
@@ -208,7 +208,7 @@ func NotifyAllPlayerMsg(m *msg.Msg) {
 }
 
 func ChampshipGroupHandler(data *msg.Msg) (interface{}, error) {
-	G_GameLogicPtr.ChampshipMgr.group()
+	G_GameLogicPtr.ChampshipMgr.group(true)
 	return nil, nil
 }
 
@@ -293,16 +293,43 @@ func PlayerLoginHandler(data *msg.Msg) (interface{}, error) {
 	messages.mu.Unlock()
 	ReplyPlayerMsgASync(data, nil)
 	// 在锁外发送离线消息
+	var applyUids []int64
+	var otherUids []int64
 	for _, message := range messagesToSend {
-		message.H = msg.MSG_TYPE_OFFLINE // 标记为离线消息
+		if message.Type == msg.HANDLE_TYPE_APPLY {
+			applyUids = append(applyUids, int64(message.From))
+		} else {
+			otherUids = append(otherUids, int64(message.From))
+		}
+	}
+	for _, message := range messagesToSend {
+		if message.Type == msg.HANDLE_TYPE_APPLY && len(applyUids) >= 3 {
+			message.H = msg.MSG_TYPE_OFFLINE // 标记为离线消息
+		}
+		if message.Type != msg.HANDLE_TYPE_APPLY && len(otherUids) >= 3 {
+			message.H = msg.MSG_TYPE_OFFLINE // 标记为离线消息
+		}
 		SendMsgToNodeAsync(message, node)
 	}
+	applyUidsFive := applyUids
+	if len(applyUids) > 5 {
+		applyUidsFive = applyUids[len(applyUids)-5:]
+	}
+	otherUidsFive := otherUids
+	if len(otherUids) > 5 {
+		otherUidsFive = otherUids[len(otherUids)-5:]
+	}
 	SendMsgToNodeAsync(&msg.Msg{
 		From:       data.From,
 		To:         data.From,
 		Type:       msg.SERVER_PLAYER_SYNC_LOGOUT_MSG,
 		HandleType: msg.HANDLE_MOD_PLAYER_MSG,
-		Extra:      len(messagesToSend),
+		Extra: map[string]interface{}{
+			"apply_uids":  applyUidsFive,
+			"apply_count": len(applyUids),
+			"other_uids":  otherUidsFive,
+			"other_count": len(otherUids),
+		},
 	}, node) // 发送离线消息处理完成通知
 	log.Debug("[Middleware] Player sync logout message player id: %v, len: %d", data.From, len(messagesToSend))
 	return nil, nil
@@ -705,9 +732,9 @@ func LoggingMiddleware() MessageMiddleware {
 
 			duration := time.Since(start)
 			if err != nil {
-				log.Error("[Middleware] Message handle type: %d; type: %d failed, duration: %v, error: %v", message.HandleType, message.Type, duration, err)
+				log.Error("[Middleware] Message handle error! message: %v; duration: %v; error: %v", message, duration, err)
 			} else {
-				log.Debug("[Middleware] Message handle type: %d; type: %d success, duration: %v", message.HandleType, message.Type, duration)
+				log.Debug("[Middleware] Message handle success! message: %v; duration: %v", message, duration)
 			}
 
 			return result, err

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

@@ -44,6 +44,7 @@ type Base struct {
 	IdCardNum       string
 	AddCode         string // 用于添加好友的code
 	DiviceId        string // 设备id
+	RegisterTime    int64  // 注册时间
 }
 
 func (b *Base) InitData(Uid int, Ip string) {

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

@@ -35,12 +35,12 @@ func (c *ChampshipMod) GetScore() int {
 	return c.Score
 }
 
-func (c *ChampshipMod) GetRankReward(Rank int) ([]*item.Item, error) {
+func (c *ChampshipMod) GetRankReward(Rank, yesterdayActivityId int) ([]*item.Item, error) {
 	if c.RankReward {
 		return nil, fmt.Errorf("rank reward has been received")
 	}
 	c.RankReward = true
-	return champshipCfg.GetRankReward(Rank), nil
+	return champshipCfg.GetRankReward(Rank, yesterdayActivityId), nil
 }
 
 func (c *ChampshipMod) AddScore(Chess []int) {
@@ -56,14 +56,14 @@ func (c *ChampshipMod) AddScore(Chess []int) {
 	c.Score += score
 }
 
-func (c *ChampshipMod) GetReward() []*item.Item {
+func (c *ChampshipMod) GetReward(activityId int) []*item.Item {
-	Reward, Items := champshipCfg.GetReward(c.Reward, c.Score)
+	Reward, Items := champshipCfg.GetReward(c.Reward, c.Score, activityId)
 	c.Reward = Reward
 	c.Max = max(c.Max, c.Reward)
 	return Items
 }
 
-func (c *ChampshipMod) BackData(MyRank, MyPreRank int) *msg.ResChampship {
+func (c *ChampshipMod) BackData(MyRank, MyPreRank, todayActivityId, yesterdayActivityId int) *msg.ResChampship {
 	rankReward := 0
 	if c.RankReward {
 		rankReward = 2
@@ -75,13 +75,15 @@ func (c *ChampshipMod) BackData(MyRank, MyPreRank int) *msg.ResChampship {
 		status = 1
 	}
 	return &msg.ResChampship{
-		Score:      int32(c.Score),
+		Score:               int32(c.Score),
-		Reward:     int32(c.Reward),
+		Reward:              int32(c.Reward),
-		EndTime:    int32(GoUtil.ZeroTimestamp() + 86400),
+		EndTime:             int32(GoUtil.ZeroTimestamp() + 86400),
-		Period:     int32(GoUtil.GetServerOpenDay()),
+		Period:              int32(GoUtil.GetServerOpenDay()),
-		Rank:       int32(MyRank),
+		Rank:                int32(MyRank),
-		RankReward: int32(rankReward),
+		RankReward:          int32(rankReward),
-		Status:     int32(status),
+		Status:              int32(status),
+		TodayActivityId:     int32(todayActivityId),
+		YesterdayActivityId: int32(yesterdayActivityId),
 	}
 }
 

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

@@ -39,6 +39,8 @@ type ChargeMod struct {
 	WishList       *WishList
 	WeeklyDiscount map[int]int // 每周折扣购买次数
 	WeeklyEndTime  int64
+
+	AdWatch int // 观看广告次数
 }
 
 type WishList struct {
@@ -132,6 +134,7 @@ func (c *ChargeMod) ZeroUpdate(Emit []int) {
 	c.FreeShop = 0
 	SpecialGrade := 1
 	c.TodayCharge = 0
+	c.AdWatch = 0
 	c.SpecialShop = make(map[int]*SepcialShop)
 	SpecialShopCount := chargeCfg.GetSpecialShopCount()
 	for i := 1; i <= 2; i++ {
@@ -310,7 +313,6 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 			if len(ChessList) == 1 {
 				ChessList = append(ChessList, ChessList[0]-1)
 			}
-			//ColorType := mergeDataCfg.GetColorType(p)
 			for _, c := range ChessList {
 				if c == 0 {
 					continue
@@ -489,3 +491,11 @@ func (c *ChargeMod) GetWeeklyEndTime() int64 {
 func (c *ChargeMod) SetWeeklyEndTime(EndTime int64) {
 	c.WeeklyEndTime = EndTime
 }
+
+func (c *ChargeMod) GetAdWatch() int {
+	return c.AdWatch
+}
+
+func (c *ChargeMod) AddAdWatch() {
+	c.AdWatch++
+}

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

@@ -304,7 +304,14 @@ func (cb *ChessBorad) emitListToSlice(retireFilter bool) []int {
 	for _, v := range EM {
 		result = append(result, v)
 	}
-	return result
+	if !retireFilter {
+		for k, v := range cb.Honor {
+			if v == 1 {
+				result = append(result, k)
+			}
+		}
+	}
+	return GoUtil.UniqueInts(result)
 }
 
 func (cb *ChessBorad) GetStarEmitList() []int {

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

@@ -8,7 +8,8 @@ import (
 	"sort"
 )
 
-func getTaskReward(Id, AreaId int) []*item.Item {
+func getTaskReward(Id, AreaId, activityId int) []*item.Item {
+	
 	switch Id {
 	case 2:
 		StarNum := int(50 * math.Pow(1.04, float64(AreaId)))

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

@@ -3,6 +3,7 @@ package dailyTask
 import (
 	"fmt"
 	dailyTaskCfg "server/conf/daily_task"
+	orderCfg "server/conf/order"
 	"server/game/mod/item"
 	"server/game/mod/quest"
 	GoUtil "server/game_util"
@@ -48,15 +49,15 @@ func (dt *DailyTaskMod) Unlock() {
 	dt.Lock = true
 }
 
-func (dt *DailyTaskMod) LevUpTrigger(Lv, AreaId int) bool {
+func (dt *DailyTaskMod) LevUpTrigger(Lv, AreaId, dailyAcitivityId int) bool {
 	if len(dt.DayTask) != 0 {
 		return false
 	}
-	dt.ZeroUpdate(Lv, AreaId)
+	dt.ZeroUpdate(Lv, AreaId, dailyAcitivityId)
 	return true
 }
 
-func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId int) {
+func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId, activityId int) {
 	TaskList := dailyTaskCfg.GetTaskList(Lv)
 	if len(TaskList) <= 0 {
 		return
@@ -65,6 +66,7 @@ func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId int) {
 	LastTaskId := GoUtil.GetMapKey(dt.lastTask)
 	TaskList1 := GoUtil.SubSlices(TaskListId, LastTaskId)
 	TaskId := GoUtil.RandSliceNum(TaskList1, 3)
+	OrderFactor := orderCfg.GetOrderFactor(AreaId)
 	for i := 0; i < len(TaskId); i++ {
 		Id := i + 1
 		questStr := TaskList[TaskId[i]]
@@ -72,7 +74,7 @@ func (dt *DailyTaskMod) ZeroUpdate(Lv, AreaId int) {
 		if err != nil {
 			log.Debug("parse quest err str : %s", questStr)
 		}
-		Items := getTaskReward(Id, AreaId)
+		Items := dailyTaskCfg.GetDailyTaskReward(Id, OrderFactor, activityId)
 		dt.DayTask[Id] = DailyTask{
 			Items:  Items,
 			UnLock: Id == 1,
@@ -165,12 +167,12 @@ func (dt *DailyTaskMod) BackData() *msg.ResDailyTask {
 	}
 }
 
-func (dt *DailyTaskMod) GetDailyReward(id int) ([]*item.Item, error) {
+func (dt *DailyTaskMod) GetDailyReward(id, activityId int) ([]*item.Item, error) {
 	if v, ok := dt.DayTask[id]; ok {
 		if v.Status == quest.QUEST_STATUS_FINISH {
 			v.Status = quest.QUEST_STATUS_REWARD
 			dt.DayTask[id] = v
-			dt.Active += 5
+			dt.Active += dailyTaskCfg.GetDailyTaskScore(id, activityId)
 			return v.Items, nil
 		}
 	}

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

@@ -5,6 +5,7 @@ import (
 	"math"
 	decorateCfg "server/conf/decorate"
 	limitedTimeEventCfg "server/conf/limited_time_event"
+	orderCfg "server/conf/order"
 	"server/game/mod/item"
 	GoUtil "server/game_util"
 	"server/msg"
@@ -119,6 +120,18 @@ func (d *Decorate) GetDecorateCostItem(AreaId, DecorateId int, DecorateOffIsExis
 	return Items, PetExp, PartItemList
 }
 
+func (d *Decorate) GetNextNeedStar() int {
+	DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)
+	SubAlice := GoUtil.SubSlices(DecorateAll, GoUtil.MapIntToIntSlice(d.FinishList))
+	orderFactor := orderCfg.GetOrderFactor(d.GetAreaId())
+	sort.Ints(SubAlice)
+	if len(SubAlice) > 0 {
+		NeedStar := decorateCfg.GetStarCost(d.AreaId, SubAlice[0])
+		return (NeedStar*orderFactor)/1000 + NeedStar
+	}
+	return 0
+}
+
 // 一键装饰
 func (d *Decorate) DecorateAll(Star int, DecorateOffIsExist bool) ([]*item.Item, []*item.Item, int, []int, []interface{}, int) {
 	DecorateAll := decorateCfg.GetAllSortIdByAreaId(d.AreaId)

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

@@ -8,25 +8,29 @@ import (
 	"server/game/mod/item"
 	GoUtil "server/game_util"
 	"server/msg"
+	"sort"
 )
 
 type FriendMod struct {
-	FriendList    map[int]struct{}          // TODO 废弃 好友列表
+	FriendList     map[int]struct{}          // 废弃 好友列表
-	NewFriendList map[int]*FriendInfo       // 好友列表
+	NewFriendList  map[int]*FriendInfo       // 好友列表
-	ApplyList     map[int]int64             // 好友请求列表
+	ApplyList      map[int]int64             // 废弃 好友请求列表
-	SendApply     map[int]int64             // 发送的申请
+	NewApplyList   map[int]*ApplyInfo        // 好友请求列表
-	Apply         []*ApplyInfo              // 其他请求列表
+	SendApply      map[int]int64             // 发送的申请
-	Card          map[string]*card.CardInfo // 收到的申请交换
+	Apply          []*ApplyInfo              // 其他请求列表
-	Log           []*LogInfo                // 日志
+	Card           map[string]*card.CardInfo // 收到的申请交换
-	AutoId        int
+	Log            []*LogInfo                // 日志
-	Id            int64               // 已同步msg ID
+	AutoId         int
-	Npc           []int               // npc id
+	Id             int64               // 已同步msg ID
-	Bubble        map[int]*BubbleInfo // 气泡
+	Npc            []int               // npc id
-	ActivityLog   []*ActLogInfo       // 活动日志
+	Bubble         map[int]*BubbleInfo // 气泡
-	ReplyList     []*ReplyInfo        // 好友回复列表
+	ActivityLog    []*ActLogInfo       // 活动日志
-	DailySponsor  int                 // 好友赞助次数
+	ReplyList      []*ReplyInfo        // 好友回复列表
-	RecommendList map[int]*Recommend
+	DailySponsor   int                 // 好友赞助次数
-	DailyGetApply int // 每日获得申请次数
+	RecommendList  map[int]*Recommend
+	DailyGetApply  int // 每日获得申请次数
+	DailyRecommend int // 每日推荐次数
+	Version        int // 数据版本，增加新字段时需要更新版本号
 }
 
 type Recommend struct {
@@ -63,6 +67,7 @@ type FriendInfo struct {
 	AddTime  int64
 	DelTime  int64
 	Interact []*Interact // 拜访记录
+	Greeting bool        // 是否打过招呼
 }
 
 type Interact struct {
@@ -71,9 +76,8 @@ type Interact struct {
 }
 
 type ApplyInfo struct {
-	Type int // 1:申请 2:同意 3:拒绝 4:删除
+	Type int
 	Time int64
-	Uid  int64
 }
 
 const (
@@ -133,7 +137,8 @@ const (
 )
 
 const (
-	APPLY_TYPE_WISH = 1 // 心愿单请求
+	APPLY_TYPE_FRIEND_CODE = 1 // 好友码申请
+	APPLY_TYPE_WISH        = 2 // 心愿单请求
 )
 
 const (
@@ -216,12 +221,44 @@ func (f *FriendMod) InitData() {
 	if f.RecommendList == nil {
 		f.RecommendList = make(map[int]*Recommend)
 	}
+	if f.NewApplyList == nil {
+		f.NewApplyList = make(map[int]*ApplyInfo)
+	}
+	f.version()
+}
+
+func (f *FriendMod) version() {
+	if f.Version == 0 {
+		f.Version = 1
+		for k := range f.ApplyList {
+			f.NewApplyList[k] = &ApplyInfo{
+				Time: f.ApplyList[k],
+			}
+		}
+		type sortData struct {
+			Uid  int
+			Time int64
+		}
+		PlayerList := make([]sortData, 0)
+		for k, v := range f.NewApplyList {
+			PlayerList = append(PlayerList, sortData{k, v.Time})
+		}
+		sort.Slice(PlayerList, func(i, j int) bool {
+			return PlayerList[i].Time > PlayerList[j].Time
+		})
+		for i := 0; i < len(PlayerList); i++ {
+			if i >= friendCfg.GetApplyListLimit() {
+				delete(f.NewApplyList, PlayerList[i].Uid)
+			}
+		}
+	}
 }
 
 // 零点更新
 func (f *FriendMod) ZeroUpdate() {
 	f.DailySponsor = f.GetDailySponsorLimit()
 	f.DailyGetApply = 0
+	f.DailyRecommend = 0
 }
 
 func (f *FriendMod) GetNpc() []int {
@@ -295,7 +332,7 @@ func (f *FriendMod) AddFriend(id int) {
 	f.NewFriendList[id] = &FriendInfo{
 		AddTime: GoUtil.Now(),
 	}
-	delete(f.ApplyList, id)
+	delete(f.NewApplyList, id)
 }
 
 // 获取卡牌交换信息
@@ -320,6 +357,12 @@ func (f *FriendMod) DelCardInfo(Id string) {
 // 删除好友
 func (f *FriendMod) DelFriend(id int) {
 	f.NewFriendList[id].DelTime = GoUtil.Now()
+	// 删除好友后清除打招呼
+	for _, v := range f.ReplyList {
+		if v.Uid == id && (v.Type == REPLY_TYPE_GREETING || v.Type == REPLY_TYPE_GREETING_Get) {
+			v.Status = 1
+		}
+	}
 }
 
 // 检查是否好友
@@ -335,13 +378,13 @@ func (f *FriendMod) GetFriendLen() int {
 
 // 拒绝好友申请
 func (f *FriendMod) RefuseApply(id int) {
-	delete(f.ApplyList, id)
+	delete(f.NewApplyList, id)
 	delete(f.SendApply, id)
 }
 
 // 检查好友申请
 func (f *FriendMod) CheckApply(id int) bool {
-	_, ok := f.ApplyList[id]
+	_, ok := f.NewApplyList[id]
 	return ok
 }
 func (f *FriendMod) GetFriendNum() int {
@@ -384,11 +427,38 @@ func (f *FriendMod) CheckAddBefore(uid int) bool {
 }
 
 // 收到申请
-func (f *FriendMod) AddFriendApply(Uid int) bool {
+func (f *FriendMod) AddFriendApply(Uid, Type int, sendTime int64) bool {
-	if f.DailyGetApply >= 30 {
+	if f.DailyGetApply >= friendCfg.GetDailyGetApplyLimit() {
 		return true
 	}
-	f.ApplyList[Uid] = GoUtil.Now()
+	var code_type int
+	for _, v := range f.NewApplyList {
+		if v.Type == APPLY_TYPE_FRIEND_CODE {
+			code_type++
+		}
+	}
+	// 好友申请列表只保留十条，好友码申请不受数量限制
+	if code_type >= friendCfg.GetApplyListLimit() && Type != APPLY_TYPE_FRIEND_CODE {
+		return true
+	}
+	var minTime int64
+	if len(f.NewApplyList) >= friendCfg.GetApplyListLimit() {
+		for _, v := range f.NewApplyList {
+			if v.Type != APPLY_TYPE_FRIEND_CODE && (minTime == 0 || v.Time < minTime) {
+				minTime = v.Time
+			}
+		}
+		for k, v := range f.NewApplyList {
+			if v.Time == minTime {
+				delete(f.NewApplyList, k)
+				break
+			}
+		}
+	}
+	f.NewApplyList[Uid] = &ApplyInfo{
+		Type: Type,
+		Time: sendTime,
+	}
 	f.DailyGetApply++
 	return false
 }
@@ -416,7 +486,7 @@ func (f *FriendMod) GetSendApplyTime(Id int) int64 {
 func (f *FriendMod) AgreeApply(UId int) {
 	f.AddFriend(UId)
 	delete(f.SendApply, UId)
-	delete(f.ApplyList, UId)
+	delete(f.NewApplyList, UId)
 }
 
 // 增加好友日志
@@ -540,16 +610,7 @@ func (f *FriendMod) GetReward(Id int) ([]*item.Item, error) {
 
 // 增加心愿单申请
 func (f *FriendMod) AddWishApply(Uid int64) error {
-	for _, v := range f.Apply {
+
-		if v.Type == APPLY_TYPE_WISH && v.Uid == Uid {
-			return fmt.Errorf("wish apply already exist")
-		}
-	}
-	f.Apply = append(f.Apply, &ApplyInfo{
-		Type: APPLY_TYPE_WISH,
-		Uid:  Uid,
-		Time: GoUtil.Now(),
-	})
 	return nil
 }
 
@@ -566,12 +627,7 @@ func (f *FriendMod) GetWishApply() []*ApplyInfo {
 
 // 同意心愿单申请
 func (f *FriendMod) ApplyWish(Uid int64) error {
-	for k, v := range f.Apply {
+
-		if v.Type == APPLY_TYPE_WISH && v.Uid == Uid {
-			f.Apply = append(f.Apply[:k], f.Apply[k+1:]...)
-			return nil
-		}
-	}
 	return fmt.Errorf("wish apply not exist")
 }
 
@@ -586,7 +642,7 @@ func (f *FriendMod) GetActLogLast() *ActLogInfo {
 // 增加待回复请求
 func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64, Items []*item.Item) *ReplyInfo {
 	f.AutoId++
-	ReplyInfo := &ReplyInfo{
+	Reply := &ReplyInfo{
 		Id:      f.AutoId,
 		Uid:     Uid,
 		Type:    Type,
@@ -595,8 +651,11 @@ func (f *FriendMod) AddReplyInfo(Uid int, Type int, Param string, EndTime int64,
 		EndTime: EndTime,
 		Items:   Items,
 	}
-	f.ReplyList = append(f.ReplyList, ReplyInfo)
+	f.ReplyList = append(f.ReplyList, Reply)
-	return ReplyInfo
+	if len(f.ReplyList) > 20 {
+		f.ReplyList = f.ReplyList[len(f.ReplyList)-20:]
+	}
+	return Reply
 }
 
 // 回复请求
@@ -658,3 +717,24 @@ func (f *FriendMod) GetRecommendTime(uid int) int64 {
 	}
 	return 0
 }
+
+func (f *FriendMod) AddDailyRecommend() error {
+	f.DailyRecommend++
+	if f.DailyRecommend > friendCfg.GetDailyRecommendLimit() {
+		return fmt.Errorf("daily recommend limit %d reached", friendCfg.GetDailyRecommendLimit())
+	}
+	return nil
+}
+
+func (f *FriendMod) GreetingFriend(Uid int) {
+	if v, ok := f.NewFriendList[Uid]; ok {
+		v.Greeting = true
+	}
+}
+
+func (f *FriendMod) CheckGreeting(Uid int) bool {
+	if v, ok := f.NewFriendList[Uid]; ok {
+		return v.Greeting
+	}
+	return false
+}

src/server/game/mod/fur/fur.go

@@ -0,0 +1,84 @@
+package fur
+
+import (
+	"fmt"
+	fur_cfg "server/conf/fur"
+	"server/game/mod/item"
+	"server/msg"
+)
+
+type FurMod struct {
+	Set  int
+	List map[int]*FurInfo
+	Free int
+}
+
+type FurInfo struct {
+	Id      int
+	AddTime int64
+	EndTime int64
+}
+
+func (f *FurMod) InitData() {
+	if f.List == nil {
+		f.List = make(map[int]*FurInfo)
+	}
+}
+
+// 获取毛皮信息
+func (f *FurMod) GetFurInfo(id int) *FurInfo {
+	info, ok := f.List[id]
+	if !ok {
+		return nil
+	}
+	return info
+}
+
+// 增加毛皮
+func (f *FurMod) AddFurInfo(id int, addTime, endTime int64) {
+	f.List[id] = &FurInfo{
+		Id:      id,
+		AddTime: addTime,
+		EndTime: endTime,
+	}
+}
+
+func (f *FurMod) GetFurBuyCost(id int) ([]*item.Item, []*item.Item) {
+	freeCount := fur_cfg.GetFurShopFreeTimes()
+	if f.Free < freeCount {
+		f.Free++
+		return nil, fur_cfg.GetFurShopItem(id)
+	}
+	return fur_cfg.GetFurShopCost(id), fur_cfg.GetFurShopItem(id)
+}
+
+// 设置毛皮
+func (f *FurMod) SetFur(id int) error {
+	if id == 0 {
+		f.Set = 0
+		return nil
+	}
+	if _, ok := f.List[id]; !ok {
+		return fmt.Errorf("fur id not found")
+	}
+	f.Set = id
+	return nil
+}
+
+func (f *FurMod) GetFurSet() int {
+	return f.Set
+}
+
+// 消息返回
+func (f *FurMod) BackData() *msg.ResPetFur {
+	freeCount := fur_cfg.GetFurShopFreeTimes()
+	furId := make([]int32, 0, len(f.List))
+	for id := range f.List {
+		furId = append(furId, int32(id))
+	}
+	return &msg.ResPetFur{
+		FurId:     furId,
+		FurSet:    int32(f.Set),
+		FreeCount: int32(freeCount - f.Free),
+	}
+}

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

@@ -58,8 +58,13 @@ const (
 	ITEM_TYPE_PLAYROOM_DRESS_SET      = 114 // playroom服饰套装
 	ITEM_TYPE_PLAYROOM_BOX            = 115 // playroom宝箱
 	ITEM_TYPE_ACT_PASS                = 116 // 通行证活动道具
+	ITEM_TYPE_PET_FUR                 = 117 // 宠物毛皮
 )
 
+func (i *Item) String() string {
+	return fmt.Sprintf("Item{Id:%d, Num:%d}", i.Id, i.Num)
+}
+
 func (i *ItemMod) InitData() {
 	if i.Data == nil {
 		i.Data = make(map[int]int)
@@ -161,6 +166,22 @@ func ItemToMsg(items []*Item) []*msg.ItemInfo {
 	return itemList
 }
 
+func ItemListToMsg(items []*Item) *msg.ItemList {
+	if items == nil {
+		return nil
+	}
+	itemList := make([]*msg.ItemInfo, 0, len(items))
+	for _, v := range items {
+		itemList = append(itemList, &msg.ItemInfo{
+			Id:  int32(v.Id),
+			Num: int32(v.Num),
+		})
+	}
+	return &msg.ItemList{
+		List: itemList,
+	}
+}
+
 // 道具叠加
 func Merge(Item1, Item2 []*Item) []*Item {
 	if Item1 == nil {

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

@@ -250,8 +250,7 @@ func (l *LimitedTimeEventMod) BackData() *msg.ResLimitEvent {
 func (l *LimitedTimeEventMod) ProgressBackData() *msg.ResLimitEventProgress {
 	r := make(map[int32]int32)
 	for k, v := range l.ProgressReward {
-		Type := limitedTimeEventCfg.GetProgressRewardType(v)
+		r[int32(k)] = int32(v)
-		r[int32(k)] = int32(Type)
 	}
 	return &msg.ResLimitEventProgress{
 		Progress:       int32(l.Progress),

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

@@ -81,12 +81,12 @@ func (m *MiningMod) Take(Map map[int32]string, Gem int) ([]*item.Item, error) {
 	return Items, nil
 }
 
-func (m *MiningMod) GetReward() ([]*item.Item, int, error) {
+func (m *MiningMod) GetReward(needStar int) ([]*item.Item, int, error) {
 	GemList := miningCfg.GetPassGem(m.Pass)
 	if len(m.Gem) < len(GemList) {
 		return nil, 0, fmt.Errorf("gem is not full")
 	}
-	Items := miningCfg.GetPassItem(m.Pass)
+	Items := miningCfg.GetPassItem(m.Pass, needStar)
 	m.Pass++
 	Ming := m.Mining
 	m.Mining = 0

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

@@ -1,19 +1,22 @@
 package msg
 
-import "server/game/mod/item"
+import (
+	"fmt"
+	"server/game/mod/item"
+)
 
 type Msg struct {
-	Type       int          // 消息类型
+	Type       int          `json:"type"`  // 消息类型
-	To         int          // 接收者
+	To         int          `json:"to"`    // 接收者
-	From       int          // 发送者
+	From       int          `json:"from"`  // 发送者
-	Item       []*item.Item // 物品
+	Item       []*item.Item `json:"item"`  // 物品
-	SendT      int64        // 发送时间
+	SendT      int64        `json:"sendT"` // 发送时间
-	End        int64        // 过期时间
+	End        int64        `json:"end"`   // 过期时间
-	Extra      interface{}  //额外信息
+	Extra      interface{}  `json:"extra"` //额外信息
-	Id         int64
+	Id         int64        `json:"id"`
-	UniKey     string // 回调监听唯一键值
+	UniKey     string       `json:"uniKey"`     // 回调监听唯一键值
-	H          int    //处理类型
+	H          int          `json:"h"`          //处理类型
-	HandleType int    //处理类型
+	HandleType int          `json:"handleType"` //处理类型
 }
 
 type VarData struct {
@@ -41,7 +44,7 @@ const (
 	HANDLE_MOD_PLAYER_LOGIN        = 20003 // 玩家登录消息
 	HANDLE_MOD_COMSUME_MSG         = 20004 // 消费消息
 	HANDLE_MOD_CLUSTER_SYNC        = 20005 // 集群同步消息
-	HANDLE_MDO_PLAYER_LOGOUT       = 20006 // 玩家登出消息
+	HANDLE_MOD_PLAYER_LOGOUT       = 20006 // 玩家登出消息
 	HANDLE_MOD_VAR_GET             = 20007 // 获取变量
 	HANDLE_MOD_VAR_SET             = 20008 // 设置变量
 	HANDLE_MOD_CATNIP_PARTNER      = 20009 // 猫薄荷伙伴
@@ -169,16 +172,17 @@ const (
 
 func (m *Msg) Clone() *Msg {
 	return &Msg{
-		Type:   m.Type,
+		Type:       m.Type,
-		To:     m.To,
+		To:         m.To,
-		From:   m.From,
+		From:       m.From,
-		Item:   m.Item,
+		Item:       m.Item,
-		SendT:  m.SendT,
+		SendT:      m.SendT,
-		End:    m.End,
+		End:        m.End,
-		Extra:  m.Extra,
+		Extra:      m.Extra,
-		Id:     m.Id,
+		Id:         m.Id,
-		H:      m.H,
+		H:          m.H,
-		UniKey: m.UniKey,
+		UniKey:     m.UniKey,
+		HandleType: m.HandleType,
 	}
 }
 
@@ -197,6 +201,206 @@ func (m *Msg) Reply(data interface{}) *Msg {
 	}
 }
 
+func (m *Msg) String() string {
+	typeStr := "default"
+	handleTypeStr := formatHandleType(m.HandleType)
+	if m.HandleType == HANDLE_MOD_REPLY_PLAYER_MSG {
+		typeStr = formatType(m.Type)
+	}
+	return fmt.Sprintf("Msg{Type:%s, To:%d, From:%d, SendT:%d, End:%d, Id:%d, HandleType:%s, Items:%+v, Extra:%+v}",
+		typeStr, m.To, m.From, m.SendT, m.End, m.Id, handleTypeStr, m.Item, m.Extra)
+}
+
+func formatHandleType(handleType int) string {
+	switch handleType {
+	case HANDLE_MOD_PLAYER_MSG:
+		return "HANDLE_MOD_PLAYER_MSG"
+	case HANDLE_MOD_CLUSTER_MSG:
+		return "HANDLE_MOD_CLUSTER_MSG"
+	case HANDLE_MOD_PLAYER_LOGIN:
+		return "HANDLE_MOD_PLAYER_LOGIN"
+	case HANDLE_MOD_COMSUME_MSG:
+		return "HANDLE_MOD_COMSUME_MSG"
+	case HANDLE_MOD_CLUSTER_SYNC:
+		return "HANDLE_MOD_CLUSTER_SYNC"
+	case HANDLE_MOD_PLAYER_LOGOUT:
+		return "HANDLE_MOD_PLAYER_LOGOUT"
+	case HANDLE_MOD_VAR_GET:
+		return "HANDLE_MOD_VAR_GET"
+	case HANDLE_MOD_VAR_SET:
+		return "HANDLE_MOD_VAR_SET"
+	case HANDLE_MOD_CATNIP_PARTNER:
+		return "HANDLE_MOD_CATNIP_PARTNER"
+	case HANDLE_MOD_USER_VAR_GET:
+		return "HANDLE_MOD_USER_VAR_GET"
+	case HANDLE_MOD_USER_VAR_SET:
+		return "HANDLE_MOD_USER_VAR_SET"
+	case HANDLE_MOD_REPLY_PLAYER_MSG:
+		return "HANDLE_MOD_REPLY_PLAYER_MSG"
+	case HANDLE_MDO_CHAMPSHIP_INRANK:
+		return "HANDLE_MDO_CHAMPSHIP_INRANK"
+	case HANDLE_MOD_CHAMPSHIP_RANK_INFO:
+		return "HANDLE_MOD_CHAMPSHIP_RANK_INFO"
+	case HANDLE_MOD_CHAMPSHIP_RANK_LIST:
+		return "HANDLE_MOD_CHAMPSHIP_RANK_LIST"
+	case HANDLE_MOD_CHAMPSHIP_PRE_RANK:
+		return "HANDLE_MOD_CHAMPSHIP_PRE_RANK"
+	case HANDLE_MOD_CHAMPSHIP_GROUP:
+		return "HANDLE_MOD_CHAMPSHIP_GROUP"
+	case HANDLE_MOD_DAILY_VAR_GET:
+		return "HANDLE_MOD_DAILY_VAR_GET"
+	case HANDLE_MOD_DAILY_VAR_SET:
+		return "HANDLE_MOD_DAILY_VAR_SET"
+	default:
+		return fmt.Sprintf("Unknown(%d)", handleType)
+	}
+}
+
+func formatType(t int) string {
+	switch t {
+	case HANDLE_TYPE_APPLY:
+		return "apply_friend"
+	case HANDLE_TYPE_DEL:
+		return "delete_friend"
+	case HANDLE_TYPE_SYNC:
+		return "sync_request"
+	case HADNLE_TYPE_AGREE:
+		return "agree_friend"
+	case HANDLE_TYPE_REFUSE:
+		return "refuse_apply"
+	case HANDLE_TYPE_REQ_CARD:
+		return "request_card"
+	case HANDLE_TYPE_AGREE_CARD:
+		return "agree_card"
+	case HANDLE_TYPE_REG_CARD_REFUSE:
+		return "refuse_card_request"
+	case HANDLE_TYPE_REG_CARD_FINISH:
+		return "card_request_finished"
+	case HANDLE_TYPE_AGREE_CARD_FAIL:
+		return "agree_card_fail"
+	case HANDLE_TYPE_EX_CARD:
+		return "exchange_card"
+	case HANDLE_TYPE_SELECT_EX_CARD:
+		return "select_exchange_card"
+	case HANDLE_TYPE_ARGREE_EX_CARD:
+		return "agree_exchange_card"
+	case HANDLE_TYPE_REFUSE_SELECT_CARD:
+		return "refuse_select_card"
+	case HANDLE_TYPE_REFUSE_EX_CARD:
+		return "refuse_exchange_card"
+	case HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT:
+		return "exchange_card_select_timeout"
+	case HANDLE_TYPE_EX_CARD_TIMEOUT:
+		return "exchange_card_timeout"
+	case HANDLE_TYPE_SEND_CARD:
+		return "send_card"
+	case HANDLE_TYPE_INVITE_FRIEND:
+		return "invite_friend"
+	case HANDLE_TYPE_INVITE_ADD_FRIEND:
+		return "invite_add_friend"
+	case HANDLE_TYPE_RANK:
+		return "rank"
+	case HANDLE_TYPE_RANK_INFO:
+		return "rank_info"
+	case HANDLE_TYPE_RANK_NOTIFY:
+		return "rank_notify"
+	case HANDLE_TYPE_MAIL:
+		return "mail"
+	case HANDLE_TYPE_CHAMPSHIP_GROUP:
+		return "champship_group"
+	case HANDLE_TYPE_CHAMPSHIP_INRANK:
+		return "champship_inrank"
+	case HANDLE_TYPE_CHAMPSHIP_AI:
+		return "champship_ai"
+	case HANDLE_TYPE_CHAMPSHIP_NOTIFY:
+		return "champship_notify"
+	case HANDLE_TYPE_CHAMPSHIP_ZERO:
+		return "champship_zero"
+	case HANDLE_TYPE_CHAMPSHIP_NOTIFY2:
+		return "champship_notify2"
+	case HANDLE_TYPE_VAR_GET:
+		return "var_get"
+	case HANDLE_TYPE_VAR_SET:
+		return "var_set"
+	case SERVER_ZERO_UPDATE:
+		return "zero_update"
+	case HANDLE_TYPE_PLAYROOM_LOSE:
+		return "playroom_lose"
+	case SERVER_NOON_UPDATE:
+		return "noon_update"
+	case FRIEND_TREASURE_HANDLE:
+		return "friend_treasure"
+	case HANDLE_TYPE_MAIL_ADD:
+		return "mail_add"
+	case HANDLE_TYPE_MAIL_RELOAD:
+		return "mail_reload"
+	case HANDLE_TYPE_HANDBOOK_COLLECTION:
+		return "handbook_collection"
+	case HANDLE_TYPE_HANDBOOK_UPVOTE:
+		return "handbook_upvote"
+	case HANDLE_TYPE_SEND_CHARGE:
+		return "send_charge"
+	case HANDLE_TYPE_CHARGE_RECEIVE:
+		return "charge_receive"
+	case HANDLE_TYPE_WISHLIST_SEND:
+		return "wishlist_send"
+	case HANDLE_TYPE_WISHLIST_AGREE:
+		return "wishlist_agree"
+	case HANDLE_TYPE_PLAYROOM_UPVOTE:
+		return "playroom_upvote"
+	case HANDLE_TYPE_CHAMPSHIP_RESULT:
+		return "champship_result"
+	case HANDLE_TYPE_TREASURE_RESULT:
+		return "treasure_result"
+	case HANDLE_TYPE_FACEBOOK_UNBIND:
+		return "facebook_unbind"
+	case HANDLE_TYPE_VAR_USER_SET:
+		return "var_user_set"
+	case HANDLE_TYPE_VAR_USER_GET:
+		return "var_user_get"
+	case HANDLE_TYPE_PLAYROOM_KISS:
+		return "playroom_kiss"
+	case HANDLE_TYPE_PLAYROOM_GAME:
+		return "playroom_game"
+	case HANDLE_TYPE_CATNIP_INVITE:
+		return "catnip_invite"
+	case HANDLE_TYPE_CATNIP_AGREE:
+		return "catnip_agree"
+	case HANDLE_TYPE_CATNIP_AGREE_DEL:
+		return "catnip_agree_del"
+	case HANDLE_TYPE_CATNIP_REFUSE:
+		return "catnip_refuse"
+	case HANDLE_TYPE_CATNIP_GROWTH:
+		return "catnip_growth"
+	case HANDLE_TYPE_CATNIP_LOCK:
+		return "catnip_lock"
+	case HANDLE_TYPE_VAR_EXPIRE_SET:
+		return "var_expire_set"
+	case HANDLE_TYPE_VAR_EXPIRE_GET:
+		return "var_expire_get"
+	case HANDLE_TYPE_FRIEND_GREETING_REPLY:
+		return "friend_greeting_reply"
+	case HANDLE_TYPE_FRIEND_SPONSOER:
+		return "friend_sponsor"
+	case HANDLE_TYPE_CHAMPSHIP_LOGIN:
+		return "champship_login"
+	case HANDLE_TYPE_CHAMPSHIP_RANK_INFO:
+		return "champship_rank_info"
+	case HANDLE_TYPE_SET_CATNIP_PARTNER:
+		return "set_catnip_partner"
+	case HANDLE_TYPE_CATNIP_SEND_EMOJI:
+		return "catnip_send_emoji"
+	case HANDLE_TYPE_CHAMPSHIP_MY_RANK:
+		return "champship_my_rank"
+	case HANDLE_TYPE_LOGIN:
+		return "player_login"
+	case SERVER_PLAYER_SYNC_LOGOUT_MSG:
+		return "player_sync_logout"
+	default:
+		return fmt.Sprintf("Unknown(%d)", t)
+	}
+}
+
 func Handle(fun func(Msg) error, m Msg) error {
 	return fun(m)
 }

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

@@ -563,20 +563,20 @@ func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int, Energ
 		}
 	}
 	b3 := false
-	//额外订单补充2；当玩家的棋盘中出现三个相同的满级产物时，立刻生成一个对应的收购订单；
+	//额外订单补充2；当玩家的棋盘中出现2个相同的满级产物时，立刻生成一个对应的收购订单；
 	for k := range MaxLvChess {
 		ChessNum := GoUtil.GetElemNum(ChessList, k)
-		if ChessNum >= 3 && Level >= 12 {
+		if ChessNum >= 2 && Level >= 12 {
 			b2 := true
 			for _, v := range o.OrderList {
-				if GoUtil.SliceEqual(v.MergeId, []int{k, k, k}) {
+				if GoUtil.SliceEqual(v.MergeId, []int{k, k}) {
 					b2 = false
 					break
 				}
 			}
 			if b2 {
 				b3 = true
-				o.addOrder([]int{k, k, k}, DIFF_LOW, Extra_type)
+				o.addOrder([]int{k, k}, DIFF_LOW, Extra_type)
 			}
 		}
 	}

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

@@ -390,6 +390,7 @@ func getChesslvRange(Emit int, EnergyMul int, IsCharge bool) (int, int) {
 
 // 根据类型获取发射器id
 func GetEmitByColor(Emit []int, color string) int {
+	sort.Ints(Emit)
 	for _, v := range Emit {
 		Produce := mergeDataCfg.GetEmitProduceChessType(v)
 		for _, c := range Produce {
@@ -668,6 +669,9 @@ func GetChessByDiff(EmitId, EnergyMul, Diff int, Color string) []int {
 		MaxLev := mergeDataCfg.GetMaxLvByColor(Color)
 		NewLev1 = min(NewLev1, MaxLev)
 		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev1, Color)
+		if ChessId == 0 {
+			continue
+		}
 		ChessIds = append(ChessIds, ChessId)
 	}
 	return GoUtil.UniqueInts(ChessIds)

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

@@ -40,11 +40,11 @@ func (s *SevenLoginMod) ZeroUpdate(Add, LastLoginTime int) {
 		s.WeekResetTime = WeekZeroTimestamp
 		s.DayR = 0
 	}
-
+	monthZeroTimestamp := GoUtil.MonthZeroTimestamp()
-	if Now > s.MonthResetTime+GoUtil.MONTHDAYS {
+	if monthZeroTimestamp > s.MonthResetTime {
 		s.MonthReward = randMonthReward()
 		s.Active = 0
-		s.MonthResetTime = s.MonthResetTime + (Now-s.MonthResetTime)/GoUtil.MONTHDAYS*GoUtil.MONTHDAYS
+		s.MonthResetTime = monthZeroTimestamp
 	}
 	s.DayR++
 }
@@ -108,11 +108,12 @@ func (s *SevenLoginMod) BackData() *msg.ResSevenLogin {
 		Status := GoUtil.IfTrue(!v.Status && s.Active >= Active, 1, 0).(int)
 		Status = GoUtil.IfTrue(v.Status, 2, Status).(int)
 		MonthReward = append(MonthReward, &msg.SevenLoginReward{
-			Item1:  item.ItemToMsg(v.Item1),
+			Item1:      item.ItemToMsg(v.Item1),
-			Item2:  item.ItemToMsg(v.Item2),
+			Item2:      item.ItemToMsg(v.Item2),
-			Item3:  item.ItemToMsg(v.Item3),
+			Item3:      item.ItemToMsg(v.Item3),
-			Status: int32(Status),
+			Status:     int32(Status),
-			Id:     int32(k),
+			Id:         int32(k),
+			NeedActive: int32(Active),
 		})
 	}
 

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

@@ -109,7 +109,8 @@ func randReward(RewardData *gamedata.SevenLoginRewardData, LastType int, jackpot
 }
 
 func randMonthReward() map[int]Reward {
-	RewardList := sevenLoginCfg.GetSevenLoginMonthReward()
+	month := GoUtil.NowMonth()
+	RewardList := sevenLoginCfg.GetSevenLoginMonthReward(month)
 	sort.Slice(RewardList, func(i, j int) bool {
 		return RewardList[i].Id < RewardList[j].Id
 	})

src/server/game/mod_factory.go

@@ -3,12 +3,19 @@ package game
 import (
 	"server/game/mod/base"
 	"server/game/mod/card"
+	"server/game/mod/champship"
 	"server/game/mod/charge"
 	"server/game/mod/chess"
+	dailyTask "server/game/mod/daily_task"
 	"server/game/mod/decorate"
 	"server/game/mod/endless"
+	"server/game/mod/face"
+	"server/game/mod/friend"
+	"server/game/mod/fur"
 	limitedTimeEvent "server/game/mod/limited_time_event"
 	"server/game/mod/mail"
+	"server/game/mod/mining"
+	"server/game/mod/order"
 	"server/game/mod/playroom"
 	sevenLogin "server/game/mod/seven_login"
 )
@@ -52,3 +59,34 @@ func (p *Player) GetMailMod() *mail.MailMod {
 func (p *Player) GetSevenLoginMod() *sevenLogin.SevenLoginMod {
 	return p.PlayMod.getSevenLoginMod()
 }
+
+func (p *Player) GetOrderMod() *order.OrderMod {
+	return p.PlayMod.getOrderMod()
+}
+
+func (p *Player) GetFurMod() *fur.FurMod {
+	return p.PlayMod.getFurMod()
+}
+
+func (p *Player) GetFriendMod() *friend.FriendMod {
+	return p.PlayMod.getFriendMod()
+}
+
+func (p *Player) GetChampshipMod() *champship.ChampshipMod {
+	return p.PlayMod.getChampshipMod()
+}
+func (p *Player) GetFaceMod() *face.FaceMod {
+	return p.PlayMod.getFaceMod()
+}
+
+func (p *Player) GetLimitedTimeEventMod() *limitedTimeEvent.LimitedTimeEventMod {
+	return p.PlayMod.getLimitedTimeEventMod()
+}
+
+func (p *Player) GetMiningMod() *mining.MiningMod {
+	return p.PlayMod.getMiningMod()
+}
+
+func (p *Player) GetDailyTaskMod() *dailyTask.DailyTaskMod {
+	return p.PlayMod.getDailyTaskMod()
+}

src/server/game/player_back.go

@@ -206,6 +206,7 @@ func (p *Player) PlayroomVisit(Uid int) {
 	r.Chip = int32(p.GetPlayroomChip(Uid))
 	r.Kiss = int32(p.GetPlayroomKiss(Uid))
 	r.DressSet = GoUtil.MapIntToInt32(PlayerData.DressSet)
+	r.Fur = int32(PlayerData.PetFur)
 	p.PushClientRes(r)
 }
 
@@ -279,6 +280,10 @@ func (p *Player) ChargeBackData() {
 		}
 	}
 	CatDaySaleEndTime := LimitedEventMod.GetCatDaySaleEndTime()
+	var specialChargeWeek int32
+	if c.LastSpecialCharge != 0 {
+		specialChargeWeek = int32(GoUtil.FullWeeksSince(c.LastSpecialCharge))
+	}
 	p.PushClientRes(&proto.ResCharge{
 		Charge:            float32(c.Charge),
 		Total:             int32(c.Total),
@@ -289,7 +294,7 @@ func (p *Player) ChargeBackData() {
 		Gift:              GoUtil.MapIntToInt32(c.Gift),
 		Ad:                c.Ad,
 		SpecialCharge:     float32(c.SpecialCharge),
-		SpecialChargeWeek: int32(GoUtil.FullWeeksSince(c.LastSpecialCharge)),
+		SpecialChargeWeek: specialChargeWeek,
 		TodayCharge:       float32(c.TodayCharge),
 		MonthCharge:       float32(c.MonthCharge),
 		Wish:              resWish,
@@ -303,7 +308,8 @@ func (p *Player) ChargeBackData() {
 func (p *Player) BackChampship() {
 	ChampshipMod := p.PlayMod.getChampshipMod()
 	rank, preRank := p.GetChampshipRank()
-	p.PushClientRes(ChampshipMod.BackData(rank, preRank))
+	todayActivityId, yesterdayActivityId := p.GetChampshipActivityId()
+	p.PushClientRes(ChampshipMod.BackData(rank, preRank, todayActivityId, yesterdayActivityId))
 }
 
 // 获取冠军赛排名 redis缓存
@@ -328,8 +334,12 @@ func (p *Player) FriendListBackData() {
 			fl = append(fl, ps)
 		}
 	}
+	now := GoUtil.Now()
 	ReqFriendList := make([]int64, 0, len(FriendMod.SendApply))
-	for k := range FriendMod.SendApply {
+	for k, v := range FriendMod.SendApply {
+		if now-v > oneday {
+			continue
+		}
 		ReqFriendList = append(ReqFriendList, int64(k))
 	}
 	p.PushClientRes(&proto.ResFriendList{
@@ -342,13 +352,13 @@ func (p *Player) FriendListBackData() {
 
 func (p *Player) FriendApplyBackData() {
 	FriendMod := p.PlayMod.getFriendMod()
-	al := make([]*proto.ResFriendApplyInfo, 0, len(FriendMod.ApplyList))
+	al := make([]*proto.ResFriendApplyInfo, 0, len(FriendMod.NewApplyList))
-	for k, v := range FriendMod.ApplyList {
+	for k, v := range FriendMod.NewApplyList {
 		ps := G_GameLogicPtr.GetResSimplePlayerByUid(k)
 		if ps != nil {
 			al = append(al, &proto.ResFriendApplyInfo{
 				Player: ps,
-				Time:   int32(v),
+				Time:   int32(v.Time),
 			})
 		}
 	}

src/server/game/player_base_mod.go

@@ -93,6 +93,39 @@ func (p *PlayerBaseData) LoadDataFromDB(UserName interface{}) bool {
 		return false
 	}
 
+	p.Data.Diamond = sqlStruck.Diamond
+	p.Data.DwUin = sqlStruck.DwUin
+	p.Data.Energy = sqlStruck.Energy
+	p.Data.Star = sqlStruck.Star
+	p.Data.RecoverTime = sqlStruck.RecoverTime
+	p.Data.Level = sqlStruck.Level
+	p.Data.Exp = sqlStruck.Exp
+	p.Data.StartOrderId = sqlStruck.StartOrderId
+	p.Data.MusicCode = sqlStruck.MusicCode
+	p.Data.Guild = sqlStruck.Guild
+	p.Data.PackUnlockCount = sqlStruck.PackUnlockCount
+	p.Data.LastPlayTime = sqlStruck.LastPlayTime
+	p.Data.Ban = sqlStruck.Ban
+	p.Data.UserName = sqlStruck.UserName
+	p.Data.LogoutTime = sqlStruck.LogoutTime
+	p.Data.Node = sqlStruck.Node
+	p.Data.Rolecreatetime = sqlStruck.Rolecreatetime
+	p.Data.LastChampGroupID = sqlStruck.LastChampGroupID
+	p.Data.ChampshipsGroupID = sqlStruck.ChampshipsGroupID
+	p.Data.NoAd = sqlStruck.NoAd
+	p.Data.FaceBookId = sqlStruck.FaceBookId
+	p.p.PlayMod.getBaseMod().RegisterTime = int64(sqlStruck.Rolecreatetime)
+	return true
+}
+
+func (p *PlayerBaseData) LoadDataFromDBByUid(Uid int) bool {
+	sqlStr := "SELECT * FROM t_player_baseinfo WHERE DwUin = ?"
+	sqlStruck := db.ResPlayerBaseInfo{}
+	if err := db.SqlDb.Get(&sqlStruck, sqlStr, Uid); err != nil {
+		log.Debug("PlayerBaseData get data failed, err:%v\n", err)
+		return false
+	}
+
 	p.Data.Diamond = sqlStruck.Diamond
 	p.Data.DwUin = sqlStruck.DwUin
 	p.Data.Energy = sqlStruck.Energy
@@ -504,7 +537,8 @@ func (p *PlayerBaseData) AddExp(player *Player, exp int, pexp int) (int, error)
 		// 日常任务解锁
 		DailyTaskMod := player.PlayMod.getDailyTaskMod()
 		DecorateMod := player.PlayMod.getDecorateMod()
-		if DailyTaskMod.LevUpTrigger(BaseMod.Level, DecorateMod.GetAreaId()) {
+		dailyAcitivityId := player.GetDailyTaskActivityId()
+		if DailyTaskMod.LevUpTrigger(BaseMod.Level, DecorateMod.GetAreaId(), dailyAcitivityId) {
 			player.PushClientRes(DailyTaskMod.BackData())
 		}
 		upLv = BaseMod.Level

src/server/game/player_data.go

@@ -10,6 +10,7 @@ import (
 	activityCfg "server/conf/activity"
 	cardCfg "server/conf/card"
 	chargeCfg "server/conf/charge"
+	fur_cfg "server/conf/fur"
 	guesscolorCfg "server/conf/guess_color"
 	itemCfg "server/conf/item"
 	limitedTimeEventCfg "server/conf/limited_time_event"
@@ -217,7 +218,7 @@ func (p *Player) InitPlayer(UserName string) error {
 	// 玩家基础数据
 	ok := Base.LoadDataFromDB(UserName)
 	if !ok {
-		log.Debug("load PlayerBaseData failed:", UserName)
+		log.Debug("load PlayerBaseData failed:%s", UserName)
 		return errors.New("load PlayerBaseData failed")
 	}
 	p.PlayerBaseMod = Base
@@ -229,7 +230,66 @@ func (p *Player) InitPlayer(UserName string) error {
 	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
 	ok = modData.LoadDataFromDB(Base.Data.DwUin)
 	if !ok {
-		log.Debug("load PlayerModData failed:", UserName)
+		log.Debug("load PlayerModData failed:%s", UserName)
+		return errors.New("load PlayerModData failed")
+	}
+	IsUpdate, err := modData.InitMod(p)
+	if err != nil {
+		log.Debug("InitMod failed:", err)
+		return err
+	}
+	p.PlayMod.mod_list = modData.ModList
+	p.PlayMod.is_update = IsUpdate
+	// 启动定时器
+	p.DispatcherHandle()
+	p.McronSave = cron.New()
+	_, err = p.McronSave.AddFunc("@every 1m", p.AutoSaveData)
+	if err != nil {
+		log.Debug("AddFunc failed:", err)
+	}
+	p.McronSave.Start()
+	p.initAcitivity()
+	p.ZeroUpdate(nil)
+	p.NoonUpdate(nil)
+	p.Login()
+	p.OrderShip()
+	p.UpdateUserInfo()
+	// fix bug
+	ChargeMod := p.PlayMod.getChargeMod()
+	ChessMod := p.PlayMod.getChessMod()
+	ChargeMod.FixBug(ChessMod.GetEmitList())
+	p.FixOrderBug()
+	p.FixDecorate()
+	return nil
+}
+
+func (p *Player) InitPlayerByUid(Uid int) error {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	p.msgChan = make(chan *MsgMod.Msg, 100)
+	p.Msg = make([]PlayerMsg, 0)
+	p.args = make(map[string]interface{})
+	p.timerList = make(map[string]*timer.Timer)
+	p.MDispatr = timer.NewDispatcher(100)
+	p.stopSignal = make(chan bool)
+	Base := &PlayerBaseData{p: p}
+
+	// 玩家基础数据
+	ok := Base.LoadDataFromDBByUid(Uid)
+	if !ok {
+		log.Debug("load PlayerBaseData failed:%d", Uid)
+		return errors.New("load PlayerBaseData failed")
+	}
+	p.PlayerBaseMod = Base
+	p.M_DwUin = Base.Data.DwUin
+
+	// 棋盘数据
+
+	// 玩家模块数据
+	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
+	ok = modData.LoadDataFromDB(Base.Data.DwUin)
+	if !ok {
+		log.Debug("load PlayerModData failed:%d", Uid)
 		return errors.New("load PlayerModData failed")
 	}
 	IsUpdate, err := modData.InitMod(p)
@@ -290,10 +350,6 @@ func (p *Player) ZeroUpdate(a []interface{}) {
 		p.HandleItem(HandbookItem, msg.ITEM_POP_LABEL_AllCollectRewardHB.String())
 		p.PushClientRes(p.PlayMod.getCardMod().BackData())
 
-		// 每日任务
-		p.PlayMod.getDailyTaskMod().ZeroUpdate(p.GetPlayerBaseMod().GetLevel(), p.PlayMod.getDecorateMod().GetAreaId())
-		p.PushClientRes(p.PlayMod.getDailyTaskMod().BackData())
-
 		// 能量商店
 		p.PlayMod.getBaseMod().ZeroUpdate()
 		p.PushClientRes(p.PlayMod.getBaseMod().BackData())
@@ -330,6 +386,11 @@ func (p *Player) ZeroUpdate(a []interface{}) {
 		p.PlayMod.getChampshipMod().ZeroUpdate()
 		p.initAcitivity()
 		p.ActivityZeroUpdate()
+
+		// 每日任务
+		p.PlayMod.getDailyTaskMod().ZeroUpdate(p.GetPlayerBaseMod().GetLevel(), p.PlayMod.getDecorateMod().GetAreaId(), p.GetDailyTaskActivityId())
+		p.PushClientRes(p.PlayMod.getDailyTaskMod().BackData())
+
 		p.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_LOGIN})
 		p.PlayMod.save()
 	}
@@ -473,7 +534,7 @@ func (p *Player) ClearData() {
 	G_GameLogicPtr.DelPlayer(p)
 	SendMsgToCenterAsync(&MsgMod.Msg{
 		From:       Uid,
-		HandleType: MsgMod.HANDLE_MDO_PLAYER_LOGOUT,
+		HandleType: MsgMod.HANDLE_MOD_PLAYER_LOGOUT,
 	})
 }
 
@@ -523,6 +584,9 @@ func (p *Player) GetAgentByPlayer() gate.Agent {
 
 // 处理物品
 func (p *Player) HandleLoseItem(itemList []*item.Item, Label string) error {
+	if itemList == nil {
+		return nil
+	}
 	for _, v := range itemList {
 		if v.Num > 0 {
 			v.Num = -v.Num
@@ -531,7 +595,7 @@ func (p *Player) HandleLoseItem(itemList []*item.Item, Label string) error {
 	return p.HandleItem(itemList, Label)
 }
 func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
-	if len(itemList) == 0 {
+	if itemList == nil {
 		return nil
 	}
 	is_update := false
@@ -833,6 +897,16 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 			PassMod := p.PlayMod.getPassMod()
 			PassMod.AddExp(v.Num)
 			p.ActPassBackData()
+		case item.ITEM_TYPE_PET_FUR:
+			FurMod := p.PlayMod.getFurMod()
+			Effect := itemCfg.GetItemEffect(v.Id)
+			FurMod.AddFurInfo(Effect, GoUtil.Now(), 0)
+			BackDataType[item.ITEM_TYPE_PET_FUR] = struct{}{}
+			p.TeLog("pro_pet_fur_get", map[string]interface{}{
+				"pet_fur_name":     fur_cfg.GetFurShopName(v.Id),
+				"fur_coin_cost":    fur_cfg.GetFurShopCostNum(v.Id),
+				"pet_fur_get_type": Label,
+			})
 		default:
 			err := ItemMod.AddItem(v.Id, v.Num)
 			p.TeLog("asset_change", map[string]interface{}{
@@ -872,6 +946,9 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 			item.ITEM_TYPE_PLAYROOM_DECORATION_SET,
 			item.ITEM_TYPE_PLAYROOM_DRESS_SET:
 			p.PlayroomBackData()
+		case item.ITEM_TYPE_PET_FUR:
+			FurMod := p.PlayMod.getFurMod()
+			p.PushClientRes(FurMod.BackData())
 		}
 	}
 	p.PetItemUseLog(itemList)
@@ -1004,6 +1081,9 @@ func (p *Player) UpdateUserInfo() {
 	simple.Physiology = p.PlayMod.getPlayroomMod().GetPhysiologyList()
 	simple.Lang = int(p.PlayMod.getBaseMod().Lang)
 	simple.Account = p.PlayMod.getBaseMod().Account
+	simple.PetFur = p.PlayMod.getFurMod().GetFurSet()
+	simple.MaxCharge = p.PlayMod.getChargeMod().GetMaxCharge()
+	simple.AdWatch = p.PlayMod.getChargeMod().GetAdWatch()
 	//TODO 存储到redis 在新版本中将优化成gob进行压缩
 	value, _ := json.Marshal(simple)
 	IdStr := GoUtil.String(p.M_DwUin)
@@ -1260,3 +1340,11 @@ func CheckPlayerLose(Uid int) bool {
 	}
 	return false
 }
+
+func (p *Player) Lock() {
+	p.lock.Lock()
+}
+
+func (p *Player) UnLock() {
+	p.lock.Unlock()
+}

src/server/game/player_mod.go

@@ -23,6 +23,7 @@ import (
 	"server/game/mod/face"
 	"server/game/mod/friend"
 	friendTreasure "server/game/mod/friend_treasure.go"
+	"server/game/mod/fur"
 	guesscolor "server/game/mod/guess_color"
 	"server/game/mod/guide"
 	guideTask "server/game/mod/guide_task"
@@ -120,6 +121,7 @@ type PlayerModList struct {
 	Catnip           catnip.CatnipMod                     // 猫草大作战
 	GuideTask        guideTask.GuideTaskMod               // 引导任务
 	Pass             pass.PassMod                         // 通行证
+	Fur              fur.FurMod                           // 毛皮
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -221,6 +223,7 @@ func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	p.ModList.Compensation.InitData()
 	p.ModList.GuideTask.InitData()
 	p.ModList.Pass.InitData()
+	p.ModList.Fur.InitData()
 	return is_update, nil
 }
 
@@ -439,3 +442,7 @@ func (p *PlayerMod) getGuideTaskMod() *guideTask.GuideTaskMod {
 func (p *PlayerMod) getPassMod() *pass.PassMod {
 	return &p.mod_list.Pass
 }
+
+func (p *PlayerMod) getFurMod() *fur.FurMod {
+	return &p.mod_list.Fur
+}

src/server/game/register_network_func.go

@@ -4,14 +4,11 @@ import (
 	"errors"
 	"fmt"
 	"math"
-	"server/conf"
-	baseCfg "server/conf/base"
 	cardCfg "server/conf/card"
 	champshipCfg "server/conf/champship"
 	collectCfg "server/conf/collect"
 	decorateCfg "server/conf/decorate"
 	emojiCfg "server/conf/emoji"
-	friendCfg "server/conf/friend"
 	GuideTaskCfg "server/conf/guide_task"
 	handbookCfg "server/conf/handbook"
 	limitedTimeEventCfg "server/conf/limited_time_event"
@@ -19,7 +16,6 @@ import (
 	miningCfg "server/conf/mining"
 	orderCfg "server/conf/order"
 	playroomCfg "server/conf/playroom"
-	"server/db"
 	"server/game/internal"
 	"server/game/mod/activity"
 	"server/game/mod/card"
@@ -732,13 +728,13 @@ func ReqGetChessFromBuff(player *Player, buf []byte) error {
 		"chess_id": ChessId,
 	})
 	Update = OrderMod.CreateExtraOrder([]int{ChessId}, AddNewEmit, ChessMod.GetUnlockChessList(), BaseMod.GetEnergyMul(), BaseMod.GetLevel())
-	if Update {
-		player.PushClientRes(OrderMod.BackData())
-	}
 	triggerComposeChess(player, ChessId, player.PlayMod.getBaseMod().EnergyMul, player.PlayMod.getChessMod().GetEmitList())
 	player.EmitRetireTrigger1()
-	player.InitOrderItem()
 	player.PlayMod.save()
+	if Update {
+		player.InitOrderItem()
+		player.PushClientRes(OrderMod.BackData())
+	}
 	player.PushClientRes(ChessMod.BackData())
 	player.PushClientRes(&msg.ResGetChessFromBuff{
 		Code: msg.RES_CODE_SUCCESS,
@@ -1338,7 +1334,7 @@ func ReqGetDailyTaskReward(player *Player, buf []byte) error {
 		return err
 	}
 	DailyTaskMod := player.PlayMod.getDailyTaskMod()
-	itemList, err := DailyTaskMod.GetDailyReward(int(req.Id))
+	itemList, err := DailyTaskMod.GetDailyReward(int(req.Id), player.GetDailyTaskActivityId())
 	if err != nil {
 		player.SendErrClienRes(&msg.ResGetDailyTaskReward{
 			Code: msg.RES_CODE_FAIL,
@@ -1796,251 +1792,6 @@ func ReqGetGoldCard(player *Player, buf []byte) error {
 	return nil
 }
 
-// 搜索用户
-func ReqSearchPlayer(player *Player, buf []byte) error {
-	req := &msg.ReqSearchPlayer{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	Uid, err := strconv.Atoi(req.Uid)
-	list := make([]*msg.ResPlayerSimple, 0)
-	if err == nil {
-		SearchPlayer := G_GameLogicPtr.GetResSimplePlayerByUid(Uid)
-		if SearchPlayer != nil && SearchPlayer.Level != 0 {
-			list = append(list, SearchPlayer)
-		}
-	}
-	data, err := db.SearchPlayer(req.Uid)
-	if err != nil {
-		player.SendErrClienRes(&msg.ResSearchPlayer{
-			Code: 0,
-		})
-	}
-	for _, v := range data {
-		if player.M_DwUin == v.DwUin {
-			continue
-		}
-		SearchPlayer := G_GameLogicPtr.GetResSimplePlayerByUid(int(v.DwUin))
-		list = append(list, SearchPlayer)
-
-	}
-	// list 列表去重
-	l := make(map[int]*msg.ResPlayerSimple)
-	for _, v := range list {
-		if _, ok := l[int(v.Uid)]; !ok {
-			l[int(v.Uid)] = v
-		}
-	}
-	l2 := make([]*msg.ResPlayerSimple, 0)
-	for _, v := range l {
-		l2 = append(l2, v)
-	}
-	player.PushClientRes(&msg.ResSearchPlayer{
-		List: l2,
-	})
-	return nil
-}
-
-// 申请好友
-func ReqApplyFriend(player *Player, buf []byte) error {
-	req := &msg.ReqApplyFriend{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	Uid := int(req.Uid)
-	FriendMod := player.PlayMod.getFriendMod()
-	if Uid == int(player.M_DwUin) {
-		player.SendErrClienRes(&msg.ResApplyFriend{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "cannot apply yourself",
-		})
-		return fmt.Errorf("cannot apply yourself")
-	}
-	if FriendMod.CheckFriend(Uid) {
-		player.SendErrClienRes(&msg.ResApplyFriend{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "already friend",
-		})
-		return fmt.Errorf("already friend")
-	}
-	// 好友人数到达上限（2000人）时，玩家将无法再发送好友申请
-	if FriendMod.GetFriendLen() >= friendCfg.GetFriendLimitNum() {
-		player.SendErrClienRes(&msg.ResApplyFriend{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "friend list full",
-		})
-		return fmt.Errorf("friend list full")
-	}
-	// 对于任何玩家而言，向自己在24小时内已从任意途径发送过好友申请的玩家再次发送好友申请时，该次申请不会被发出
-	sendApplyTime := FriendMod.GetSendApplyTime(Uid)
-	if sendApplyTime != 0 && GoUtil.Now()-sendApplyTime < 86400 {
-		player.PushClientRes(&msg.ResApplyFriend{
-			Code: msg.RES_CODE_FAIL,
-			Uid:  req.Uid,
-			Msg:  "already applied",
-		})
-		return fmt.Errorf("already applied")
-	}
-	now := GoUtil.Now()
-	if req.Type == 1 {
-		Items, err := FriendMod.GetSponsorReward()
-		if err != nil {
-			player.SendErrClienRes(&msg.ResApplyFriend{
-				Code: msg.RES_CODE_FAIL,
-				Msg:  err.Error(),
-			})
-			return err
-		}
-		BaseMod := player.PlayMod.getBaseMod()
-		BaseMod.GetEnergyByAD()
-		err = player.HandleItem(Items, msg.ITEM_POP_LABEL_ApplyFriendSponsor.String())
-		if err != nil {
-			player.SendErrClienRes(&msg.ResApplyFriend{
-				Code: msg.RES_CODE_FAIL,
-				Msg:  err.Error(),
-			})
-			return err
-		}
-		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: now,
-			End:   now + sevendays,
-		})
-		player.PushClientRes(BaseMod.BackData())
-		player.TeLog("friend_invite_reward", map[string]interface{}{
-			"item_list": Items,
-		})
-	}
-	m := &MsqMod.Msg{
-		Type:  MsqMod.HANDLE_TYPE_APPLY,
-		From:  int(player.M_DwUin),
-		To:    Uid,
-		SendT: now,
-		End:   now + sevendays,
-	}
-	FriendMgrSend(m)
-	player.PushClientRes(&msg.ResApplyFriend{
-		Code: msg.RES_CODE_SUCCESS,
-		Uid:  req.Uid,
-	})
-	return nil
-}
-
-// 同意申请
-func ReqAgreeFriend(player *Player, buf []byte) error {
-	req := &msg.ReqAgreeFriend{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	Uid := int(req.Uid)
-	FriendMod := player.PlayMod.getFriendMod()
-	if !FriendMod.CheckApply(Uid) {
-		player.SendErrClienRes(&msg.ResAgreeFriend{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "apply uid not exist",
-		})
-		return fmt.Errorf("apply uid not exist")
-	}
-	// 好友人数到达上限（2000人）时，玩家将无法再同意好友申请
-	if FriendMod.GetFriendLen() >= friendCfg.GetFriendLimitNum() {
-		player.SendErrClienRes(&msg.ResAgreeFriend{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "friend list full",
-		})
-		return fmt.Errorf("friend list full")
-	}
-	// 新好友才可以打招呼
-	if !FriendMod.CheckAddBefore(Uid) {
-		FriendMod.AddReplyInfo(Uid, friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+oneday, nil)
-	}
-	FriendMod.AddFriend(Uid)
-	player.PushClientRes(&msg.ResAgreeFriend{
-		Code:   msg.RES_CODE_SUCCESS,
-		Uid:    req.Uid,
-		Player: G_GameLogicPtr.GetResSimplePlayerByUid(int(req.Uid)),
-	})
-	player.TeLog("friend_add", map[string]interface{}{
-		"player_id": Uid,
-		"add_type":  "接受申请",
-	})
-	player.AddLog(Uid, friend.LOG_TYPE_FRIEND_BECOME, "", GoUtil.Now())
-	m := &MsqMod.Msg{
-		Type:  MsqMod.HADNLE_TYPE_AGREE,
-		From:  int(player.M_DwUin),
-		To:    Uid,
-		SendT: GoUtil.Now(),
-	}
-	FriendMgrSend(m)
-	player.FriendApplyBackData()
-	player.FriendLogBackData()
-	player.PlayMod.save()
-	return nil
-}
-
-// 删除好友
-func ReqDelFriend(player *Player, buf []byte) error {
-	req := &msg.ReqDelFriend{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	Uid := int(req.Uid)
-	m := &MsqMod.Msg{
-		Type:  MsqMod.HANDLE_TYPE_DEL,
-		From:  int(player.M_DwUin),
-		To:    Uid,
-		SendT: GoUtil.Now(),
-	}
-	FriendMgrSend(m)
-	FriendMod := player.PlayMod.getFriendMod()
-	FriendMod.DelFriend(Uid)
-	player.PlayMod.save()
-	player.PushClientRes(&msg.ResDelFriend{
-		Code: msg.RES_CODE_SUCCESS,
-		Uid:  req.Uid,
-	})
-	player.AddLog(Uid, friend.LOG_TYPE_FRIEND_DELETE, "", GoUtil.Now())
-	player.FriendListBackData()
-	player.TeLog("friend_delete", map[string]interface{}{
-		"player_id": Uid,
-	})
-	return nil
-}
-
-// 拒绝申请
-func ReqRefuseFriend(player *Player, buf []byte) error {
-	req := &msg.ReqRefuseFriend{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	Uid := int(req.Uid)
-	FriendMod := player.PlayMod.getFriendMod()
-	FriendMod.RefuseApply(Uid)
-	player.PlayMod.save()
-	player.PushClientRes(&msg.ResRefuseFriend{
-		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: now,
-		End:   now + 86400*7,
-	}
-	FriendMgrSend(m)
-	player.FriendApplyBackData()
-	return nil
-}
-
 // 向好友请求卡牌
 func ReqCardGive(player *Player, buf []byte) error {
 	req := &msg.ReqCardGive{}
@@ -2987,7 +2738,9 @@ func ReqShippingOrder(player *Player, buf []byte) error {
 // 锦标赛
 func ReqChampshipReward(player *Player, buf []byte) error {
 	ChampshipMod := player.PlayMod.getChampshipMod()
-	itemList := ChampshipMod.GetReward()
+	todayActivityId, _ := player.GetChampshipActivityId()
+	RewardId := ChampshipMod.Reward
+	itemList := ChampshipMod.GetReward(todayActivityId)
 	err := player.HandleItem(itemList, msg.ITEM_POP_LABEL_ChampshipReward.String())
 	if err != nil {
 		player.SendErrClienRes(&msg.ResChampshipReward{
@@ -3008,13 +2761,17 @@ func ReqChampshipReward(player *Player, buf []byte) error {
 		FriendMod.AddActLog(friend.ACT_LOG_TYPE_GET_CHAMPIONSHIP_PRIZE, "")
 		player.UpdateUserInfo()
 	}
-	player.TeLog("championship_reward", map[string]interface{}{
+	for i := RewardId + 1; i <= ChampshipMod.Reward; i++ {
-		"season_id":         GoUtil.ZeroTimestamp(),
+		items, _ := champshipCfg.GetRewardItems(i)
-		"champship_step_id": ChampshipMod.Reward,
+		player.TeLog("championship_reward", map[string]interface{}{
-		"reward_type":       "step",
+			"season_id":         GoUtil.ZeroTimestamp(),
-		"item_list":         itemList,
+			"champship_step_id": i,
-		"champship_score":   ChampshipMod.Score,
+			"reward_type":       "step",
-	})
+			"item_list":         items,
+			"champship_score":   ChampshipMod.Score,
+		})
+	}
+
 	return nil
 }
 
@@ -3036,140 +2793,11 @@ func ReqKv(player *Player, buf []byte) error {
 	return nil
 }
 
-func ReqFriendRecommend(player *Player, buf []byte) error {
-	FriendMod := player.PlayMod.getFriendMod()
-	RecommendList := make([]*msg.ResPlayerSimple, 0)
-	FriendNum := FriendMod.GetFriendNum()
-	var n int
-	if FriendNum < 10 {
-		n = 3
-	} else {
-		Active := 0
-		for k := range FriendMod.GetFriendList() {
-			PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(k)
-			if PlayerSimpleData == nil {
-				continue
-			}
-			if PlayerSimpleData.Login > GoUtil.Now()-86400 {
-				Active++
-			}
-		}
-		n = max(0, 3-(Active/10))
-	}
-	PlayerList := GetRecommendPlayer(player, n)
-
-	for _, v := range PlayerList {
-		PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(v)
-		RecommendList = append(RecommendList, PlayerSimpleData)
-	}
-	player.PushClientRes(&msg.ResFriendRecommend{
-		List: RecommendList,
-	})
-	player.PlayMod.save()
-	return nil
-}
-
-func ReqFriendList(player *Player, buf []byte) error {
-	player.FriendListBackData()
-	return nil
-}
-
-func ReqFriendApply(player *Player, buf []byte) error {
-	player.FriendApplyBackData()
-	return nil
-}
-
-func ReqFriendCardMsg(player *Player, buf []byte) error {
-	player.FriendCardBackData()
-	return nil
-}
-
-func ReqFriendTimeLine(player *Player, buf []byte) error {
-	player.FriendLogBackData()
-	return nil
-}
-
-func ReqFriendTLUpvote(player *Player, buf []byte) error {
-	req := &msg.ReqFriendTLUpvote{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	FriendMod := player.PlayMod.getFriendMod()
-	Items, FUid, err := FriendMod.Upvote(int(req.Id))
-	if err != nil {
-		player.SendErrClienRes(&msg.ResFriendTLUpvote{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_TLUpvote.String())
-	if err != nil {
-		player.SendErrClienRes(&msg.ResFriendTLUpvote{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	now := GoUtil.Now()
-	// 添加时间线
-	m := &MsqMod.Msg{
-		Type:  MsqMod.HANDLE_TYPE_HANDBOOK_UPVOTE,
-		From:  int(player.M_DwUin),
-		To:    int(FUid),
-		SendT: now,
-		End:   now + sevendays,
-	}
-	FriendMod.AddActLog(friend.ACT_LOG_TYPE_VISIT_UPVOTE, "")
-	player.UpdateUserInfo()
-	FriendMgrSend(m)
-	player.PlayMod.save()
-	player.PushClientRes(&msg.ResFriendTLUpvote{
-		Code: msg.RES_CODE_SUCCESS,
-		Id:   req.Id,
-	})
-	player.TeLog("friend_upvote", map[string]interface{}{
-		"player_id": int(req.Id),
-	})
-	return nil
-}
-
-func ReqFriendTReward(player *Player, buf []byte) error {
-	req := &msg.ReqFriendTReward{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	FriendMod := player.PlayMod.getFriendMod()
-	Items, err := FriendMod.GetReward(int(req.Id))
-	if err != nil {
-		player.SendErrClienRes(&msg.ResFriendTReward{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_FriendTReward.String())
-	if err != nil {
-		player.SendErrClienRes(&msg.ResFriendTReward{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	player.PlayMod.save()
-	player.PushClientRes(&msg.ResFriendTReward{
-		Code: msg.RES_CODE_SUCCESS,
-		Id:   req.Id,
-	})
-	return nil
-}
-
 func ReqChampshipRankReward(player *Player, buf []byte) error {
 	_, myPreRank := player.GetChampshipRank()
 	ChampshipMod := player.PlayMod.getChampshipMod()
-	itemList, err := ChampshipMod.GetRankReward(myPreRank)
+	_, yesterdayActivityId := player.GetChampshipActivityId()
+	itemList, err := ChampshipMod.GetRankReward(myPreRank, yesterdayActivityId)
 	if err != nil {
 		player.SendErrClienRes(&msg.ResChampshipRankReward{
 			Code: msg.RES_CODE_FAIL,
@@ -3501,6 +3129,7 @@ func ReqMiningTake(player *Player, buf []byte) error {
 		})
 		return err
 	}
+
 	itemList, err := MiningMod.Take(req.Map, int(req.Gem))
 	if err != nil {
 		player.SendErrClienRes(&msg.ResMiningTake{
@@ -3535,7 +3164,9 @@ func ReqMiningReward(player *Player, buf []byte) error {
 		})
 		return fmt.Errorf("activity not start")
 	}
-	itemList, Mining, err := MiningMod.GetReward()
+	DecorateMod := player.PlayMod.getDecorateMod()
+	needStar := DecorateMod.GetNextNeedStar()
+	itemList, Mining, err := MiningMod.GetReward(needStar)
 	if err != nil {
 		player.SendErrClienRes(&msg.ResMiningReward{
 			Code: msg.RES_CODE_FAIL,
@@ -3785,7 +3416,14 @@ func ReqPlayroomInfo(player *Player, buf []byte) error {
 		}
 	} else {
 		PlayroomMod.SetGameId(playroom.GAME_TYPE_FILP)
-		PlayroomMod.SetGameRewardFlip(int(float64(PlayerData.Star)*0.03), int(float64(PlayerData.Star)*0.05), int(float64(PlayerData.Star)*0.1))
+		DecorateMod := player.PlayMod.getDecorateMod()
+		needStar := DecorateMod.GetNextNeedStar()
+		highReward := int(float64(needStar) * 0.75)
+		if highReward < PlayerData.Star {
+			PlayroomMod.SetGameRewardFlip(max(int(float64(needStar)*0.1), 10), max(int(float64(needStar)*0.3), 10), max(int(float64(needStar)*0.75), 10))
+		} else {
+			PlayroomMod.SetGameRewardFlip(max(10, int(float64(PlayerData.Star)*0.1)), max(10, int(float64(PlayerData.Star)*0.5)), max(PlayerData.Star, 10))
+		}
 	}
 	player.PlayMod.save()
 	player.PlayroomVisit(Targer)
@@ -4771,6 +4409,7 @@ func ReqSetEmoji(player *Player, buf []byte) error {
 		"emoji_id":       int(req.Id),
 		"emoji_setplace": int(req.Type),
 	})
+	player.UpdateUserInfo()
 	player.PlayMod.save()
 	player.PushClientRes(&msg.ResSetEmoji{
 		Code: msg.RES_CODE_SUCCESS,
@@ -5005,6 +4644,24 @@ func ReqLang(player *Player, buf []byte) error {
 	return nil
 }
 
+func ReqAdWatch(player *Player, buf []byte) error {
+	req := &msg.ReqAdWatch{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	ChargeMod := player.GetChargeMod()
+	ChargeMod.AddAdWatch()
+	player.TeLog("ad_watch", map[string]interface{}{
+		"type": req.Type,
+	})
+	player.PlayMod.save()
+	player.UpdateUserInfo()
+	player.PushClientRes(&msg.ResAdWatch{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
 func ReqCatTrickReward(player *Player, buf []byte) error {
 	req := &msg.ReqCatTrickReward{}
 	err := proto.Unmarshal(buf, req)
@@ -5047,40 +4704,6 @@ func ReqCatTrickReward(player *Player, buf []byte) error {
 	return nil
 }
 
-func ReqAddNpc(player *Player, buf []byte) error {
-	req := &msg.ReqAddNpc{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	FriendMod := player.PlayMod.getFriendMod()
-	err = FriendMod.SetNpc(int(req.NpcId))
-	if err != nil {
-		player.SendErrClienRes(&msg.ResAddNpc{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	if len(FriendMod.Npc) == 1 { // 首次添加NPC 视为邀请好友成功
-		InviteMod := player.PlayMod.getInviteMod()
-		InviteMod.AddInvite(int(req.NpcId))
-	}
-	player.PlayMod.save()
-	player.FriendListBackData()
-	player.TeLog("add_npc", map[string]interface{}{
-		"NpcId": int(req.NpcId),
-	})
-	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()+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,
-		NpcId: req.NpcId,
-	})
-	return nil
-}
-
 func ReqChargeReceive(player *Player, buf []byte) error {
 	req := &msg.ReqChargeReceive{}
 	err := proto.Unmarshal(buf, req)
@@ -5205,6 +4828,7 @@ func ReqSendWishBeg(player *Player, buf []byte) error {
 	return nil
 }
 
+// TODO 心愿单功能 待开发
 func ReqWishApplyList(player *Player, buf []byte) error {
 	req := &msg.ReqWishApplyList{}
 	err := proto.Unmarshal(buf, req)
@@ -5215,7 +4839,7 @@ func ReqWishApplyList(player *Player, buf []byte) error {
 	List := FriendMod.GetWishApply()
 	rs := make([]*msg.ResFriendApplyInfo, 0)
 	for _, v := range List {
-		PD := G_GameLogicPtr.GetResSimplePlayerByUid(int(v.Uid))
+		PD := G_GameLogicPtr.GetResSimplePlayerByUid(0)
 		if PD == nil {
 			continue
 		}
@@ -5330,51 +4954,6 @@ func ReqId2Verify(player *Player, buf []byte) error {
 	return nil
 }
 
-func ReqFriendByCode(player *Player, buf []byte) error {
-	req := &msg.ReqFriendByCode{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	if req.Code == "" {
-		player.SendErrClienRes(&msg.ResFriendByCode{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "code is empty",
-		})
-		return fmt.Errorf("code is empty")
-	}
-	CodeNum := GoUtil.ParseUniqueStringToInt(req.Code)
-	if CodeNum <= 0 {
-		player.SendErrClienRes(&msg.ResFriendByCode{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "code is invalid",
-		})
-		return fmt.Errorf("code is invalid")
-	}
-	Uid := int64(CodeNum) + int64(100000) + int64(conf.Server.AppID*100000000)
-	if Uid == player.M_DwUin {
-		player.SendErrClienRes(&msg.ResFriendByCode{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "can not add yourself",
-		})
-		return fmt.Errorf("can not add yourself")
-	}
-
-	PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(int(Uid))
-	if PlayerSimpleData == nil {
-		player.SendErrClienRes(&msg.ResFriendByCode{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "player not exist",
-		})
-		return fmt.Errorf("player not exist")
-	}
-	player.PushClientRes(&msg.ResFriendByCode{
-		Code:   msg.RES_CODE_SUCCESS,
-		Player: PlayerSimpleData,
-	})
-	return nil
-}
-
 func ReqPlayroomGameShowReward(player *Player, buf []byte) error {
 	req := &msg.ReqPlayroomGameShowReward{}
 	err := proto.Unmarshal(buf, req)
@@ -5777,104 +5356,6 @@ func ReqActPassReward(player *Player, buf []byte) error {
 	return nil
 }
 
-func ReqFriendReplyHandle(player *Player, buf []byte) error {
-	req := &msg.ReqFriendReplyHandle{}
-	err := proto.Unmarshal(buf, req)
-	if err != nil {
-		return err
-	}
-	FriendMod := player.PlayMod.getFriendMod()
-	ReplyInfo := FriendMod.ReplyFriend(int(req.LogId))
-	if ReplyInfo == nil {
-		player.SendErrClienRes(&msg.ResFriendReplyHandle{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  "reply info not exist",
-		})
-		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:
-			ReplyData := friend.ReplyInfo{
-				Uid:   int(player.M_DwUin),
-				Type:  friend.REPLY_TYPE_GREETING_Get,
-				Param: req.Param,
-			}
-			FriendMgrSend(&MsqMod.Msg{
-				From:  int(player.M_DwUin),
-				To:    int(ReplyInfo.Uid),
-				Type:  MsqMod.HANDLE_TYPE_FRIEND_GREETING_REPLY,
-				SendT: now,
-				End:   now + sevendays,
-				Extra: ReplyData,
-			})
-		case friend.REPLY_TYPE_CATNIP: // 猫草大作战同意邀请
-			GameId := GoUtil.Int(ReplyInfo.Param)
-			activityInfo := player.GetActivityInfo(player.GetActivityId(activity.ACT_TYPE_CATNIP))
-			if activityInfo == nil {
-				break
-			}
-			err := player.SetCatnipPartner(GameId, ReplyInfo.Uid, activityInfo.EndT)
-			if err == nil {
-				CatnipMod := player.PlayMod.getCatnipMod()
-				ActivityId := player.GetActivityId(activity.ACT_TYPE_CATNIP)
-				UserList, _ := CatnipMod.Agree(GameId, ReplyInfo.Uid)
-				player.TeLog("catnip_agree", map[string]interface{}{
-					"Id": int(GameId),
-				})
-				FriendMgrSend(&MsqMod.Msg{
-					From: int(player.M_DwUin),
-					To:   int(ReplyInfo.Uid),
-					Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
-					Extra: CatnipMsg{
-						ActivityId: ActivityId,
-						GameId:     int(GameId),
-					},
-					SendT: now,
-					End:   now + sevendays,
-				})
-
-				for _, v := range UserList {
-					FriendMgrSend(&MsqMod.Msg{
-						From: int(player.M_DwUin),
-						To:   int(v),
-						Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
-						Extra: CatnipMsg{
-							ActivityId: ActivityId,
-							GameId:     int(GameId),
-						},
-						SendT: now,
-						End:   now + sevendays,
-					})
-				}
-				player.CatnipBackData()
-			} else {
-				ErrType = msg.FRIEND_REPLY_HANDLE_ERR_TYPE_CATNIP
-			}
-
-		}
-	}
-	Items := baseCfg.GetFriendReplyReward()
-	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_FriendReplyHandle.String())
-	if err != nil {
-		player.SendErrClienRes(&msg.ResFriendReplyHandle{
-			Code: msg.RES_CODE_FAIL,
-			Msg:  err.Error(),
-		})
-		return err
-	}
-	player.FriendLogBackData()
-	player.PushClientRes(&msg.ResFriendReplyHandle{
-		Code:    msg.RES_CODE_SUCCESS,
-		LogId:   req.LogId,
-		Type:    req.Type,
-		ErrType: ErrType,
-	})
-	return nil
-}
-
 func ReqGetChessRetireReward(player *Player, buf []byte) error {
 	req := &msg.ReqGetChessRetireReward{}
 	err := proto.Unmarshal(buf, req)

src/server/game/req_func_friend.go

@@ -0,0 +1,579 @@
+package game
+
+import (
+	"fmt"
+	"server/conf"
+	baseCfg "server/conf/base"
+	friendCfg "server/conf/friend"
+	"server/db"
+	"server/game/mod/activity"
+	"server/game/mod/friend"
+	MsqMod "server/game/mod/msg"
+	GoUtil "server/game_util"
+	"server/msg"
+	"strconv"
+
+	"google.golang.org/protobuf/proto"
+)
+
+func ReqFriendRecommend(player *Player, buf []byte) error {
+	FriendMod := player.PlayMod.getFriendMod()
+	RecommendList := make([]*msg.ResPlayerSimple, 0)
+	FriendNum := FriendMod.GetFriendNum()
+	err := FriendMod.AddDailyRecommend()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendRecommend{})
+		return err
+	}
+	var n int
+	if FriendNum < 10 {
+		n = 3
+	} else {
+		Active := 0
+		for k := range FriendMod.GetFriendList() {
+			PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(k)
+			if PlayerSimpleData == nil {
+				continue
+			}
+			if PlayerSimpleData.Login > GoUtil.Now()-86400 {
+				Active++
+			}
+		}
+		n = max(0, 3-(Active/10))
+	}
+	PlayerList := GetRecommendPlayer(player, n)
+
+	for _, v := range PlayerList {
+		PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(v)
+		RecommendList = append(RecommendList, PlayerSimpleData)
+	}
+	player.PushClientRes(&msg.ResFriendRecommend{
+		List: RecommendList,
+	})
+	player.PlayMod.save()
+	return nil
+}
+
+// 搜索用户
+func ReqSearchPlayer(player *Player, buf []byte) error {
+	req := &msg.ReqSearchPlayer{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	Uid, err := strconv.Atoi(req.Uid)
+	list := make([]*msg.ResPlayerSimple, 0)
+	if err == nil {
+		SearchPlayer := G_GameLogicPtr.GetResSimplePlayerByUid(Uid)
+		if SearchPlayer != nil && SearchPlayer.Level != 0 {
+			list = append(list, SearchPlayer)
+		}
+	}
+	data, err := db.SearchPlayer(req.Uid)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResSearchPlayer{
+			Code: 0,
+		})
+	}
+	for _, v := range data {
+		if player.M_DwUin == v.DwUin {
+			continue
+		}
+		SearchPlayer := G_GameLogicPtr.GetResSimplePlayerByUid(int(v.DwUin))
+		list = append(list, SearchPlayer)
+
+	}
+	// list 列表去重
+	l := make(map[int]*msg.ResPlayerSimple)
+	for _, v := range list {
+		if _, ok := l[int(v.Uid)]; !ok {
+			l[int(v.Uid)] = v
+		}
+	}
+	l2 := make([]*msg.ResPlayerSimple, 0)
+	for _, v := range l {
+		l2 = append(l2, v)
+	}
+	player.PushClientRes(&msg.ResSearchPlayer{
+		List: l2,
+	})
+	return nil
+}
+
+// 申请好友
+func ReqApplyFriend(player *Player, buf []byte) error {
+	req := &msg.ReqApplyFriend{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	Uid := int(req.Uid)
+	FriendMod := player.PlayMod.getFriendMod()
+	if Uid == int(player.M_DwUin) {
+		player.SendErrClienRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "cannot apply yourself",
+		})
+		return fmt.Errorf("cannot apply yourself")
+	}
+	if FriendMod.CheckFriend(Uid) {
+		player.SendErrClienRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "already friend",
+		})
+		return fmt.Errorf("already friend")
+	}
+	// 好友人数到达上限（2000人）时，玩家将无法再发送好友申请
+	if FriendMod.GetFriendLen() >= friendCfg.GetFriendLimitNum() {
+		player.SendErrClienRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "friend list full",
+		})
+		return fmt.Errorf("friend list full")
+	}
+	// 对于任何玩家而言，向自己在24小时内已从任意途径发送过好友申请的玩家再次发送好友申请时，该次申请不会被发出
+	sendApplyTime := FriendMod.GetSendApplyTime(Uid)
+	if sendApplyTime != 0 && GoUtil.Now()-sendApplyTime < oneday {
+		player.PushClientRes(&msg.ResApplyFriend{
+			Code: msg.RES_CODE_FAIL,
+			Uid:  req.Uid,
+			Msg:  "already applied",
+		})
+		return fmt.Errorf("already applied")
+	}
+	FriendMod.AddSendApply(Uid)
+	now := GoUtil.Now()
+	if req.Type == 1 {
+		Items, err := FriendMod.GetSponsorReward()
+		if err != nil {
+			player.SendErrClienRes(&msg.ResApplyFriend{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			})
+			return err
+		}
+		BaseMod := player.PlayMod.getBaseMod()
+		BaseMod.GetEnergyByAD()
+		err = player.HandleItem(Items, msg.ITEM_POP_LABEL_ApplyFriendSponsor.String())
+		if err != nil {
+			player.SendErrClienRes(&msg.ResApplyFriend{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			})
+			return err
+		}
+		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: now,
+			End:   now + sevendays,
+		})
+		player.PushClientRes(BaseMod.BackData())
+		player.TeLog("friend_invite_reward", map[string]interface{}{
+			"item_list": Items,
+		})
+	}
+	m := &MsqMod.Msg{
+		Type:  MsqMod.HANDLE_TYPE_APPLY,
+		From:  int(player.M_DwUin),
+		To:    Uid,
+		SendT: now,
+		End:   now + sevendays,
+		Extra: map[string]interface{}{
+			"type": req.Type,
+		},
+	}
+	FriendMgrSend(m)
+	player.PushClientRes(&msg.ResApplyFriend{
+		Code: msg.RES_CODE_SUCCESS,
+		Uid:  req.Uid,
+	})
+	return nil
+}
+
+// 同意申请
+func ReqAgreeFriend(player *Player, buf []byte) error {
+	req := &msg.ReqAgreeFriend{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	Uid := int(req.Uid)
+	FriendMod := player.PlayMod.getFriendMod()
+	if !FriendMod.CheckApply(Uid) {
+		player.SendErrClienRes(&msg.ResAgreeFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "apply uid not exist",
+		})
+		return fmt.Errorf("apply uid not exist")
+	}
+	// 好友人数到达上限（2000人）时，玩家将无法再同意好友申请
+	if FriendMod.GetFriendLen() >= friendCfg.GetFriendLimitNum() {
+		player.SendErrClienRes(&msg.ResAgreeFriend{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "friend list full",
+		})
+		return fmt.Errorf("friend list full")
+	}
+	// 新好友才可以打招呼
+	if !FriendMod.CheckGreeting(Uid) {
+		FriendMod.AddReplyInfo(Uid, friend.REPLY_TYPE_GREETING, "", GoUtil.Now()+oneday, nil)
+	}
+	FriendMod.AddFriend(Uid)
+	player.PushClientRes(&msg.ResAgreeFriend{
+		Code:   msg.RES_CODE_SUCCESS,
+		Uid:    req.Uid,
+		Player: G_GameLogicPtr.GetResSimplePlayerByUid(int(req.Uid)),
+	})
+	player.TeLog("friend_add", map[string]interface{}{
+		"player_id": Uid,
+		"add_type":  "接受申请",
+	})
+	player.AddLog(Uid, friend.LOG_TYPE_FRIEND_BECOME, "", GoUtil.Now())
+	m := &MsqMod.Msg{
+		Type:  MsqMod.HADNLE_TYPE_AGREE,
+		From:  int(player.M_DwUin),
+		To:    Uid,
+		SendT: GoUtil.Now(),
+	}
+	FriendMgrSend(m)
+	player.FriendApplyBackData()
+	player.FriendLogBackData()
+	player.PlayMod.save()
+	return nil
+}
+
+// 删除好友
+func ReqDelFriend(player *Player, buf []byte) error {
+	req := &msg.ReqDelFriend{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	Uid := int(req.Uid)
+	m := &MsqMod.Msg{
+		Type:  MsqMod.HANDLE_TYPE_DEL,
+		From:  int(player.M_DwUin),
+		To:    Uid,
+		SendT: GoUtil.Now(),
+	}
+	FriendMgrSend(m)
+	FriendMod := player.PlayMod.getFriendMod()
+	FriendMod.DelFriend(Uid)
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResDelFriend{
+		Code: msg.RES_CODE_SUCCESS,
+		Uid:  req.Uid,
+	})
+	player.AddLog(Uid, friend.LOG_TYPE_FRIEND_DELETE, "", GoUtil.Now())
+	player.FriendListBackData()
+	player.TeLog("friend_delete", map[string]interface{}{
+		"player_id": Uid,
+	})
+	return nil
+}
+
+// 拒绝申请
+func ReqRefuseFriend(player *Player, buf []byte) error {
+	req := &msg.ReqRefuseFriend{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	Uid := int(req.Uid)
+	FriendMod := player.PlayMod.getFriendMod()
+	FriendMod.RefuseApply(Uid)
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResRefuseFriend{
+		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: now,
+		End:   now + 86400*7,
+	}
+	FriendMgrSend(m)
+	player.FriendApplyBackData()
+	return nil
+}
+
+func ReqFriendList(player *Player, buf []byte) error {
+	player.FriendListBackData()
+	return nil
+}
+
+func ReqFriendApply(player *Player, buf []byte) error {
+	player.FriendApplyBackData()
+	return nil
+}
+
+func ReqFriendCardMsg(player *Player, buf []byte) error {
+	player.FriendCardBackData()
+	return nil
+}
+
+func ReqFriendTimeLine(player *Player, buf []byte) error {
+	player.FriendLogBackData()
+	return nil
+}
+
+func ReqFriendTLUpvote(player *Player, buf []byte) error {
+	req := &msg.ReqFriendTLUpvote{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	FriendMod := player.PlayMod.getFriendMod()
+	Items, FUid, err := FriendMod.Upvote(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTLUpvote{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_TLUpvote.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTLUpvote{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	now := GoUtil.Now()
+	// 添加时间线
+	m := &MsqMod.Msg{
+		Type:  MsqMod.HANDLE_TYPE_HANDBOOK_UPVOTE,
+		From:  int(player.M_DwUin),
+		To:    int(FUid),
+		SendT: now,
+		End:   now + sevendays,
+	}
+	FriendMod.AddActLog(friend.ACT_LOG_TYPE_VISIT_UPVOTE, "")
+	player.UpdateUserInfo()
+	FriendMgrSend(m)
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTLUpvote{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   req.Id,
+	})
+	player.TeLog("friend_upvote", map[string]interface{}{
+		"player_id": int(req.Id),
+	})
+	return nil
+}
+
+func ReqFriendTReward(player *Player, buf []byte) error {
+	req := &msg.ReqFriendTReward{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	FriendMod := player.PlayMod.getFriendMod()
+	Items, err := FriendMod.GetReward(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_FriendTReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendTReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTReward{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   req.Id,
+	})
+	return nil
+}
+
+func ReqFriendReplyHandle(player *Player, buf []byte) error {
+	req := &msg.ReqFriendReplyHandle{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	FriendMod := player.PlayMod.getFriendMod()
+	ReplyInfo := FriendMod.ReplyFriend(int(req.LogId))
+	if ReplyInfo == nil {
+		player.SendErrClienRes(&msg.ResFriendReplyHandle{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "reply info not exist",
+		})
+		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:
+			ReplyData := friend.ReplyInfo{
+				Uid:   int(player.M_DwUin),
+				Type:  friend.REPLY_TYPE_GREETING_Get,
+				Param: req.Param,
+			}
+			FriendMgrSend(&MsqMod.Msg{
+				From:  int(player.M_DwUin),
+				To:    int(ReplyInfo.Uid),
+				Type:  MsqMod.HANDLE_TYPE_FRIEND_GREETING_REPLY,
+				SendT: now,
+				End:   now + sevendays,
+				Extra: ReplyData,
+			})
+			FriendMod.GreetingFriend(int(ReplyInfo.Uid))
+		case friend.REPLY_TYPE_CATNIP: // 猫草大作战同意邀请
+			GameId := GoUtil.Int(ReplyInfo.Param)
+			activityInfo := player.GetActivityInfo(player.GetActivityId(activity.ACT_TYPE_CATNIP))
+			if activityInfo == nil {
+				break
+			}
+			err := player.SetCatnipPartner(GameId, ReplyInfo.Uid, activityInfo.EndT)
+			if err == nil {
+				CatnipMod := player.PlayMod.getCatnipMod()
+				ActivityId := player.GetActivityId(activity.ACT_TYPE_CATNIP)
+				UserList, _ := CatnipMod.Agree(GameId, ReplyInfo.Uid)
+				player.TeLog("catnip_agree", map[string]interface{}{
+					"Id": int(GameId),
+				})
+				FriendMgrSend(&MsqMod.Msg{
+					From: int(player.M_DwUin),
+					To:   int(ReplyInfo.Uid),
+					Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
+					Extra: CatnipMsg{
+						ActivityId: ActivityId,
+						GameId:     int(GameId),
+					},
+					SendT: now,
+					End:   now + sevendays,
+				})
+
+				for _, v := range UserList {
+					FriendMgrSend(&MsqMod.Msg{
+						From: int(player.M_DwUin),
+						To:   int(v),
+						Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
+						Extra: CatnipMsg{
+							ActivityId: ActivityId,
+							GameId:     int(GameId),
+						},
+						SendT: now,
+						End:   now + sevendays,
+					})
+				}
+				player.CatnipBackData()
+			} else {
+				ErrType = msg.FRIEND_REPLY_HANDLE_ERR_TYPE_CATNIP
+			}
+
+		}
+	}
+	Items := baseCfg.GetFriendReplyReward()
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_FriendReplyHandle.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResFriendReplyHandle{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.FriendLogBackData()
+	player.PushClientRes(&msg.ResFriendReplyHandle{
+		Code:    msg.RES_CODE_SUCCESS,
+		LogId:   req.LogId,
+		Type:    req.Type,
+		ErrType: ErrType,
+	})
+	return nil
+}
+
+func ReqFriendByCode(player *Player, buf []byte) error {
+	req := &msg.ReqFriendByCode{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	if req.Code == "" {
+		player.SendErrClienRes(&msg.ResFriendByCode{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "code is empty",
+		})
+		return fmt.Errorf("code is empty")
+	}
+	CodeNum := GoUtil.ParseUniqueStringToInt(req.Code)
+	if CodeNum <= 0 {
+		player.SendErrClienRes(&msg.ResFriendByCode{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "code is invalid",
+		})
+		return fmt.Errorf("code is invalid")
+	}
+	Uid := int64(CodeNum) + int64(100000) + int64(conf.Server.AppID*100000000)
+	if Uid == player.M_DwUin {
+		player.SendErrClienRes(&msg.ResFriendByCode{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "can not add yourself",
+		})
+		return fmt.Errorf("can not add yourself")
+	}
+
+	PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(int(Uid))
+	if PlayerSimpleData == nil {
+		player.SendErrClienRes(&msg.ResFriendByCode{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "player not exist",
+		})
+		return fmt.Errorf("player not exist")
+	}
+	player.PushClientRes(&msg.ResFriendByCode{
+		Code:   msg.RES_CODE_SUCCESS,
+		Player: PlayerSimpleData,
+	})
+	return nil
+}
+
+func ReqAddNpc(player *Player, buf []byte) error {
+	req := &msg.ReqAddNpc{}
+	err := proto.Unmarshal(buf, req)
+	if err != nil {
+		return err
+	}
+	FriendMod := player.PlayMod.getFriendMod()
+	err = FriendMod.SetNpc(int(req.NpcId))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResAddNpc{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	if len(FriendMod.Npc) == 1 { // 首次添加NPC 视为邀请好友成功
+		InviteMod := player.PlayMod.getInviteMod()
+		InviteMod.AddInvite(int(req.NpcId))
+	}
+	player.PlayMod.save()
+	player.FriendListBackData()
+	player.TeLog("add_npc", map[string]interface{}{
+		"NpcId": int(req.NpcId),
+	})
+	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()+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,
+		NpcId: req.NpcId,
+	})
+	return nil
+}

src/server/game/req_func_fur.go

@@ -0,0 +1,52 @@
+package game
+
+import (
+	"server/msg"
+
+	"google.golang.org/protobuf/proto"
+)
+
+func ReqPetFur(player *Player, buf []byte) error {
+	FurMod := player.GetFurMod()
+	player.PushClientRes(FurMod.BackData())
+	return nil
+}
+
+func ReqPetFurBuy(player *Player, buf []byte) error {
+	var req msg.ReqPetFurBuy
+	err := proto.Unmarshal(buf, &req)
+	if err != nil {
+		return err
+	}
+	FurMod := player.GetFurMod()
+	costList, AddItem := FurMod.GetFurBuyCost(int(req.FurId))
+	// 扣除物品
+	err = player.HandleLoseItem(costList, msg.ITEM_POP_LABEL_PetFurShop.String())
+	if err != nil {
+		return err
+	}
+	// 增加物品
+	err = player.HandleItem(AddItem, msg.ITEM_POP_LABEL_PetFurShop.String())
+	if err != nil {
+		return err
+	}
+	player.PlayMod.save()
+	return nil
+}
+
+func ReqFurSet(player *Player, buf []byte) error {
+	var req msg.ReqFurSet
+	err := proto.Unmarshal(buf, &req)
+	if err != nil {
+		return err
+	}
+	FurMod := player.GetFurMod()
+	err = FurMod.SetFur(int(req.FurId))
+	if err != nil {
+		return err
+	}
+	player.UpdateUserInfo()
+	player.PlayMod.save()
+	player.PushClientRes(FurMod.BackData())
+	return nil
+}

src/server/game/trigger_func.go

@@ -142,6 +142,7 @@ func (player *Player) TriggerShippingOrderOrigin(req *msg.ReqShippingOrder) {
 		ProduceName := chargeCfg.GetProduceName(OrderData.ProductId)
 		GoUtil.SendFeishuOrder(int(player.M_DwUin), OrderData.PayChannelOrderId, OrderData.Price, ProduceName, OrderData.PayTime, GoUtil.Now(), ChargeMod.Charge)
 	}
+	BaseMod := player.PlayMod.getBaseMod()
 	orderDataMap := map[string]interface{}{
 		"AppId":             conf.Server.AppID,
 		"ServerId":          conf.Server.ServerID,
@@ -153,6 +154,9 @@ func (player *Player) TriggerShippingOrderOrigin(req *msg.ReqShippingOrder) {
 		"Token":             req.Token,
 		"Price":             OrderData.Price,
 		"PayType":           OrderData.PayType,
+		"Level":             BaseMod.GetLevel(),
+		"Energy":            BaseMod.GetEnergy(),
+		"Star":              BaseMod.GetStar(),
 	}
 	player.TeLog("pay", orderDataMap)
 	player.PushClientRes(&msg.ResShippingOrder{

src/server/game_util/GoUtil.go

@@ -210,6 +210,29 @@ func Int(a interface{}) int {
 	return 0
 }
 
+func Int32(a interface{}) int32 {
+	if a == nil {
+		return 0
+	}
+	switch v := a.(type) {
+	case int:
+		return int32(v)
+	case int32:
+		return int32(v)
+	case int64:
+		return int32(v)
+	case float64:
+		return int32(v)
+	case string:
+		r, err := strconv.Atoi(v)
+		if err != nil {
+			return 0
+		}
+		return int32(r)
+	}
+	return 0
+}
+
 func String(a interface{}) string {
 	if a == nil {
 		return ""
@@ -564,7 +587,9 @@ const (
 )
 
 func NotifyPlayer(uid, pushid int, title, content string) {
-
+	if uid == 0 {
+		return
+	}
 	url := "https://tygapi-new.tuyooglobal.com/api/push/ga/push_message/project_trigger"
 	method := "POST"
 	executeId := fmt.Sprintf("%s_%s", PROJECT_ID, Rand8DigitNumber()+Rand8DigitNumber())

src/server/game_util/feishu.go

@@ -64,11 +64,11 @@ func SendFeishuOrder(PlayerId int, OrderId string, Price float64, ProductName st
 	payload := map[string]interface{}{
 		"UID":           PlayerId,
 		"OrderId":       OrderId,
-		"Product":       String(Price),
+		"Product":       fmt.Sprintf("%.2f", Price),
 		"ProductName":   ProductName,
 		"EventRecovery": time.Unix(PayTime, 0).Format("2006-01-02 15:04:05"),
 		"EventAge":      time.Unix(VerityTime, 0).Format("2006-01-02 15:04:05"),
-		"TotalCharge":   String(Charge),
+		"TotalCharge":   fmt.Sprintf("%.2f", Charge),
 	}
 
 	payloadBytes, err := json.Marshal(payload)

src/server/game_util/timeUtil.go

@@ -174,3 +174,7 @@ func IsFirstDayOfMonth() bool {
 	now := time.Now()
 	return now.Day() == 1
 }
+
+func NowMonth() int {
+	return int(time.Now().Month())
+}

src/server/gamedata/config/reload

@@ -1 +0,0 @@
-11

src/server/go.mod

@@ -46,7 +46,10 @@ require (
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )
 
-require golang.org/x/sys v0.29.0 // indirect
+require (
+	github.com/apache/thrift v0.22.0 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+)
 
 require (
 	filippo.io/edwards25519 v1.1.0 // indirect

src/server/go.sum

@@ -73,6 +73,8 @@ github.com/aliyun/credentials-go v1.3.6/go.mod h1:1LxUuX7L5YrZUWzBrRyk0SwSdH4OmP
 github.com/aliyun/credentials-go v1.4.5/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
 github.com/aliyun/credentials-go v1.4.6 h1:CG8rc/nxCNKfXbZWpWDzI9GjF4Tuu3Es14qT8Y0ClOk=
 github.com/aliyun/credentials-go v1.4.6/go.mod h1:Jm6d+xIgwJVLVWT561vy67ZRP4lPTQxMbEYRuT2Ti1U=
+github.com/apache/thrift v0.22.0 h1:r7mTJdj51TMDe6RtcmNdQxgn9XcyfGDOzegMDRg47uc=
+github.com/apache/thrift v0.22.0/go.mod h1:1e7J/O1Ae6ZQMTYdy9xa3w9k+XHWPfRvdPyJeynQ+/g=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=

src/server/test/README.MD

@@ -0,0 +1,33 @@
+# 单元调试
+
+## 好友模块
+
+### 随机好友推荐
+
+```golang
+test function TestFriendRecommendList 2026-03-04
+ok  server/test 1.033s 
+```
+
+### 好友离线消息聚合
+
+```golang
+3625212 | 100001
+3714321 | 100002
+```
+
+### 好友申请
+
+```golang
+test function TestReqApplyFriend 2026-03-05
+ok      server/test     0.479s
+```
+
+## 充值模块
+
+### 观看广告记录
+
+```golang
+test function TestWatchAd 2026-03-04
+ok server/test  0.410s
+```

src/server/test/champship_test.go

@@ -0,0 +1,37 @@
+package test
+
+import (
+	champshipCfg "server/conf/champship"
+	"server/game"
+	"testing"
+)
+
+func TestChampshipReward(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	ChampshipMod := p1.GetChampshipMod()
+	ChampshipMod.Score = 1000
+	game.ReqChampshipReward(p1, nil)
+}
+
+func TestChampshipRankReward(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	ChampshipMod := p1.GetChampshipMod()
+	ChampshipMod.RankReward = false
+	_, yesterdayActivityId := p1.GetChampshipActivityId()
+	ChampshipMod.GetRankReward(1, yesterdayActivityId)
+}
+
+func TestGetChampshipActivityId(t *testing.T) {
+	res := champshipCfg.GetChampshipActivityId()
+	t.Logf("res:%v", res)
+}
+
+func TestReqChampshipReward(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	ChampshipMod := p1.GetChampshipMod()
+	ChampshipMod.Score = 1000
+	game.ReqChampshipReward(p1, nil)
+}

src/server/test/charge_test.go

@@ -1,6 +1,7 @@
 package test
 
 import (
+	"fmt"
 	"server/game"
 	"testing"
 )
@@ -11,3 +12,17 @@ func TestSpecialCharge(t *testing.T) {
 	ChargeMod := p1.GetChargeMod()
 	ChargeMod.ZeroUpdate(nil)
 }
+
+func TestWatchAd(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	ChargeMod := p1.GetChargeMod()
+	ChargeMod.AddAdWatch()
+	count := ChargeMod.GetAdWatch()
+	fmt.Println("观看广告次数：", count)
+	ChargeMod.ZeroUpdate(nil)
+	fmt.Println("观看广告次数重置后：", ChargeMod.GetAdWatch())
+	ChargeMod.AddAdWatch()
+	count = ChargeMod.GetAdWatch()
+	fmt.Println("观看广告次数：", count)
+}

src/server/test/chess_test.go

@@ -0,0 +1,23 @@
+package test
+
+import (
+	"fmt"
+	"server/game"
+	"server/game/mod/order"
+	"testing"
+)
+
+func TestGetStarEmitList(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	ChessMod := p1.GetChessMod()
+	EM := ChessMod.GetStarEmitList()
+	OrderMod := p1.GetOrderMod()
+	OrderMod.OrderList = map[int]order.Order{
+		1: {
+			MergeId: []int{25, 25},
+		},
+	}
+	p1.InitOrderItem()
+	fmt.Printf("%v\n", EM)
+}

src/server/test/dailytask_test.go

@@ -0,0 +1,39 @@
+package test
+
+import (
+	"fmt"
+	dailyTaskCfg "server/conf/daily_task"
+	"server/game"
+	"testing"
+)
+
+func TestDailyActiviyId(t *testing.T) {
+	player := new(game.Player)
+	player.InitPlayerByUid(100001)
+	ids := player.GetDailyTaskActivityId()
+	if ids == 0 {
+		t.Errorf("GetDailyTaskActivityId failed, ids is empty")
+	}
+}
+
+func TestDailyZeroUpdate(t *testing.T) {
+	player := new(game.Player)
+	player.InitPlayerByUid(100001)
+	DailyTaskMod := player.GetDailyTaskMod()
+	BaseMod := player.GetBaseMod()
+	DecorateMod := player.GetDecorateMod()
+	DailyTaskMod.ZeroUpdate(BaseMod.Level, DecorateMod.GetAreaId(), player.GetDailyTaskActivityId())
+	DailyTaskMod.BackData()
+}
+
+func TestDailyTaskRewardScore(t *testing.T) {
+	score1 := dailyTaskCfg.GetDailyTaskScore(1, 1)
+	if score1 == 0 {
+		t.Errorf("GetDailyTaskScore failed, score1 is 0")
+	}
+	score2 := dailyTaskCfg.GetDailyTaskScore(1, 0)
+	if score2 == 0 {
+		t.Errorf("GetDailyTaskScore failed, score2 is 0")
+	}
+	fmt.Printf("score1: %d, score2: %d\n", score1, score2)
+}

src/server/test/friend_test.go

@@ -0,0 +1,48 @@
+package test
+
+import (
+	"fmt"
+	"server/game"
+	"server/msg"
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+)
+
+func TestFriendInit(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	FriendMod := p1.GetFriendMod()
+	if FriendMod == nil {
+		t.Error("FriendMod init failed")
+	}
+}
+
+func TestFriendApply(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	FriendMod := p1.GetFriendMod()
+	FriendMod.AddFriendApply(100002, 0, 1698000000)
+	if !FriendMod.CheckApply(100002) {
+		t.Error("FriendMod AddFriendApply failed")
+	}
+}
+
+func TestFriendRecommendList(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	l1 := game.GetRecommendPlayer(p1, 3)
+	fmt.Printf("Recommend List: %v\n", l1)
+}
+
+func TestReqApplyFriend(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	req := &msg.ReqApplyFriend{
+		Uid:  100002,
+		Type: 0,
+	}
+	buf, _ := proto.Marshal(req)
+	game.ReqApplyFriend(p1, buf)
+	p1.FriendListBackData()
+}

src/server/test/fur_test.go

@@ -0,0 +1,92 @@
+package test
+
+import (
+	"fmt"
+	fur_cfg "server/conf/fur"
+	"server/game"
+	"server/msg"
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+)
+
+func TestGetFurShopCost(t *testing.T) {
+	cost := fur_cfg.GetFurShopCost(1)
+	fmt.Printf("cost: %v", cost)
+}
+
+func TestGetFurShopFreeTimes(t *testing.T) {
+	freeTimes := fur_cfg.GetFurShopFreeTimes()
+	fmt.Printf("freeTimes: %d", freeTimes)
+}
+
+func TestGetFurShopTag(t *testing.T) {
+	tag := fur_cfg.GetFurShopTag(1)
+	fmt.Printf("tag: %d", tag)
+}
+
+func TestReqPetFur(t *testing.T) {
+	player := new(game.Player)
+	err := game.ReqPetFur(player, nil)
+	if err != nil {
+		t.Errorf("ReqPetFur error: %v", err)
+	}
+}
+
+func TestReqPetFurBuy(t *testing.T) {
+	player := new(game.Player)
+	player.InitPlayerByUid(100001)
+	m := msg.ReqPetFurBuy{
+		FurId: 1,
+	}
+	buf, err := proto.Marshal(&m)
+	if err != nil {
+		t.Errorf("marshal error: %v", err)
+	}
+	err = game.ReqPetFurBuy(player, buf)
+	if err != nil {
+		t.Errorf("ReqPetFurBuy error: %v", err)
+	}
+
+	m = msg.ReqPetFurBuy{
+		FurId: 2,
+	}
+	buf, err = proto.Marshal(&m)
+	if err != nil {
+		t.Errorf("marshal error: %v", err)
+	}
+	err = game.ReqPetFurBuy(player, buf)
+	if err != nil {
+		t.Errorf("ReqPetFurBuy error: %v", err)
+	}
+}
+
+func TestReqFurSet(t *testing.T) {
+	player := new(game.Player)
+	player.InitPlayerByUid(100001)
+	m := msg.ReqFurSet{
+		FurId: 1,
+	}
+	buf, err := proto.Marshal(&m)
+	if err != nil {
+		t.Errorf("marshal error: %v", err)
+	}
+	FurMod := player.GetFurMod()
+	FurMod.AddFurInfo(1, 0, 0)
+	err = game.ReqFurSet(player, buf)
+	if err != nil {
+		t.Errorf("ReqFurSet error: %v", err)
+	}
+
+	m = msg.ReqFurSet{
+		FurId: 0,
+	}
+	buf, err = proto.Marshal(&m)
+	if err != nil {
+		t.Errorf("marshal error: %v", err)
+	}
+	err = game.ReqFurSet(player, buf)
+	if err != nil {
+		t.Errorf("ReqFurSet error: %v", err)
+	}
+}

src/server/test/log/20260305.log

@@ -0,0 +1,2 @@
+2026/03/05 00:00:00 [debug  ] CreateDailyLogFile
+2026/03/05 00:00:00 [debug  ] Server ZeroFlush

src/server/test/mining_test.go

@@ -0,0 +1,20 @@
+package test
+
+import (
+	miningCfg "server/conf/mining"
+	"server/game"
+	"testing"
+)
+
+func TestGetPassReward(t *testing.T) {
+	player := new(game.Player)
+	player.InitPlayerByUid(100001)
+	MiningMod := player.GetMiningMod()
+	DecorateMod := player.GetDecorateMod()
+	needStar := DecorateMod.GetNextNeedStar()
+	Items := miningCfg.GetPassItem(3, needStar)
+	if len(Items) == 0 {
+		t.Errorf("GetPassReward failed, pass: %d, needStar: %d", MiningMod.Pass, needStar)
+	}
+	player.MiningBackData()
+}

src/server/test/seven_test.go

@@ -0,0 +1,23 @@
+package test
+
+import (
+	sevenLoginCfg "server/conf/seven_login"
+	"server/game"
+	GoUtil "server/game_util"
+	"testing"
+)
+
+func TestGetSevenLoginMonthReward(t *testing.T) {
+	month := GoUtil.NowMonth()
+	res := sevenLoginCfg.GetSevenLoginMonthReward(month)
+	t.Logf("res:%v", res)
+}
+
+func TestSevenLoginZeroUpdate(t *testing.T) {
+	p1 := new(game.Player)
+	p1.InitPlayer("3625212")
+	SevenLoginMod := p1.GetSevenLoginMod()
+	SevenLoginMod.ZeroUpdate(0, 0)
+	SevenLoginMod.BackData()
+	t.Logf("SevenLoginMod:%v", SevenLoginMod)
+}