Merge branch 'develop' into sdk

src/server/GoUtil/GoUtil.go

@@ -298,6 +298,10 @@ func GetUserKey(Uid int64) string {
 	return fmt.Sprintf("user_data_%d", Uid)
 }
 
+func GetCatnipLockKey(Uid, GameId int) string {
+	return fmt.Sprintf("catnip_lock_%d_%d", Uid, GameId)
+}
+
 func Rand6DigitNumber() string {
 	n := rand.Intn(1000000)
 	return fmt.Sprintf("%06d", n)

src/server/GoUtil/sliceUtil.go

@@ -2,6 +2,7 @@ package GoUtil
 
 import (
 	"fmt"
+	"server/game/mod/item"
 	"sort"
 	"strconv"
 	"strings"
@@ -52,6 +53,15 @@ func RandSlice(slice []int) int {
 	return slice[Id]
 }
 
+func RandItem(slice []*item.Item) *item.Item {
+	slen := len(slice)
+	if slen == 0 {
+		return nil
+	}
+	Id := GetRand().Intn(slen)
+	return slice[Id]
+}
+
 func RandSliceNum(s []int, num int) []int {
 	slice := make([]int, len(s))
 	copy(slice, s)

src/server/conf/catnip/CatnipCfg.go

@@ -0,0 +1,25 @@
+package catnipCfg
+
+import "server/gamedata"
+
+const (
+	CATNIP_TEMPLATE_CFG_NAME   = "CatnipTemplate"
+	CATNIP_JACKPOT_CFG_NAME    = "CatnipJackpot"
+	CATNIP_MULTIPLIER_CFG_NAME = "CatnipMultiplier"
+	CATNIP_GAME_CFG_NAME       = "CatnipGame"
+)
+
+func init() {
+	gamedata.InitCfg(CATNIP_TEMPLATE_CFG_NAME)
+	gamedata.InitCfg(CATNIP_JACKPOT_CFG_NAME)
+	gamedata.InitCfg(CATNIP_MULTIPLIER_CFG_NAME)
+	gamedata.InitCfg(CATNIP_GAME_CFG_NAME)
+}
+
+func GetGameNum(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CATNIP_TEMPLATE_CFG_NAME, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "PassNum")
+}

src/server/db/SqlStruct.go

@@ -477,6 +477,8 @@ type SqlServerMailStruct struct {
 	Id            int    `db:"mail_id"`
 	Title         string `db:"title"`
 	Content       string `db:"content"`
+	SubTitle      string `db:"subTitle"`
+	SubTitleEn    string `db:"subTitle_en"`
 	TitleEn       string `db:"title_en"`
 	ContentEn     string `db:"content_en"`
 	Items         string `db:"items"`

src/server/game/ActivityFunc.go

@@ -8,6 +8,7 @@ import (
 	mailCfg "server/conf/mail"
 	miningCfg "server/conf/mining"
 	raceCfg "server/conf/race"
+	"server/game/mod/activity"
 	"server/game/mod/item"
 	"server/game/mod/mail"
 	"server/msg"
@@ -17,7 +18,7 @@ import (
 func ActivityLogin(p *Player) {
 	ItemMod := p.PlayMod.getItemMod()
 	// 挖矿
-	ActivityId := GetActivityId(p, ACT_TYPE_MINING)
+	ActivityId := GetActivityId(p, activity.ACT_TYPE_MINING)
 	MiningMod := p.PlayMod.getMiningMod()
 	OldId := MiningMod.Login(ActivityId)
 	if OldId != 0 {
@@ -29,7 +30,7 @@ func ActivityLogin(p *Player) {
 		}
 	}
 	// 猜颜色
-	ActivityId = GetActivityId(p, ACT_TYPE_GUESS_COLOR)
+	ActivityId = GetActivityId(p, activity.ACT_TYPE_GUESS_COLOR)
 	GuessColorMod := p.PlayMod.getGuessColorMod()
 	OldId = GuessColorMod.Login(ActivityId)
 	if OldId != 0 {
@@ -42,7 +43,7 @@ func ActivityLogin(p *Player) {
 	}
 
 	// 赛跑
-	ActivityId = GetActivityId(p, ACT_TYPE_RACE)
+	ActivityId = GetActivityId(p, activity.ACT_TYPE_RACE)
 	RaceMod := p.PlayMod.getRaceMod()
 	OldId = RaceMod.Login(ActivityId)
 	if OldId != 0 {
@@ -66,17 +67,17 @@ func SendActivityMail(p *Player, ItemId, ItemNum, ActivityId int) {
 
 // 活动模块 零点更新
 func ActivityZeroUpdate(p *Player) {
-	ActivityInfo := GetActivityInfo(p, ACT_TYPE_MINING)
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_MINING)
 	if ActivityInfo != nil {
 		MiningMod := p.PlayMod.getMiningMod()
 		MiningMod.ZeroUpdate(ActivityInfo.Id)
 	}
-	ActivityInfo = GetActivityInfo(p, ACT_TYPE_GUESS_COLOR)
+	ActivityInfo = GetActivityInfo(p, activity.ACT_TYPE_GUESS_COLOR)
 	if ActivityInfo != nil {
 		GuessColorMod := p.PlayMod.getGuessColorMod()
 		GuessColorMod.ZeroUpdate(ActivityInfo.Id)
 	}
-	ActivityInfo = GetActivityInfo(p, ACT_TYPE_RACE)
+	ActivityInfo = GetActivityInfo(p, activity.ACT_TYPE_RACE)
 	if ActivityInfo != nil {
 		RaceMod := p.PlayMod.getRaceMod()
 		RaceMod.ZeroUpdate(ActivityInfo.Id)
@@ -126,11 +127,11 @@ func GetActivityStatus(p *Player, actType int) int {
 }
 
 func MiningBackData(p *Player) {
-	ActivityInfo := GetActivityInfo(p, ACT_TYPE_MINING)
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_MINING)
 	if ActivityInfo == nil {
 		return
 	}
-	Status := GetActivityStatus(p, ACT_TYPE_MINING)
+	Status := GetActivityStatus(p, activity.ACT_TYPE_MINING)
 	Template := miningCfg.GetTemplate(ActivityInfo.Id)
 	MiningMod := p.PlayMod.getMiningMod()
 	p.PushClientRes(&msg.ResMining{
@@ -146,12 +147,12 @@ func MiningBackData(p *Player) {
 }
 
 func GuessColorBackData(p *Player) {
-	ActivityInfo := GetActivityInfo(p, ACT_TYPE_GUESS_COLOR)
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_GUESS_COLOR)
 	if ActivityInfo == nil {
 		return
 	}
 
-	Status := GetActivityStatus(p, ACT_TYPE_GUESS_COLOR)
+	Status := GetActivityStatus(p, activity.ACT_TYPE_GUESS_COLOR)
 	GuessColorMod := p.PlayMod.getGuessColorMod()
 	MapList := make([]*msg.GuessColorInfo, 0)
 	for _, v := range GuessColorMod.MapList {
@@ -177,11 +178,11 @@ func GuessColorBackData(p *Player) {
 }
 
 func RaceBackData(p *Player) {
-	ActivityInfo := GetActivityInfo(p, ACT_TYPE_RACE)
+	ActivityInfo := GetActivityInfo(p, activity.ACT_TYPE_RACE)
 	if ActivityInfo == nil {
 		return
 	}
-	Status := GetActivityStatus(p, ACT_TYPE_RACE)
+	Status := GetActivityStatus(p, activity.ACT_TYPE_RACE)
 	RaceMod := p.PlayMod.getRaceMod()
 	Opponent := make([]*msg.Raceopponent, 0)
 	for _, v := range RaceMod.Opponent {
@@ -229,13 +230,13 @@ func GetActivityItem(p *Player, ActType []int) []*item.Item {
 			continue
 		}
 		switch v {
-		case ACT_TYPE_MINING:
+		case activity.ACT_TYPE_MINING:
 			Item := miningCfg.GetLoseItem(ActivityInfo.Id)
 			Items = item.Merge(Items, Item)
-		case ACT_TYPE_GUESS_COLOR:
+		case activity.ACT_TYPE_GUESS_COLOR:
 			Item := guesscolorCfg.GetLoseItem(ActivityInfo.Id)
 			Items = item.Merge(Items, Item)
-		case ACT_TYPE_RACE:
+		case activity.ACT_TYPE_RACE:
 			ItemId := raceCfg.GetCoin(ActivityInfo.Id)
 			Item := item.NewItem(ItemId, 1)
 			Items = append(Items, Item)
@@ -243,3 +244,42 @@ func GetActivityItem(p *Player, ActType []int) []*item.Item {
 	}
 	return Items
 }
+
+func (p *Player) CatnipBackData() {
+	CatnipMod := p.PlayMod.getCatnipMod()
+	Status := GetActivityStatus(p, activity.ACT_TYPE_CATNIP)
+	if CatnipMod == nil {
+		return
+	}
+	GameList := make([]*msg.CatnipGame, 0)
+	for _, v := range CatnipMod.Game {
+		GameInfo := &msg.CatnipGame{
+			Id:       int32(v.Id),
+			Progress: int32(v.Progress),
+			Status:   int32(v.Status),
+		}
+		if v.Partner != 0 {
+			PlayerData := G_getGameLogic().GetResSimplePlayerByUid(v.Partner)
+			if PlayerData != nil {
+				GameInfo.Partner = PlayerData
+			}
+		}
+		GameList = append(GameList, GameInfo)
+	}
+	res := &msg.ResCatnip{
+		Id:       int32(CatnipMod.Id),
+		Status:   int32(Status),
+		GameList: GameList,
+	}
+	p.PushClientRes(res)
+}
+
+func (p *Player) SetCatnipGameLock(Uid int, GameId int) error {
+	ActivityInfo := GetActivityInfoById(p, activity.ACT_TYPE_CATNIP)
+	return G_GameLogicPtr.SetDataSync(int(p.M_DwUin), VAR_OP_CATNIP_LOCK, CatnipLock{
+		Uid:     int(p.M_DwUin),
+		Partner: Uid,
+		GameId:  GameId,
+		End:     int(ActivityInfo.EndT), // 锁
+	})
+}

src/server/game/FriendMgr.go

@@ -75,11 +75,20 @@ func (f *FriendMgr) Init() {
 	f.RegisterHandler(msg.HANDLE_TYPE_CHAMPSHIP_RESULT, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_TREASURE_RESULT, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_FACEBOOK_UNBIND, f.sendToPlayer)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_INVITE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_AGREE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_REFUSE, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_GROWTH, f.sendToPlayer)
+	f.RegisterHandler(msg.HANDLE_TYPE_CATNIP_AGREE_DEL, f.sendToPlayer)
+
 	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_KISS, f.sendToPlayerOnline)
-	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_GAME, f.sendToPlayerOnline)
+	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_GAME, f.sendToPlayer)
 
 	f.RegisterHandler(msg.HANDLE_TYPE_VAR_USER_GET, f.GetVarUserData)
 	f.RegisterHandler(msg.HANDLE_TYPE_VAR_USER_SET, f.SetVarUserData)
+
+	f.RegisterHandler(msg.HANDLE_TYPE_VAR_EXPIRE_SET, f.SetExpireVarData)
 }
 
 func (f *FriendMgr) getData() *FirendData {
@@ -161,6 +170,34 @@ func (f *FriendMgr) SetVarUserData(m *msg.Msg) (interface{}, error) {
 	}, nil
 }
 
+func (f *FriendMgr) SetExpireVarData(m *msg.Msg) (interface{}, error) {
+	VarOp := m.Extra.(VarOpration)
+	switch VarOp.Type {
+	case VAR_OP_CATNIP_LOCK:
+		data := VarOp.Data.(CatnipLock)
+		MyKey := GoUtil.GetCatnipLockKey(data.Uid, data.GameId)
+		OtherKey := GoUtil.GetCatnipLockKey(data.Partner, data.GameId)
+		ExpireData := G_GameLogicPtr.VarMgr.GetExpireVar(OtherKey)
+		if _, ok := ExpireData.D.(*CatnipLock); ok {
+			return nil, fmt.Errorf("catnip lock already exists for %d in game %d", data.Uid, data.GameId)
+		}
+		G_GameLogicPtr.VarMgr.SetExpireVar(MyKey, &VarExpireData{
+			T: int64(data.End + 24*3600), // 设置过期时间
+			D: &data,
+		})
+		G_GameLogicPtr.VarMgr.SetExpireVar(OtherKey, &VarExpireData{
+			T: int64(data.End + 24*3600), // 设置过期时间
+			D: &CatnipLock{
+				Uid:     data.Partner,
+				Partner: data.Uid,
+				GameId:  data.GameId,
+				End:     data.End,
+			},
+		})
+	}
+	return nil, nil
+}
+
 // 发送消息给玩家
 func sendToPlayer(m *msg.Msg) error {
 	p := G_GameLogicPtr.GetPlayer(int64(m.To))

src/server/game/GameLogic.go

@@ -288,6 +288,17 @@ func (ad *GameLogic) SetUserData(Uid int, Op int, Data interface{}) {
 	})
 }
 
+func (ad *GameLogic) SetDataSync(Uid int, Op int, Data interface{}) error {
+	_, err := ad.FriendMgr.Call(&MsgMod.Msg{
+		From:  Uid,
+		To:    Uid,
+		Type:  MsgMod.HANDLE_TYPE_VAR_EXPIRE_SET,
+		SendT: GoUtil.Now(),
+		Extra: VarOpration{Type: Op, Data: Data},
+	})
+	return err
+}
+
 func (ad *GameLogic) GetUserData(Uid int) *VarUserData {
 	result, err := ad.FriendMgr.Call(&MsgMod.Msg{
 		From:  Uid,
@@ -806,7 +817,15 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqRace", ReqRace)
 	RegisterMsgProcessFunc("ReqRaceReward", ReqRaceReward)
 	RegisterMsgProcessFunc("ReqRaceStart", ReqRaceStart)
-
+	// 猫草大作战
+	RegisterMsgProcessFunc("ReqCatnip", ReqCatnip)                       // 请求猫草大作战数据
+	RegisterMsgProcessFunc("ReqCatnipInvite", ReqCatnipInvite)           // 猫草大作战邀请好友
+	RegisterMsgProcessFunc("ReqCatnipAgree", ReqCatnipAgree)             // 同意邀请
+	RegisterMsgProcessFunc("ReqCatnipRefuse", ReqCatnipRefuse)           // 拒绝邀请
+	RegisterMsgProcessFunc("ReqCatnipMultiply", ReqCatnipMultiply)       // 猫草大作战倍数
+	RegisterMsgProcessFunc("ReqCatnipPlay", ReqCatnipPlay)               // 猫草大作战游戏转盘
+	RegisterMsgProcessFunc("ReqCatnipReward", ReqCatnipReward)           // 猫草大作战领取奖励
+	RegisterMsgProcessFunc("ReqCatnipGrandReward", ReqCatnipGrandReward) // 猫草大作战领取大奖
 	// #region playroom
 	RegisterMsgProcessFunc("ReqPlayroom", ReqPlayroom)                             // 请求playroom数据
 	RegisterMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo)                     // 请求playroom拜访信息
@@ -901,8 +920,8 @@ func NotifyPlayer(Uid int, m *MsgMod.Msg) {
 	p.Send(m)
 }
 
-func setRedisLock(key, value string, Duration time.Duration) bool {
+func setRedisLock(key string, Duration time.Duration) bool {
-	return db.RedisLock(key, "", Duration)
+	return db.RedisLock(key, "lock", Duration)
 }
 
 func getRedisLock(key string) error {

src/server/game/Gm.go

@@ -14,6 +14,7 @@ import (
 	mergeDataCfg "server/conf/mergeData"
 	playroomCfg "server/conf/playroom"
 	"server/db"
+	"server/game/mod/activity"
 	"server/game/mod/avatar"
 	"server/game/mod/card"
 	"server/game/mod/emoji"
@@ -249,19 +250,19 @@ func ReqGmCommand_(player *Player, Command string) error {
 	case "miningReload":
 		MiningMod := player.PlayMod.getMiningMod()
 		MiningMod.ZeroUpdate(-1)
-		ActivityInfo := GetActivityInfo(player, ACT_TYPE_MINING)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_MINING)
 		MiningMod.ZeroUpdate(ActivityInfo.Id)
 		MiningBackData(player)
 	case "guessColorReload":
 		GuessColorMod := player.PlayMod.getGuessColorMod()
 		GuessColorMod.ZeroUpdate(-1)
-		ActivityInfo := GetActivityInfo(player, ACT_TYPE_GUESS_COLOR)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_GUESS_COLOR)
 		GuessColorMod.ZeroUpdate(ActivityInfo.Id)
 		GuessColorBackData(player)
 	case "raceReload":
 		RaceMod := player.PlayMod.getRaceMod()
 		RaceMod.ZeroUpdate(-1)
-		ActivityInfo := GetActivityInfo(player, ACT_TYPE_RACE)
+		ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_RACE)
 		RaceMod.ZeroUpdate(ActivityInfo.Id)
 		RaceBackData(player)
 	case "raceAdd":

src/server/game/LimitedTimeTrigger.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"server/GoUtil"
-	baseCfg "server/conf/base"
 	playroomCfg "server/conf/playroom"
 	userCfg "server/conf/user"
 	"server/game/mod/card"
@@ -43,8 +42,6 @@ func LimitedTimeEventTrigger(p *Player, AddEventId int) {
 		case limitedTimeEvent.EVENT_TYPE_HIGH_ROLLER:
 			BaseMod := p.PlayMod.getBaseMod()
 			EnergyMul := BaseMod.GetEnergyMul()
-			MaxEnergyMul := baseCfg.GetMaxEnergyMul(BaseMod.GetLevel(), BaseMod.GetEnergy())
-			p.PlayMod.getBaseMod().ResetEnergyMul(MaxEnergyMul)
 			NewEnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
 			OrderMod := p.PlayMod.getOrderMod()
 			Lv := p.GetPlayerBaseMod().GetLevel()

src/server/game/MailMgr.go

@@ -6,6 +6,7 @@ import (
 	"server/db"
 	"server/game/mod/item"
 	"server/game/mod/msg"
+	"server/pkg/github.com/name5566/leaf/log"
 	"strings"
 )
 
@@ -60,7 +61,11 @@ func (m *MailMgr) AddMail(msg *msg.Msg) (interface{}, error) {
 func (r *MailMgr) LoadMail(msg *msg.Msg) (interface{}, error) {
 	// 从数据库加载邮件
 	data := make([]*db.SqlServerMailStruct, 0)
-	db.GetServerMailData(&data)
+	err := db.GetServerMailData(&data)
+	if err != nil {
+		log.Error("LoadMail error: %v", err)
+		return nil, err
+	}
 	for _, v := range data {
 		Uids := make([]int, 0)
 		UidArr := strings.Split(v.To_uids, ",")

src/server/game/Player.go

@@ -994,11 +994,11 @@ func (p *Player) GetRed(AI *ActivityInfo) int {
 		return 0
 	}
 	// 限时活动红点
-	if AI.Type == ACT_TYPE_MINING {
+	if AI.Type == activity.ACT_TYPE_MINING {
 		ItemId := miningCfg.GetActivityItemId(AI.Id)
 		return p.PlayMod.getItemMod().GetItem(ItemId)
 	}
-	if AI.Type == ACT_TYPE_GUESS_COLOR {
+	if AI.Type == activity.ACT_TYPE_GUESS_COLOR {
 		ItemId := guesscolorCfg.GetActivityItemId(AI.Id)
 		return p.PlayMod.getItemMod().GetItem(ItemId)
 	}

src/server/game/PlayerBack.go

@@ -103,6 +103,7 @@ func PlayroomBackData(p *Player) {
 
 func PlayroomVisit(p *Player, Uid int) {
 	if Uid == 0 {
+		p.PushClientRes(&proto.ResPlayroomInfo{})
 		return
 	}
 	PlayroomMod := p.PlayMod.getPlayroomMod()

src/server/game/PlayerFunc.go

@@ -16,6 +16,7 @@ import (
 	playroomCfg "server/conf/playroom"
 	userCfg "server/conf/user"
 	"server/db"
+	"server/game/mod/activity"
 	"server/game/mod/card"
 	"server/game/mod/friend"
 	"server/game/mod/item"
@@ -308,6 +309,42 @@ func handle(p *Player, m *msg.Msg) error {
 		p.PushClientRes(ChargeMod.BackData())
 	case msg.HANDLE_TYPE_PLAYROOM_KISS: // playroom亲吻
 		p.NotifyPlayroomKiss()
+	case msg.HANDLE_TYPE_CATNIP_INVITE:
+		CatnipMod := p.PlayMod.getCatnipMod()
+		CatnipMsg := m.Extra.(CatnipMsg)
+		ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
+		if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
+			return nil
+		}
+		CatnipMod.BeInvited(CatnipMsg.GameId, int(m.From), m.SendT)
+	case msg.HANDLE_TYPE_CATNIP_AGREE:
+		CatnipMod := p.PlayMod.getCatnipMod()
+		CatnipMsgInfo := m.Extra.(CatnipMsg)
+		ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
+		if ActivityId != CatnipMsgInfo.ActivityId { // 活动ID不匹配
+			return nil
+		}
+		UserList, _ := CatnipMod.Agree(CatnipMsgInfo.GameId, int(m.From))
+		for _, v := range UserList {
+			FriendMgrSend(&msg.Msg{
+				From: int(p.M_DwUin),
+				To:   int(v),
+				Type: msg.HANDLE_TYPE_CATNIP_AGREE,
+				Extra: CatnipMsg{
+					ActivityId: ActivityId,
+					GameId:     int(CatnipMsgInfo.GameId),
+				},
+				SendT: GoUtil.Now(),
+			})
+		}
+	case msg.HANDLE_TYPE_CATNIP_AGREE_DEL:
+		CatnipMod := p.PlayMod.getCatnipMod()
+		CatnipMsg := m.Extra.(CatnipMsg)
+		ActivityId := GetActivityId(p, activity.ACT_TYPE_CATNIP)
+		if ActivityId != CatnipMsg.ActivityId { // 活动ID不匹配
+			return nil
+		}
+		CatnipMod.DelInvited(CatnipMsg.GameId, int(m.From))
 	default:
 		log.Debug("uid : %d, handle msg type : %d not exist", p.M_DwUin, m.Type)
 	}

src/server/game/PlayerMod.go

@@ -9,6 +9,7 @@ import (
 	"server/game/mod/avatar"
 	"server/game/mod/base"
 	"server/game/mod/card"
+	"server/game/mod/catnip"
 	"server/game/mod/champship"
 	"server/game/mod/charge"
 	"server/game/mod/chess"
@@ -79,6 +80,7 @@ type PlayerModList struct {
 	Collect          collect.Collect                      // 收集
 	Activity         activity.Activity                    // 活动
 	Compensation     compensation.Compensation            // 补偿
+	Catnip           catnip.CatnipMod                     // 猫草大作战
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -176,6 +178,7 @@ func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	p.ModList.Emoji.InitData()
 	p.ModList.Collect.InitData()
 	p.ModList.Activity.InitData()
+	p.ModList.Catnip.InitData()
 	return is_update, nil
 }
 
@@ -366,3 +369,6 @@ func (p *PlayerMod) getActivityMod() *activity.Activity {
 func (p *PlayerMod) getCompensationMod() *compensation.Compensation {
 	return &p.mod_list.Compensation
 }
+func (p *PlayerMod) getCatnipMod() *catnip.CatnipMod {
+	return &p.mod_list.Catnip
+}

src/server/game/RegisterNetworkFunc.go

@@ -15,6 +15,7 @@ import (
 	playroomCfg "server/conf/playroom"
 	"server/db"
 	"server/game/internal"
+	"server/game/mod/activity"
 	"server/game/mod/card"
 	"server/game/mod/collect"
 	"server/game/mod/friend"
@@ -68,6 +69,7 @@ func ReqPlayerBriefProfileDataFunc(player *Player, buf []byte) error {
 		PicURL:      PlayerSimpleData.FaceBookPic,
 		ActiveTime:  int32(max(PlayerSimpleData.Loginout, PlayerSimpleData.Login)),
 		NickName:    PlayerSimpleData.Name,
+		SetEmoji:    GoUtil.MapIntToInt32(PlayerSimpleData.Emoji),
 	})
 	return nil
 }
@@ -2959,8 +2961,8 @@ func ReqMiningTake(player *Player, buf []byte) error {
 	req := &msg.ReqMiningTake{}
 	proto.Unmarshal(buf, req)
 	MiningMod := player.PlayMod.getMiningMod()
-	ActivityInfo := GetActivityInfo(player, ACT_TYPE_MINING)
+	ActivityInfo := GetActivityInfo(player, activity.ACT_TYPE_MINING)
-	Status := GetActivityStatus(player, ACT_TYPE_MINING)
+	Status := GetActivityStatus(player, activity.ACT_TYPE_MINING)
 	if Status != ACT_STATUS_START {
 		player.SendErrClienRes(&msg.ResMiningTake{
 			Code: msg.RES_CODE_FAIL,
@@ -2995,7 +2997,7 @@ func ReqMiningTake(player *Player, buf []byte) error {
 	}
 	player.TeLog("ReqMiningTake", map[string]interface{}{})
 	player.PlayMod.save()
-	player.NotifyRed(ACT_TYPE_MINING)
+	player.NotifyRed(activity.ACT_TYPE_MINING)
 	MiningBackData(player)
 	return nil
 }
@@ -3003,7 +3005,7 @@ func ReqMiningTake(player *Player, buf []byte) error {
 // 领取关卡奖励
 func ReqMiningReward(player *Player, buf []byte) error {
 	MiningMod := player.PlayMod.getMiningMod()
-	Status := GetActivityStatus(player, ACT_TYPE_MINING)
+	Status := GetActivityStatus(player, activity.ACT_TYPE_MINING)
 	if Status != ACT_STATUS_START {
 		player.SendErrClienRes(&msg.ResMiningReward{
 			Code: msg.RES_CODE_FAIL,
@@ -3058,7 +3060,7 @@ func ReqGuessColor(player *Player, buf []byte) error {
 func ReqGuessColorTake(player *Player, buf []byte) error {
 	req := &msg.ReqGuessColorTake{}
 	proto.Unmarshal(buf, req)
-	Status := GetActivityStatus(player, ACT_TYPE_GUESS_COLOR)
+	Status := GetActivityStatus(player, activity.ACT_TYPE_GUESS_COLOR)
 	if Status != ACT_STATUS_START {
 		player.SendErrClienRes(&msg.ResGuessColorTake{
 			Code: msg.RES_CODE_FAIL,
@@ -3083,7 +3085,7 @@ func ReqGuessColorTake(player *Player, buf []byte) error {
 	})
 	player.PlayMod.save()
 	GuessColorBackData(player)
-	player.NotifyRed(ACT_TYPE_GUESS_COLOR)
+	player.NotifyRed(activity.ACT_TYPE_GUESS_COLOR)
 	return nil
 }
 
@@ -3091,7 +3093,7 @@ func ReqGuessColorTake(player *Player, buf []byte) error {
 func ReqGuessColorReward(player *Player, buf []byte) error {
 	req := &msg.ReqGuessColorReward{}
 	proto.Unmarshal(buf, req)
-	Status := GetActivityStatus(player, ACT_TYPE_GUESS_COLOR)
+	Status := GetActivityStatus(player, activity.ACT_TYPE_GUESS_COLOR)
 	if Status != ACT_STATUS_START {
 		player.SendErrClienRes(&msg.ResGuessColorReward{
 			Code: msg.RES_CODE_FAIL,
@@ -3200,7 +3202,7 @@ func ReqPlayroomInfo(player *Player, buf []byte) error {
 		Targer = GetVisitorPlayer(player)
 	}
 	if Targer == 0 {
-		return fmt.Errorf("ReqPlayroomInfo no target")
+		PlayroomVisit(player, Targer)
 	}
 	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Targer)
 	PlayroomMod.SetTarget(Targer)
@@ -4680,3 +4682,228 @@ func ReqPlayroomGuide(player *Player, buf []byte) error {
 	})
 	return nil
 }
+
+func ReqCatnip(player *Player, buf []byte) error {
+	player.CatnipBackData()
+	return nil
+}
+
+// TODO : 猫草大作战邀请好友
+func ReqCatnipInvite(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipInvite{}
+	proto.Unmarshal(buf, req)
+	ActivityId := GetActivityId(player, activity.ACT_TYPE_MINING)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	err := CatnipMod.Invite(int(req.Id), int(req.Uid))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipInvite{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_invite", map[string]interface{}{
+		"Id": int(req.Id),
+	})
+	FriendMgrSend(&MsqMod.Msg{
+		From: int(player.M_DwUin),
+		To:   int(req.Uid),
+		Type: MsqMod.HANDLE_TYPE_CATNIP_INVITE,
+		Extra: CatnipMsg{
+			ActivityId: ActivityId,
+			GameId:     int(req.Id),
+		},
+		SendT: GoUtil.Now(),
+	})
+
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipInvite{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqCatnipAgree(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipAgree{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	ActivityId := GetActivityId(player, activity.ACT_TYPE_MINING)
+	UserList, err := CatnipMod.Agree(int(req.Id), int(req.Uid))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipAgree{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_agree", map[string]interface{}{
+		"Id": int(req.Id),
+	})
+	FriendMgrSend(&MsqMod.Msg{
+		From: int(player.M_DwUin),
+		To:   int(req.Uid),
+		Type: MsqMod.HANDLE_TYPE_CATNIP_AGREE,
+		Extra: CatnipMsg{
+			ActivityId: ActivityId,
+			GameId:     int(req.Id),
+		},
+		SendT: GoUtil.Now(),
+	})
+
+	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(req.Id),
+			},
+			SendT: GoUtil.Now(),
+		})
+	}
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipAgree{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+// TODO : 猫草大作战设置倍数
+func ReqCatnipMultiply(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipMultiply{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	err := CatnipMod.Multiply(int(req.Id), int(req.Multiply))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipMultiply{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_multiply", map[string]interface{}{
+		"Id": int(req.Id),
+	})
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipMultiply{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+// TODO : 猫草大作战开始游戏
+func ReqCatnipPlay(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipPlay{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	err := CatnipMod.Play(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipPlay{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_play", map[string]interface{}{
+		"Id": int(req.Id),
+	})
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipPlay{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+// TODO : 猫草大作战领取奖励
+func ReqCatnipReward(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipReward{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	Items, err := CatnipMod.Reward(int(req.Progress))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_CatnipReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_reward", map[string]interface{}{
+		"Items": Items,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqCatnipGrandReward(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipGrandReward{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	Items, err := CatnipMod.GrandReward()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipGrandReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, msg.ITEM_POP_LABEL_CatnipGrandReward.String())
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipGrandReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_grand_reward", map[string]interface{}{
+		"Items": Items,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipGrandReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqCatnipRefuse(player *Player, buf []byte) error {
+	req := &msg.ReqCatnipRefuse{}
+	proto.Unmarshal(buf, req)
+	CatnipMod := player.PlayMod.getCatnipMod()
+	err := CatnipMod.Refuse(int(req.Id), int(req.Uid))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResCatnipRefuse{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("catnip_refuse", map[string]interface{}{
+		"Id": int(req.Id),
+	})
+	FriendMgrSend(&MsqMod.Msg{
+		From:  int(player.M_DwUin),
+		To:    int(req.Uid),
+		Type:  MsqMod.HANDLE_TYPE_CATNIP_REFUSE,
+		SendT: GoUtil.Now(),
+		Extra: CatnipMsg{
+			ActivityId: GetActivityId(player, activity.ACT_TYPE_MINING),
+			GameId:     int(req.Id),
+		},
+	})
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResCatnipRefuse{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}

src/server/game/Type.go

@@ -48,18 +48,17 @@ type VarUserData struct {
 	Kiss   int
 }
 
+type VarExpireData struct {
+	D interface{}
+	T int64
+}
+
 const (
 	ACT_STATUS_NOT_START = 0
 	ACT_STATUS_START     = 1
 	ACT_STATUS_END       = 2
 )
 
-const (
-	ACT_TYPE_MINING      = 1 // 挖矿
-	ACT_TYPE_GUESS_COLOR = 2 // 猜颜色
-	ACT_TYPE_RACE        = 3 // 赛跑
-)
-
 type ActivityInfo struct {
 	StartT int64
 	EndT   int64
@@ -83,6 +82,18 @@ type GameResult struct {
 	Emoji int // 表情
 }
 
+type CatnipMsg struct {
+	ActivityId int
+	GameId     int
+}
+
+type CatnipLock struct {
+	Uid     int // 玩家ID
+	Partner int // 伙伴ID
+	GameId  int // 游戏ID
+	End     int
+}
+
 func init() {
 	gob.Register(&limitedTimeEvent.MoneyCat{})
 	gob.Register(&limitedTimeEvent.LuckyCat{})
@@ -93,4 +104,6 @@ func init() {
 	gob.Register(&ActivityInfo{})
 	gob.Register(&ChargeExtra{})
 	gob.Register(&GameResult{})
+	gob.Register(&CatnipMsg{})
+	gob.Register(&CatnipLock{})
 }

src/server/game/VarMgr.go

@@ -13,9 +13,10 @@ type VarMgr struct {
 }
 
 type VarData struct {
-	Var      map[string]interface{}
+	Var       map[string]interface{}
-	UserVar  map[string]*VarUserData
+	VarExpire map[string]*VarExpireData
-	ZeroTime int64
+	UserVar   map[string]*VarUserData
+	ZeroTime  int64
 }
 
 const (
@@ -25,10 +26,11 @@ const (
 )
 
 const (
-	VAR_OP_UPVOTE   = 1
+	VAR_OP_UPVOTE      = 1
-	VAR_OP_CHIP     = 2
+	VAR_OP_CHIP        = 2
-	VAR_OP_KISS     = 3
+	VAR_OP_KISS        = 3
-	VAR_OP_CHIP_SET = 4
+	VAR_OP_CHIP_SET    = 4
+	VAR_OP_CATNIP_LOCK = 5
 )
 
 func (f *VarMgr) Init() {
@@ -69,6 +71,11 @@ func (f *VarMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
 		Four: Card1,
 		Five: Card2,
 	})
+	for k, v := range f.getData().VarExpire {
+		if v.T < GoUtil.ZeroTimestamp() {
+			delete(f.getData().VarExpire, k)
+		}
+	}
 	return nil, nil
 }
 
@@ -80,6 +87,19 @@ func (f *VarMgr) GetVar(key string) interface{} {
 	return f.getData().Var[key]
 }
 
+func (f *VarMgr) SetExpireVar(key string, value *VarExpireData) {
+	f.getData().VarExpire[key] = value
+}
+
+func (f *VarMgr) GetExpireVar(key string) *VarExpireData {
+	if v, ok := f.getData().VarExpire[key]; ok {
+		return v
+	}
+	data := &VarExpireData{}
+	f.getData().VarExpire[key] = data
+	return data
+}
+
 func (f *VarMgr) SetUserVar(key string, value *VarUserData) {
 	f.getData().UserVar[key] = value
 }

src/server/game/admin.go

@@ -181,6 +181,7 @@ func ReqServerInfo(args []interface{}) error {
 func ReqReloadServerMail(args []interface{}) error {
 	G_GameLogicPtr.MailMgrCall(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL_RELOAD})
 	G_GameLogicPtr.NotifyAll(&Msg.Msg{Type: Msg.HANDLE_TYPE_MAIL})
+	log.Debug("ReqReloadServerMail success")
 	return nil
 }
 

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

@@ -22,6 +22,7 @@ const (
 	ACT_TYPE_DISCOUNT_GIFT = 4 // 折扣礼包
 	ACT_TYPE_ADD_GIFT      = 5 // 加送礼包
 	ACT_TYPE_SUPER_GIFT    = 6 // 超值加购礼包
+	ACT_TYPE_CATNIP        = 7 // 猫草大作战
 )
 
 const (

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

@@ -0,0 +1,206 @@
+package catnip
+
+import (
+	"fmt"
+	"server/GoUtil"
+	catnipCfg "server/conf/catnip"
+	"server/game/mod/item"
+)
+
+type CatnipMod struct {
+	Id            int
+	Game          map[int]*CatnipGame
+	InviteList    map[int][]*InviteInfo // 邀请列表，key: 邀请者ID, value: 被邀请者ID
+	BeInvitedList map[int][]*InviteInfo // 被邀请列表，key: 被邀请者ID, value: 邀请者ID
+}
+
+type InviteInfo struct {
+	InviteId int   // 邀请者ID
+	Time     int64 // 邀请时间
+}
+
+type CatnipGame struct {
+	Id         int   // 游戏ID
+	Partner    int   // 伙伴ID
+	Progress   int   // 进度
+	PartnerAdd int   // 伙伴贡献
+	Reward     []int // 已领取阶段奖励
+	Mul        int   // 倍数
+	Status     int   // 0: Not Started, 1: In Progress, 2: Completed
+}
+
+const (
+	GAME_STATUS_IDLE        = 0 // 游戏未开始
+	GAME_STATUS_IN_PROGRESS = 1 // 游戏进行中
+	GAME_STATUS_COMPLETED   = 2 // 游戏已完成
+)
+
+func (c *CatnipMod) InitData() {
+	// Initialize Catnip data here
+	if c.Game == nil {
+		c.Game = make(map[int]*CatnipGame)
+	}
+	if c.InviteList == nil {
+		c.InviteList = make(map[int][]*InviteInfo)
+	}
+	if c.BeInvitedList == nil {
+		c.BeInvitedList = make(map[int][]*InviteInfo)
+	}
+}
+
+func (c *CatnipMod) Login(Id int) int {
+	OldId := c.Id
+	if Id == 0 {
+		c.Id = 0
+		return OldId
+	}
+	if c.Id == Id {
+		return 0
+	}
+	c.Id = Id
+	c.Game = make(map[int]*CatnipGame)
+	GameNum := catnipCfg.GetGameNum(c.Id) // Assuming 1 is the default game ID
+	for i := 1; i <= GameNum; i++ {
+		c.Game[i] = &CatnipGame{
+			Id:       i,
+			Partner:  0,                // No partner initially
+			Progress: 0,                // Initial progress
+			Status:   GAME_STATUS_IDLE, // Not started
+		}
+	}
+	return c.Id
+}
+
+func (c *CatnipMod) ZeroUpdate(Id int) {
+	c.Login(Id)
+}
+
+func (c *CatnipMod) Invite(Id, Uid int) error {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	if GameInfo.Status != 0 {
+		return fmt.Errorf("game with ID %d is already in progress or completed", Id)
+	}
+	for _, invite := range c.InviteList[Id] {
+		if invite.InviteId == Uid {
+			return fmt.Errorf("user with ID %d is already invited to game ID %d", Uid, Id)
+		}
+	}
+	c.InviteList[Id] = append(c.InviteList[Id], &InviteInfo{
+		InviteId: Uid,
+		Time:     GoUtil.Now(),
+	})
+	return nil
+}
+
+func (c *CatnipMod) BeInvited(Id, Uid int, Time int64) error {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	if GameInfo.Status != GAME_STATUS_IDLE {
+		return fmt.Errorf("game with ID %d is already in progress or completed", Id)
+	}
+	// Check if the user is already invited
+	for _, invite := range c.BeInvitedList[Uid] {
+		if invite.InviteId == Id {
+			return fmt.Errorf("user with ID %d has already been invited to game ID %d", Uid, Id)
+		}
+	}
+	c.BeInvitedList[Uid] = append(c.BeInvitedList[Uid], &InviteInfo{
+		InviteId: Id,
+		Time:     Time,
+	})
+	return nil
+}
+
+func (c *CatnipMod) Agree(Id, Uid int) ([]int, error) {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return nil, fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	if GameInfo.Status != GAME_STATUS_IDLE {
+		return nil, fmt.Errorf("game with ID %d is already in progress or completed", Id)
+	}
+	// Check if the user is in the invite list
+	inviteList, exists := c.InviteList[Id]
+	if !exists {
+		return nil, fmt.Errorf("no invites found for game ID %d", Id)
+	}
+	userExists := false
+	InviteUser := []int{}
+	for _, invite := range inviteList {
+		if invite.InviteId == Uid {
+			userExists = true
+			continue
+		}
+		InviteUser = append(InviteUser, invite.InviteId)
+
+	}
+	if !userExists {
+		return nil, fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
+	}
+	c.InviteList[Id] = make([]*InviteInfo, 0) // Clear the invite list after agreeing
+	GameInfo.Partner = Uid                    // Set the partner for the game
+	GameInfo.Status = GAME_STATUS_COMPLETED   // Set the game status to in progress
+	return InviteUser, nil
+}
+
+func (c *CatnipMod) DelInvited(Id, Uid int) error {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	if GameInfo.Status != GAME_STATUS_IDLE {
+		return fmt.Errorf("game with ID %d is already in progress or completed", Id)
+	}
+	for k, invite := range c.BeInvitedList[Id] {
+		if invite.InviteId == Uid {
+			// Remove the invite from the list
+			c.BeInvitedList[Id] = append(c.InviteList[Id][:k], c.InviteList[Id][k+1:]...)
+			return nil
+		}
+	}
+	return fmt.Errorf("user with ID %d is not invited to game ID %d", Uid, Id)
+}
+
+func (c *CatnipMod) Multiply(Id, Mul int) error {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	GameInfo.Mul = Mul
+	return nil
+}
+
+func (c *CatnipMod) Refuse(Id, Uid int) error {
+	GameInfo, ok := c.Game[Id]
+	if !ok {
+		return fmt.Errorf("game with ID %d does not exist", Id)
+	}
+	if GameInfo.Status != GAME_STATUS_IDLE {
+		return fmt.Errorf("game with ID %d is already in progress or completed", Id)
+	}
+	for k, invite := range c.InviteList[Id] {
+		if invite.InviteId == Uid {
+			// Remove the invite from the list
+			c.InviteList[Id] = append(c.InviteList[Id][:k], c.InviteList[Id][k+1:]...)
+			return nil
+		}
+	}
+	return nil
+}
+
+func (c *CatnipMod) Play(Id int) error {
+	return nil
+}
+
+func (c *CatnipMod) Reward(Id int) ([]*item.Item, error) {
+	return nil, nil
+}
+
+func (c *CatnipMod) GrandReward() ([]*item.Item, error) {
+	return nil, nil
+}

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

@@ -32,14 +32,19 @@ func (f *FaceMod) InitData() {
 	if f.List == nil || !f.Init {
 		f.Init = true
 		f.List = make(map[int]*Face)
-		InitId := faceCfg.GetInitList()
+
-		for _, v := range InitId {
-			f.List[v] = &Face{
-				AddTime: now,
-			}
-		}
 		f.SetId = 1
 	}
+	InitId := faceCfg.GetInitList()
+	for _, v := range InitId {
+		if _, ok := f.List[v]; ok {
+			continue
+		}
+		// 初始化表情
+		f.List[v] = &Face{
+			AddTime: now,
+		}
+	}
 }
 
 func (f *FaceMod) GetFaceNum() int {

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

@@ -295,7 +295,12 @@ func (l *LimitedTimeEventMod) GetChestReward(MergeList []int) []*item.Item {
 func (l *LimitedTimeEventMod) GetSceneDashReward() (int, []*item.Item) {
 	ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
 	Id := GoUtil.RandMap(ProbList)
-	return Id, limitedTimeEventCfg.GetSenceJackpotReward(Id)
+	Items := limitedTimeEventCfg.GetSenceJackpotReward(Id)
+	if len(Items) > 1 {
+		// 多个奖励时，随机选择一个
+		Items = []*item.Item{GoUtil.RandItem(Items)}
+	}
+	return Id, Items
 }
 
 // 获取连击快手奖励

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

@@ -93,6 +93,17 @@ const (
 
 	HANDLE_TYPE_PLAYROOM_KISS // playroom亲吻
 	HANDLE_TYPE_PLAYROOM_GAME // playroom游戏
+
+	HANDLE_TYPE_CATNIP_INVITE    // 猫薄荷邀请
+	HANDLE_TYPE_CATNIP_AGREE     // 猫薄荷同意邀请
+	HANDLE_TYPE_CATNIP_AGREE_DEL // 猫薄荷已同意邀请
+	HANDLE_TYPE_CATNIP_REFUSE    // 猫薄荷拒绝邀请
+	HANDLE_TYPE_CATNIP_GROWTH    // 猫薄荷成长
+
+	HANDLE_TYPE_CATNIP_LOCK // 猫薄荷游戏锁定
+
+	HANDLE_TYPE_VAR_EXPIRE_SET // 设置全服过期数据
+	HANDLE_TYPE_VAR_EXPIRE_GET // 获取全服过期数据
 )
 
 const (