宠物宝藏

src/server/GoUtil/sliceUtil.go

@@ -210,3 +210,11 @@ func SliceEqual(a, b []int) bool {
 	}
 	return true
 }
+
+func InitNumSlice(start, end int) []int {
+	result := make([]int, 0, end-start+1)
+	for i := start; i <= end; i++ {
+		result = append(result, i)
+	}
+	return result
+}

src/server/conf/card/CardCfg.go

@@ -62,13 +62,17 @@ func GetPackMustHave(Star int) int {
 }
 
 // 根据星级获取卡牌列表
-func GetCardListByStar(Star, IsGold int) []int {
+func GetCardListByStar(Round, Star, IsGold int) []int {
 	var CardList []int
 	data, err := gamedata.GetData(CARD_DETAIL_CFG_NAME)
 	if err != nil {
 		log.Debug("GetCardListByStar data not found")
 	}
 	for k, v := range data {
+		Extra := gamedata.GetIntValue(v, "Round")
+		if Round < Extra {
+			continue
+		}
 		vStar := gamedata.GetIntValue(v, "Star")
 		isGold := gamedata.GetIntValue(v, "IsGold")
 		if vStar == Star && IsGold == isGold {
@@ -139,14 +143,18 @@ func GetCardListByColor(Id int) []int {
 }
 
 // 获取所有卡牌id
-func GetAllCardId() []int {
+func GetAllCardId(Round int) []int {
 	data, err := gamedata.GetData(CARD_DETAIL_CFG_NAME)
 	if err != nil {
 		log.Debug("GetCardListByColor data not found")
 		return []int{}
 	}
 	var r []int
-	for k := range data {
+	for k, v := range data {
+		Extra := gamedata.GetIntValue(v, "Round")
+		if Round < Extra {
+			continue
+		}
 		k1, _ := strconv.Atoi(k)
 		r = append(r, k1)
 	}

src/server/conf/friendTreasure/friendTreasureCfg.go

@@ -0,0 +1,77 @@
+package friendTreasureCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_FRIEND_TREASURE_PROB  = "FriendTreasureProb"
+	CFG_FRIEND_TREASURE_CHEST = "FriendTreasureChest"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_FRIEND_TREASURE_PROB)
+	gamedata.InitCfg(CFG_FRIEND_TREASURE_CHEST)
+}
+
+func GetFriendTreasureProb(Num int) map[int]int {
+	data, err := gamedata.GetData(CFG_FRIEND_TREASURE_PROB)
+	if err != nil {
+		return nil
+	}
+	ProbMap := make(map[int]int)
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		Prob := gamedata.GetIntValue(v, "Prob")
+		ProbMap[Id] = Prob
+	}
+	AddProb := 0
+	n := 0
+	for k, v := range ProbMap {
+		if k > Num {
+			AddProb += v
+			n++
+			ProbMap[k] = 0
+		}
+	}
+	PerProb := AddProb / n
+	for k, v := range ProbMap {
+		if k <= Num && k != 1 {
+			ProbMap[k] = v + PerProb
+		}
+	}
+	return ProbMap
+}
+
+func GetProbAdd(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_FRIEND_TREASURE_PROB, Id)
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Add")
+}
+
+func GetChestProb() map[int]int {
+	data, err := gamedata.GetData(CFG_FRIEND_TREASURE_CHEST)
+	if err != nil {
+		return nil
+	}
+	ProbMap := make(map[int]int)
+	for k, v := range data {
+		Id := GoUtil.Int(k)
+		Prob := gamedata.GetIntValue(v, "Prob")
+		ProbMap[Id] = Prob
+	}
+	return ProbMap
+}
+
+func GetChestItems(Id int) []*item.Item {
+	data, err := gamedata.GetDataByIntKey(CFG_FRIEND_TREASURE_CHEST, Id)
+	if err != nil {
+		return nil
+	}
+
+	return gamedata.GetItemList(data, "Items")
+}

src/server/conf/json.go

@@ -47,7 +47,7 @@ var Server struct {
 
 func init() {
 	filePath := "conf/server.json"
-	if len(os.Args) > 1 {
+	if len(os.Args) == 2 {
 		if os.Args[1] != "" {
 			filePath = os.Args[1]
 		}

src/server/conf/mergeData/MergeDataCfg.go

@@ -245,15 +245,6 @@ func GetExtraEmitId() map[string]struct{} {
 	return r
 }
 
-func GetProductType(Chess int) int {
-	data, err := gamedata.GetDataByIntKey(CFG_NAME, Chess)
-	if err != nil {
-		log.Debug("GetProductType GetOne Id:%v not found", Chess)
-		return 0
-	}
-	return gamedata.ParseInt(data["PType"])
-}
-
 func GetChessBagMaxGrid() int {
 	return GetConstInt("chess_bag_max")
 }

src/server/conf/server.json

@@ -28,7 +28,6 @@
 	"RedisPort" :"6379",
 	"RedisPwd"  :"",
 	
-	"RemoteAddr":"host.docker.internal:9001",
-	"ListenAddr": ":9001",
-	"CenterAddr": ":9000"
+	"RemoteAddr":"host.docker.internal:9001"
+	
 }

src/server/game/FriendMgr.go

@@ -26,7 +26,6 @@ func (f *FriendMgr) Init() {
 	gob.Register(card.CardInfo{})
 	gob.Register(item.Item{})
 	gob.Register([]*item.Item{}) // 注册 []*item.Item 类型
-	gob.Register(msg.Msg{})      // 注册 msg.Msg 类型
 
 	f.key = FRIEND_MGR_KEY
 	f.data = &FirendData{
@@ -62,7 +61,7 @@ func (f *FriendMgr) Init() {
 	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE_EX_CARD, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_SEND_CARD, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_PLAYROOM_LOSE, f.sendToPlayer)
-
+	f.RegisterHandler(msg.FRIEND_TREASURE_HANDLE, f.sendToPlayer)
 }
 
 func (f *FriendMgr) getData() *FirendData {

src/server/game/GameLogic.go

@@ -801,6 +801,11 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqPlayroomOutline", ReqPlayroomOutline)           // 打工离线
 	RegisterMsgProcessFunc("ReqPlayroomWrokOutline", ReqPlayroomWrokOutline)   // 打工离线完成
 
+	// 宠物宝藏
+	RegisterMsgProcessFunc("ReqFriendTreasure", ReqFriendTreasure)           // 请求好友宝藏数据
+	RegisterMsgProcessFunc("ReqFriendTreasureStart", ReqFriendTreasureStart) // 开始挖宝
+	RegisterMsgProcessFunc("ReqFriendTreasureFilp", ReqFriendTreasureFilp)   // 挖宝
+	RegisterMsgProcessFunc("ReqFriendTreasureEnd", ReqFriendTreasureEnd)     // 挖宝
 }
 
 func (ad *GameLogic) CreateHttpManager() {

src/server/game/Gm.go

@@ -1,12 +1,17 @@
 package game
 
 import (
+	"fmt"
+	"server/GoUtil"
+	cardCfg "server/conf/card"
 	playroomCfg "server/conf/playroom"
+	"server/db"
 	"server/game/mod/card"
 	"server/game/mod/item"
 	MsgMod "server/game/mod/msg"
 	"server/game/mod/playroom"
 	"server/msg"
+	"server/pkg/github.com/name5566/leaf/log"
 	"strconv"
 	"strings"
 
@@ -18,6 +23,7 @@ func ReqGmCommand(args []interface{}) error {
 	detail := &msg.ReqGmCommand{}
 	proto.Unmarshal(buf, detail)
 	arg := strings.Split(detail.Command, " ")
+	log.Debug("Player %d ReqGmCommand:%v", player.M_DwUin, arg)
 	switch arg[0] {
 	case "additem":
 		id, _ := strconv.Atoi(arg[1])
@@ -166,6 +172,30 @@ func ReqGmCommand(args []interface{}) error {
 		a := player.GetAgent()
 		a.Close()
 		player.ClearData()
+	case "addFriend":
+		FriendMod := player.PlayMod.getFriendMod()
+		Uid, _ := strconv.Atoi(arg[1])
+		FriendMod.AddFriend(Uid)
+	case "addAddCard":
+		CardMod := player.PlayMod.getCardMod()
+		CardList := cardCfg.GetAllCardId(CardMod.Round)
+		for _, v := range CardList {
+			CardMod.AddCard(v)
+		}
+	case "resetRankUser":
+		O := G_GameLogicPtr.RankMgr.getAllRank(RANK_TYPE_USER)
+		for _, v := range O {
+			Uid := strconv.Itoa(v.Uid)
+			TimeSort := fmt.Sprintf("0.%d", RANK_TIME_SORT-GoUtil.Now())
+			TimeSortF, _ := strconv.ParseFloat(TimeSort, 64)
+			db.RedisZAdd(RANK_USER, Uid, v.Score+TimeSortF)
+		}
+	case "setDecorateArea":
+		S, _ := strconv.Atoi(arg[1])
+		DecorateMod := player.PlayMod.getDecorateMod()
+		DecorateMod.AreaId = S
+		DecorateMod.FinishList = make(map[int]struct{})
+		DecorateMod.Progress = 0
 	}
 	player.PlayMod.save()
 	return nil

src/server/game/Player.go

@@ -682,8 +682,7 @@ func (p *Player) LoginBackData() {
 	BackUserInfo(p)
 }
 
-// 获取玩家简单数据
-func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
+func (p *Player) InitPlayerOnly() {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 	p.Msg = make(map[string]PlayerMsg)
@@ -696,9 +695,9 @@ func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
 	p.playerdata[PLAYER_BASE_DATA] = Base
 
 	// 玩家基础数据
-	ok := Base.GetDataByUid(Uid)
+	ok := Base.GetDataByUid(p.M_DwUin)
 	if !ok {
-		return errors.New("load PlayerBaseData failed")
+		return
 	}
 	p.playerdata[PLAYER_BASE_DATA] = Base
 	p.M_DwUin = Base.Data.DwUin
@@ -707,10 +706,17 @@ func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
 	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
 	ok = modData.LoadDataFromDB(Base.Data.DwUin)
 	if !ok {
-		return errors.New("load PlayerModData failed")
+		return
 	}
 	modData.InitMod()
 	p.PlayMod.mod_list = modData.ModList
+}
+
+// 获取玩家简单数据
+func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
+	p.M_DwUin = int32(Uid)
+	p.InitPlayerOnly()
+	Base := p.GetPlayerBaseMod()
 	simple.Name = p.GetPlayerBaseMod().GetName()
 	simple.Avatar = p.PlayMod.getAvatarMod().SetId
 	simple.Face = p.PlayMod.getFaceMod().SetId

src/server/game/PlayerBaseMod.go

@@ -708,7 +708,7 @@ func (p *PlayerBaseData) GetDataByUid(Uid interface{}) bool {
 	sqlStr := "SELECT * FROM t_player_baseinfo WHERE dwUin = ?"
 	sqlStruck := db.ResPlayerBaseInfo{}
 	if err := db.SqlDb.Get(&sqlStruck, sqlStr, Uid); err != nil {
-		log.Debug("get data failed, err:%v\n", err)
+		// log.Debug("get data failed, err:%v\n", err)
 		return false
 	}
 

src/server/game/PlayerFunc.go

@@ -230,7 +230,14 @@ func handle(p *Player, m *msg.Msg) error {
 		p.UpdateUserInfo()
 		p.Kafka(PLAYROOM_LOST, map[string]interface{}{"uid": m.From})
 		p.PushClientRes(PlayroomMod.NotifyLose())
+	case msg.FRIEND_TREASURE_HANDLE: // #  好友宝藏
+		Items := make([]*item.Item, 0)
+		if m.Extra != nil {
+			Items = m.Extra.([]*item.Item)
+		}
+		p.HandleItem(Items, "")
 	}
+	// #region 以下是处理系统请求
 	return nil
 }
 

src/server/game/PlayerMod.go

@@ -16,6 +16,7 @@ import (
 	"server/game/mod/endless"
 	"server/game/mod/face"
 	"server/game/mod/friend"
+	"server/game/mod/friendTreasure.go"
 	guesscolor "server/game/mod/guessColor"
 	"server/game/mod/guild"
 	"server/game/mod/handbook"
@@ -69,6 +70,7 @@ type PlayerModList struct {
 	GuessColor       guesscolor.GuessColorMod             // 猜颜色活动
 	Race             race.RaceMod                         // 竞赛活动
 	Playroom         playroom.PlayroomMod                 // 玩家小屋
+	FriendTreasure   friendTreasure.FriendTreasureMod     // 好友宝藏
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -322,3 +324,7 @@ func (p *PlayerMod) getRaceMod() *race.RaceMod {
 func (p *PlayerMod) getPlayroomMod() *playroom.PlayroomMod {
 	return &p.mod_list.Playroom
 }
+
+func (p *PlayerMod) getFriendTreasureMod() *friendTreasure.FriendTreasureMod {
+	return &p.mod_list.FriendTreasure
+}

src/server/game/RankMgr.go

@@ -184,9 +184,9 @@ func (r *RankMgr) inRank(m *msg.Msg) (interface{}, error) {
 }
 
 func (r *RankMgr) ClearRank(RankType int) {
-	if RankType == RANK_TYPE_GLOBAL {
-		db.RedisDel(RANK_USER)
-		return
-	}
+	// if RankType == RANK_TYPE_GLOBAL {
+	// 	db.RedisDel(RANK_USER)
+	// 	return
+	// }
 	r.setRank(RankType, []*Rank{})
 }

src/server/game/RegisterNetworkFunc.go

@@ -328,7 +328,9 @@ func ReqRewardOrder(args []interface{}) error {
 		})
 		return err
 	}
-
+	FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+	FriendTreasureMod.AddStar(Star / 10)
+	player.PushClientRes(FriendTreasureMod.NotifyStar())
 	// 限时事件增加进度
 	LimitedTimeEventMod.AddProgress(player.GetPlayerBaseMod().GetLevel())
 	player.HandleInChampshipRank()
@@ -3161,3 +3163,149 @@ func ReqPlayroomWrokOutline(args []interface{}) error {
 	})
 	return nil
 }
+
+func ReqFriendTreasure(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	TreasureInfoList := make([]*msg.TreasureInfo, 0)
+	FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+	for _, v := range FriendTreasureMod.GameFriend {
+		TreasureInfoList = append(TreasureInfoList, v)
+	}
+
+	player.PushClientRes(&msg.ResFriendTreasure{
+		Status: int32(FriendTreasureMod.Status),
+		List:   TreasureInfoList,
+		List2:  FriendTreasureMod.SelectF,
+		Star:   int32(FriendTreasureMod.Star),
+		Shift:  int32(FriendTreasureMod.Shift),
+	})
+	return nil
+}
+
+func ReqFriendTreasureStart(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqFriendTreasureStart{}
+	proto.Unmarshal(buf, req)
+	// FriendMod := player.PlayMod.getFriendMod()
+	FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+	if FriendTreasureMod.Status == 1 {
+		player.SendErrClienRes(&msg.ResFriendTreasureStart{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "game not over",
+		})
+		return fmt.Errorf("game not over")
+	}
+
+	if FriendTreasureMod.Star < 100 {
+		player.SendErrClienRes(&msg.ResFriendTreasureStart{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "not enough star",
+		})
+		return fmt.Errorf("not enough star")
+	}
+
+	// FriendList := FriendMod.GetFriendList()
+	// FriendList2 := GoUtil.SubSlices(FriendList, FriendTreasureMod.GetFriendList())
+	// if len(FriendList2) < 5 {
+	// 	player.SendErrClienRes(&msg.ResFriendTreasureStart{
+	// 		Code: msg.RES_CODE_FAIL,
+	// 		Msg:  "not enough friends",
+	// 	})
+	// 	return fmt.Errorf("not enough friends")
+	// }
+
+	// Alive := make([]int, 0)
+	// NotAlive := make([]int, 0)
+	// Now := GoUtil.Now()
+	// for _, v := range FriendList2 {
+	// 	PD := G_GameLogicPtr.GetSimplePlayerByUid(v)
+	// 	if PD.Login < Now-86400 {
+	// 		NotAlive = append(NotAlive, v)
+	// 	} else {
+	// 		Alive = append(Alive, v)
+	// 	}
+	// }
+
+	FriendTreasureMod.InitGame(req.List, req.List2)
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTreasureStart{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqFriendTreasureFilp(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqFriendTreasureFilp{}
+	proto.Unmarshal(buf, req)
+	FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+	Items, err := FriendTreasureMod.Flip(int(req.Pos))
+	if err != nil {
+		player.SendErrClienRes(
+			&msg.ResFriendTreasureFilp{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			},
+		)
+		return err
+	}
+
+	err = player.HandleItem(Items, "FriendTreasureFilp")
+	if err != nil {
+		player.SendErrClienRes(
+			&msg.ResFriendTreasureFilp{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			},
+		)
+		return err
+	}
+
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTreasureFilp{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqFriendTreasureEnd(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	FriendTreasureMod := player.PlayMod.getFriendTreasureMod()
+	Items, FriendItemNum, err := FriendTreasureMod.EndGame()
+	if err != nil {
+		player.SendErrClienRes(
+			&msg.ResFriendTreasureEnd{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			},
+		)
+		return err
+	}
+	for _, v := range FriendTreasureMod.GameFriend {
+		if v.Status != 1 {
+			continue
+		}
+		G_GameLogicPtr.FriendMgrSend(&MsqMod.Msg{
+			From:  int(player.M_DwUin),
+			To:    int(v.Uid),
+			Type:  MsqMod.FRIEND_TREASURE_HANDLE,
+			SendT: GoUtil.Now(),
+			Extra: []*item.Item{item.NewItem(item.ITEM_STAR_ID, FriendItemNum)},
+		})
+	}
+	err = player.HandleItem(Items, "FriendTreasureEnd")
+	if err != nil {
+		player.SendErrClienRes(
+			&msg.ResFriendTreasureEnd{
+				Code: msg.RES_CODE_FAIL,
+				Msg:  err.Error(),
+			},
+		)
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(&msg.ResFriendTreasureEnd{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}

src/server/game/UnitTest.go

@@ -79,3 +79,13 @@ func UnitSevenMonthReward(p *Player) error {
 	fmt.Print(i)
 	return nil
 }
+
+func UnitAllCard(p *Player) error {
+	CardMod := p.PlayMod.getCardMod()
+	Item, err := CardMod.OpenCardPack(5)
+	if err != nil {
+		return err
+	}
+	fmt.Print(Item)
+	return nil
+}

src/server/game/admin.go

@@ -0,0 +1,54 @@
+package game
+
+import (
+	"encoding/json"
+	"server/msg"
+	"server/pkg/github.com/name5566/leaf/gate"
+	"server/pkg/github.com/name5566/leaf/log"
+
+	"google.golang.org/protobuf/proto"
+)
+
+var AdminFuncMap = map[string]func([]interface{}) error{
+	"ReqAdminInfo": AdminPlayerInfo,
+}
+
+func AdminProcess(Func string, args []interface{}) {
+	if f, ok := AdminFuncMap[Func]; ok {
+		err := f(args)
+		if err != nil {
+			log.Debug("AdminProcess error: %v", err)
+		}
+		return
+	}
+	log.Debug("AdminProcess error: %v", "Func not found")
+}
+
+func AdminPlayerInfo(args []interface{}) error {
+	a, buf := ParseAdminArgs(args)
+	req := &msg.ReqAdminInfo{}
+	proto.Unmarshal(buf, req)
+	player := G_GameLogicPtr.GetPlayer(req.Uid)
+	if player == nil {
+		player = new(Player)
+		player.M_DwUin = req.Uid
+		player.InitPlayerOnly()
+	}
+	res := make(map[string]interface{})
+	res["Name"] = player.PlayMod.getBaseMod().NickName
+	res["Decorate"] = player.PlayMod.getDecorateMod().DecorateNum
+	res["ChargeMoney"] = player.PlayMod.getChargeMod().Charge
+	JsonBuff, err := json.Marshal(res)
+	if err != nil {
+		return err
+	}
+	AdminPlayerBack(a, JsonBuff)
+	return nil
+}
+
+func AdminPlayerBack(a gate.Agent, buf []byte) {
+	response := &msg.AdminRes{}
+	response.Func = "admin"
+	response.Info = buf
+	a.WriteMsg(response)
+}

src/server/game/common.go

@@ -22,6 +22,13 @@ func ParseArgs(args []interface{}) (gate.Agent, *Player, []byte) {
 	return a, player, buf
 }
 
+// 解析参数
+func ParseAdminArgs(args []interface{}) (gate.Agent, []byte) {
+	a := args[0].(gate.Agent)
+	buf := args[1].([]byte)
+	return a, buf
+}
+
 // 获取结构体名称
 func GetStructName(v interface{}) string {
 	t := reflect.TypeOf(v)

src/server/game/external.go

@@ -29,6 +29,7 @@ func handler(m interface{}, h interface{}) {
 
 func RegisterHandlerRPC(param []interface{}) {
 	handler(&msg.ClientReq{}, HandleClientReq)
+	handler(&msg.AdminReq{}, HandleAdminReq)
 }
 
 func init() {
@@ -39,6 +40,15 @@ func init() {
 	G_getGameLogic()
 }
 
+func HandleAdminReq(args []interface{}) {
+	m := args[0].(*msg.AdminReq)
+	// 消息的发送者
+	a := args[1].(gate.Agent)
+	buf := m.GetInfo()
+	log.Debug("admin 消息Func : %s", m.GetFunc())
+	AdminProcess(m.GetFunc(), []interface{}{a, buf})
+}
+
 func HandleClientReq(args []interface{}) {
 	if G_GameLogicPtr.SeverInfo.Status == SERVER_STATUS_CLOSE || G_GameLogicPtr.SeverInfo.Status == SERVER_STATUS_MAINTAIN {
 		return // 服务器关闭或者维护中，不处理任何消息
@@ -47,9 +57,11 @@ func HandleClientReq(args []interface{}) {
 	// 消息的发送者
 	a := args[1].(gate.Agent)
 	buf := m.GetInfo()
-	// log.Debug("消息Func : %s", m.GetFunc())
+	log.Debug("消息Func : %s", m.GetFunc())
 	switch m.GetFunc() {
 	case "ClientTick":
+	case "ReqAdminInfo":
+		AdminProcess(m.GetFunc(), []interface{}{a, buf})
 	case "ReqServerVersion":
 		G_GameLogicPtr.SendServerVersion(a)
 	case "ReqRegisterAccount":

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

@@ -22,6 +22,7 @@ type CardMod struct {
 	ReqFriend     map[int]*CardInfo //今日已请求好友
 	ExCard        map[int]*CardInfo // 交换卡牌
 	Cache         Cache             // 缓存卡牌
+	Round         int               // 轮次
 }
 
 type Cache struct {
@@ -99,6 +100,7 @@ func (c *CardMod) Login(ServerOpenTime int64) {
 		c.CollectReward = make(map[int]struct{})
 		c.AllCollect = 0
 		c.EndTime = 0
+		c.Round = 0
 	}
 	if c.EndTime == 0 {
 		c.EndTime = ((Now-ServerOpenTime)/Duration+1)*Duration + ServerOpenTime
@@ -137,7 +139,7 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
 	mustHaveStar := cardCfg.GetPackMustHave(Star)
 
 	if mustHaveStar != 0 {
-		cardId = randCard(mustHaveStar, 0)
+		cardId = randCard(c.Round, mustHaveStar, 0)
 		if cardId == 0 {
 			return newCard, fmt.Errorf("OpenCardPack card id err")
 		}
@@ -155,11 +157,11 @@ func (c *CardMod) OpenCardPack(Star int) ([]int, error) {
 		CardStar := GoUtil.RandMap(randList)
 		switch CardStar {
 		case 5:
-			cardId = randCard(4, 1)
+			cardId = randCard(c.Round, 4, 1)
 		case 6:
-			cardId = randCard(5, 1)
+			cardId = randCard(c.Round, 5, 1)
 		default:
-			cardId = randCard(CardStar, 0)
+			cardId = randCard(c.Round, CardStar, 0)
 		}
 		if cardId == 0 {
 			return newCard, fmt.Errorf("OpenCardPack card id err")
@@ -207,6 +209,7 @@ func (c *CardMod) BackData() *msg.ResCardInfo {
 		AllCard:   GoUtil.MapIntToInt32(c.AllCard),
 		ReqUid:    ReqUid,
 		ExUid:     ExUid,
+		Round:     int32(c.Round),
 	}
 }
 
@@ -247,14 +250,24 @@ func (c *CardMod) AllCollectReward() ([]*item.Item, error) {
 	if c.AllCollect == 1 {
 		return nil, fmt.Errorf("AllCollectReward already collect")
 	}
-	AllCardId := cardCfg.GetAllCardId()
+	AllCardId := cardCfg.GetAllCardId(c.Round)
 	for _, v := range AllCardId {
 		count, ok := c.CardList[v]
 		if !ok || count <= 0 {
 			return nil, fmt.Errorf("card not fully collect")
 		}
 	}
-	c.AllCollect = 1
+	c.AllCollect = 0
+	c.Round++
+	c.CollectReward = make(map[int]struct{})
+	ExStar := 0
+	for k, v := range c.CardList {
+		star := cardCfg.GetStarById(k)
+		ExStar += star * (v - 1)
+	}
+	c.CardList = make(map[int]int)
+	c.ExchangeStar += ExStar
+	c.Cache.ExStar += ExStar
 	Item := cardCfg.GetAllCollectReward()
 	return Item, nil
 }

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

@@ -5,12 +5,12 @@ import (
 	cardCfg "server/conf/card"
 )
 
-func randCard(Star, IsGold int) int {
-	cardList := cardCfg.GetCardListByStar(Star, IsGold)
+func randCard(Round, Star, IsGold int) int {
+	cardList := cardCfg.GetCardListByStar(Round, Star, IsGold)
 	cardId := GoUtil.RandSlice(cardList)
 	return cardId
 }
 
 func RankGoldCard() (int, int) {
-	return randCard(4, 1), randCard(5, 1)
+	return randCard(0, 4, 1), randCard(0, 5, 1)
 }

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

@@ -100,7 +100,7 @@ func (f *FriendMod) GetFriendNum() int {
 }
 func (f *FriendMod) GetFriendList() []int {
 	var list []int
-	for k, _ := range f.FriendList {
+	for k := range f.FriendList {
 		list = append(list, k)
 	}
 	return list

src/server/game/mod/friendTreasure.go/friendTreasure.go

@@ -0,0 +1,153 @@
+package friendTreasure
+
+import (
+	"fmt"
+	"server/GoUtil"
+	friendTreasureCfg "server/conf/friendTreasure"
+	"server/game/mod/item"
+	"server/msg"
+)
+
+type FriendTreasureMod struct {
+	Star       int // 星级
+	Shift      int // 挡位
+	Pos        []int
+	Num        int
+	GameFriend map[int]*msg.TreasureInfo
+	SelectF    []int32 // 选择的好友
+	Status     int
+}
+
+const (
+	FRIEND_TYPE_ALIVE     = 1
+	FRIEND_TYPE_NOT_ALIVE = 2
+)
+
+func (f *FriendTreasureMod) InitData() {
+	if f.GameFriend == nil {
+		f.GameFriend = make(map[int]*msg.TreasureInfo)
+	}
+}
+
+func (f *FriendTreasureMod) ZeroUpdate() {
+	f.Star = 0
+	f.Shift = 0
+	f.Pos = nil
+	f.Num = 0
+	f.GameFriend = make(map[int]*msg.TreasureInfo)
+	f.SelectF = nil
+	f.Status = 0
+}
+
+func (f *FriendTreasureMod) InitGame(List []*msg.TreasureInfo, List2 []int32) {
+	for _, v := range List {
+		f.GameFriend[int(v.Pos)] = v
+	}
+	f.SelectF = List2
+	f.Num = 0
+	f.Status = 1
+}
+
+func (f *FriendTreasureMod) AddStar(Star int) {
+	f.Star += min(200, Star)
+}
+
+func (f *FriendTreasureMod) Flip(Pos int) ([]*item.Item, error) {
+	if f.Status == 0 {
+		return nil, fmt.Errorf("game not start")
+	}
+	f.Num++
+	Info := f.GameFriend[Pos]
+	// if f.Num == f.Shift { // 游戏结束
+	// 	ProbAdd := friendTreasureCfg.GetProbAdd(f.Num)
+	// 	Reward := []*item.Item{
+	// 		{Id: 1, Num: int(float64(f.Star) * float64((1+ProbAdd)/100))},
+	// 	}
+	// 	f.Star = 0
+	// 	f.Shift = 0
+	// 	return Reward, nil
+	// }
+
+	if Info.Type == FRIEND_TYPE_ALIVE && Info.Status == 0 {
+		ProbMap := friendTreasureCfg.GetChestProb()
+		Prob := GoUtil.RandMap(ProbMap)
+		Info.Status = 1
+		return friendTreasureCfg.GetChestItems(Prob), nil
+	}
+	Info.Status = 1
+	return nil, nil
+}
+
+func (f *FriendTreasureMod) EndGame() ([]*item.Item, int, error) {
+	if f.Status == 0 {
+		return nil, 0, fmt.Errorf("game is over")
+	}
+	ProbAdd := friendTreasureCfg.GetProbAdd(f.Num)
+	ItemNum := int(float64(f.Star) * float64((1+ProbAdd)/100))
+	FriendItemNum := ItemNum / 10
+	Reward := []*item.Item{
+		{Id: 1, Num: ItemNum},
+	}
+	f.Star = 0
+	f.Shift = 0
+	f.Status = 0
+	f.Num = 0
+	return Reward, FriendItemNum, nil
+}
+
+func (f *FriendTreasureMod) NotifyStar() *msg.ResFriendTreasureStar {
+	return &msg.ResFriendTreasureStar{
+		Star: int32(f.Star),
+	}
+}
+
+// func getFriendList(Alive, NotAlive []int) []*Info {
+// 	FriendList := make([]*Info, 0)
+// 	AllFriend := make([]int, 0)
+// 	AllFriend = append(AllFriend, Alive...)
+// 	AllFriend = append(AllFriend, NotAlive...)
+// 	if len(Alive)+len(NotAlive) < 9 {
+// 		AliveInfo := initInfo(Alive, FRIEND_TYPE_ALIVE)
+// 		NotAliveInfo := initInfo(NotAlive, FRIEND_TYPE_NOT_ALIVE)
+// 		FriendList = append(FriendList, AliveInfo...)
+// 		FriendList = append(FriendList, NotAliveInfo...)
+// 		return FriendList
+// 	}
+// 	if len(Alive) < 3 {
+// 		AliveInfo := initInfo(Alive, FRIEND_TYPE_ALIVE)
+// 		NotAliveInfo := initInfo(NotAlive, FRIEND_TYPE_NOT_ALIVE)
+// 		FriendList = append(FriendList, AliveInfo...)
+// 		FriendList = append(FriendList, NotAliveInfo...)
+// 		interfaceList := make([]interface{}, len(FriendList))
+// 		for i, v := range FriendList {
+// 			interfaceList[i] = v
+// 		}
+// 		randResult := GoUtil.RandSliceNum2(interfaceList, 9)
+// 		result := make([]*Info, len(randResult))
+// 		for i, v := range randResult {
+// 			result[i] = v.(*Info)
+// 		}
+// 		return result
+// 	}
+// 	L1 := GoUtil.RandSliceNum(Alive, 3)
+// 	LastFriend := GoUtil.SubSlices(AllFriend, L1)
+// 	LastAlive := GoUtil.SubSlices(Alive, L1)
+// 	L11 := initInfo(L1, FRIEND_TYPE_ALIVE)
+// 	FriendList = append(FriendList, L11...)
+// 	Num := math.Ceil(6 * float64(len(NotAlive)) / float64(len(LastFriend)))
+// 	L2 := GoUtil.RandSliceNum(NotAlive, int(Num))
+// 	L22 := initInfo(L2, FRIEND_TYPE_NOT_ALIVE)
+// 	FriendList = append(FriendList, L22...)
+// 	L3 := GoUtil.RandSliceNum(LastAlive, 9-len(FriendList))
+// 	L33 := initInfo(L3, FRIEND_TYPE_ALIVE)
+// 	FriendList = append(FriendList, L33...)
+// 	return FriendList
+// }
+
+// func initInfo(Uid []int, Type int) []*Info {
+// 	L := make([]*Info, 0)
+// 	for _, v := range Uid {
+// 		L = append(L, &Info{Uid: v, Type: Type})
+// 	}
+// 	return L
+// }

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

@@ -65,6 +65,8 @@ const (
 	SERVER_ZERO_UPDATE        //zero update
 	HANDLE_TYPE_PLAYROOM_LOSE // playroom偷取物品
 	SERVER_NOON_UPDATE        // 12点更新
+
+	FRIEND_TREASURE_HANDLE //好友宝藏操作
 )
 
 const (

src/server/gate/router.go

@@ -9,4 +9,6 @@ func init() {
 	// 这里指定消息 Hello 路由到 game 模块
 	// 模块间使用 ChanRPC 通讯，消息路由也不例外
 	msg.Processor.SetRouter(&msg.ClientReq{}, game.ChanRPC)
+	msg.Processor.SetRouter(&msg.ClientRes{}, game.ChanRPC)
+	msg.Processor.SetRouter(&msg.AdminReq{}, game.ChanRPC)
 }

src/server/msg/msg.go

@@ -8,7 +8,7 @@ var Processor = protobuf.NewProcessor()
 
 func init() {
 	Processor.Register(&ClientReq{})
-
 	Processor.Register(&ClientRes{})
-
+	Processor.Register(&AdminReq{})
+	Processor.Register(&AdminRes{})
 }