更新playroom

src/server/GoUtil/GoUtil.go

@@ -183,3 +183,27 @@ func RandString(n int) string {
 func CreateCardId(From, To, CardId int) string {
 	return fmt.Sprintf("%d_%d_%d_%d_%s", From, To, CardId, Now(), RandString(3))
 }
+
+func PlayroomTrigger(Time int64, Num int) (int64, int) {
+	if Num == 0 {
+		return 0, 0
+	}
+	Now := Now()
+	var Duration int64
+	for {
+		if Num > 50 {
+			Duration = 1200
+
+		} else {
+			Duration = 3600
+		}
+		if Time+Duration > Now {
+			return Time, Num
+		}
+		Time += Duration
+		Num -= 10
+		if Num <= 0 {
+			return 0, 0
+		}
+	}
+}

src/server/GoUtil/randUtil.go

@@ -26,6 +26,27 @@ func RandMap(d map[int]int) int {
 	return -1
 }
 
+func RandStringMap(d map[string]int) string {
+	total := 0
+	for _, v := range d {
+		total += v
+	}
+
+	// 生成一个 [0, total) 范围内的随机数
+	r := rand.Intn(total)
+
+	// 根据随机数选择一个键
+	for k, v := range d {
+		if r < v {
+			return k
+		}
+		r -= v
+	}
+
+	// 如果没有找到，返回一个默认值
+	return ""
+}
+
 // 从d中随机选取n个元素 不放回
 func RandMapNum(d map[int]int, n int) []int {
 	if n <= 0 || n > len(d) {

src/server/GoUtil/sliceUtil.go

@@ -182,3 +182,17 @@ func PopSlice(s []int) (int, []int) {
 	}
 	return s[0], s[1:]
 }
+
+func SliceEqual(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	sort.Ints(a)
+	sort.Ints(b)
+	for k, v := range a {
+		if v != b[k] {
+			return false
+		}
+	}
+	return true
+}

src/server/conf/champship/ChampshipCfg.go

@@ -69,7 +69,7 @@ func GetRankReward(Rank int) []*item.Item {
 	}
 	for _, v := range data {
 		if Rank >= gamedata.GetIntValue(v, "Min") && Rank <= gamedata.GetIntValue(v, "Max") {
-			return item.ParseItem(gamedata.GetStringValue(v, "Items"))
+			return gamedata.GetItemList(v, "Items")
 		}
 	}
 	return nil

src/server/conf/json.go

@@ -40,14 +40,14 @@ var Server struct {
 	ListenAddr string
 	CenterAddr string
 
-	RemoteAddr string
+	RemoteAddr   string
-
+	GameConfPath string
-	TELOGDIR string
+	TELOGDIR     string
 }
 
 func init() {
-	// data, err := ioutil.ReadFile("conf/server.json")
+	filePath := "conf/server.json"
-	file, err := os.Open("conf/server.json")
+	file, err := os.Open(filePath)
 	if err != nil {
 		panic(err)
 	}

src/server/conf/mergeData/MergeDataCfg.go

@@ -82,6 +82,7 @@ func GetChessIdByLvAndColor(Lv int, Color string) int {
 			return Id
 		}
 	}
+	log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
 	return 0
 }
 
@@ -105,6 +106,15 @@ func GetMaxLvById(Id int) int {
 	return gamedata.ParseInt(data["MaxLv"])
 }
 
+func GetEmitMinLvById(Id int) int {
+	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
+	if err != nil {
+		log.Debug("GetMaxLvById GetOne Id:%v not found", Id)
+		return 0
+	}
+	return gamedata.ParseInt(data["Emit_Min_Lv"])
+}
+
 func GetMaxLvByColor(Color string) int {
 	data, err := gamedata.GetData(CFG_NAME)
 	if err != nil {
@@ -157,7 +167,11 @@ func GetEmitProduceChessType(Id int) []string {
 		log.Debug("GetTypeById GetOne Id:%v not found", Id)
 		return []string{}
 	}
-	return strings.Split(gamedata.ParseString(data["Product_Type"]), ",")
+	value := gamedata.ParseString(data["Product_Type"])
+	if value == "" {
+		return []string{}
+	}
+	return strings.Split(value, ",")
 }
 
 // 根据Id获取发射器Id

src/server/conf/playroom/playroomCfg.go

@@ -0,0 +1,127 @@
+package playroomCfg
+
+import (
+	"server/GoUtil"
+	"server/game/mod/item"
+	"server/gamedata"
+)
+
+const (
+	CFG_PLAYROOM_CONST    = "PlayroomConst"
+	CFG_PLAYROOM_DECORATE = "PlayroomDecorate"
+	CFG_PLAYROOM_MOOD     = "PlayroomMood"
+)
+
+func init() {
+	gamedata.InitCfg(CFG_PLAYROOM_CONST)
+	gamedata.InitCfg(CFG_PLAYROOM_DECORATE)
+	gamedata.InitCfg(CFG_PLAYROOM_MOOD)
+}
+
+func GetUnLockLv() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Lv")
+	if err != nil {
+		return 999
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetOrderStar() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "Star")
+	if err != nil {
+		return 1000
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetRewardStar() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "RewardStar")
+	if err != nil {
+		return 1000
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetNormalItem() (int, int) {
+	data1, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "NormalFoodId")
+	if err != nil {
+		return 0, 0
+	}
+	data2, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "NormalCleanId")
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data1, "Value"), gamedata.GetIntValue(data2, "Value")
+}
+
+func GetPremiumItem() (int, int) {
+	data1, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "PremiumFoodId")
+	if err != nil {
+		return 0, 0
+	}
+	data2, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "PremiumCleanId")
+	if err != nil {
+		return 0, 0
+	}
+	return gamedata.GetIntValue(data1, "Value"), gamedata.GetIntValue(data2, "Value")
+}
+
+func GetVisitorItem() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "VisitorItem")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+func GetWorkItem() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "WorkItem")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetWorkChargeId() int {
+	data, err := gamedata.GetDataByKey(CFG_PLAYROOM_CONST, "WorkChargeId")
+	if err != nil {
+		return 0
+	}
+	return gamedata.GetIntValue(data, "Value")
+}
+
+func GetInteract(Id, Type int) (int, []*item.Item, int) {
+	data, err := gamedata.GetDataByIntKey(CFG_PLAYROOM_MOOD, Id)
+	if err != nil {
+		return 0, nil, 0
+	}
+	if Type == 1 {
+		return gamedata.GetIntValue(data, "Type"), gamedata.GetItemList(data, "Cost"), gamedata.GetIntValue(data, "Effect")
+	}
+	return gamedata.GetIntValue(data, "Type"), gamedata.GetItemList(data, "Cost2"), gamedata.GetIntValue(data, "Effect")
+}
+
+func GetInitDecorate() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DECORATE)
+	if err != nil {
+		return []int{}
+	}
+	for k, v := range data {
+		if gamedata.GetIntValue(v, "Init") == 1 {
+			r = append(r, GoUtil.Int(k))
+		}
+	}
+	return r
+}
+
+func GetDecorateList() []int {
+	r := make([]int, 0)
+	data, err := gamedata.GetData(CFG_PLAYROOM_DECORATE)
+	if err != nil {
+		return []int{}
+	}
+	for k := range data {
+		r = append(r, GoUtil.Int(k))
+	}
+	return r
+}

src/server/conf/server.json

@@ -10,7 +10,6 @@
 	"MaxConnNum": 20000,
 	"DbName": "Merge_Pet",
 	"HttpPort": ":8081",
-	"RemoteAddr":"host.docker.internal:9001",
 
 	"TELOGDIR" : "./teLog/",
 
@@ -28,7 +27,8 @@
 	"RedisAddr":"127.0.0.1",
 	"RedisPort" :"6379",
 	"RedisPwd"  :"",
-
+	
+	"RemoteAddr":"host.docker.internal:9001",
 	"ListenAddr": ":9001",
-	"CenterAddr": ":3560"
+	"CenterAddr": ":9000"
 }

src/server/game/ChampshipMgr.go

@@ -107,10 +107,11 @@ func (c *ChampshipMgr) Init() {
 	})
 }
 
-func (c *ChampshipMgr) NotifyAll() {
+func (c *ChampshipMgr) NotifyAll(m *msg.Msg) (interface{}, error) {
 	G_GameLogicPtr.NotifyAll(&msg.Msg{
 		Type: msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY,
 	})
+	return nil, nil
 }
 
 func (c *ChampshipMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {

src/server/game/ChargeFunc.go

@@ -9,6 +9,17 @@ func Charge(p *Player, ChargeId int) {
 	ChargeFire(p, ChargeId)    // 充值
 	EndlessFire(p, ChargeId)   // 无尽礼包
 	PiggyBankFire(p, ChargeId) // 猪猪银行
+	PlayroomFire(p, ChargeId)  // 游乐场
+}
+
+func PlayroomFire(p *Player, ChargeId int) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	Item := PlayroomMod.Fire(ChargeId)
+	err := p.HandleItem(Item, "Playroom")
+	if err != nil {
+		log.Debug("ChargeFire err : %s", err)
+	}
+	p.PlayMod.save()
 }
 
 func PiggyBankFire(p *Player, ChargeId int) {

src/server/game/FriendMgr.go

@@ -39,7 +39,7 @@ func (f *FriendMgr) Init() {
 	f.RegisterHandler(msg.HADNLE_TYPE_AGREE, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_DEL, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_SYNC, f.sync)
-	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE, f.sync)
+	f.RegisterHandler(msg.HANDLE_TYPE_REFUSE, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_INVITE_ADD_FRIEND, f.sendToPlayer)
 	f.RegisterHandler(msg.HANDLE_TYPE_INVITE_FRIEND, f.sendToPlayer)
 
@@ -84,6 +84,7 @@ func (f *FriendMgr) sendToPlayer(m *msg.Msg) (interface{}, error) {
 func (f *FriendMgr) sync(m *msg.Msg) (interface{}, error) {
 	data := f.getData().List[m.From]
 	f.getData().List[m.From] = make([]*msg.Msg, 0)
+	log.Debug("sync friendMgr msg to player success")
 	return data, nil
 }
 
@@ -93,7 +94,7 @@ func sendToPlayer(m *msg.Msg) error {
 	if p == nil || p.stop {
 		return fmt.Errorf("player %d not online", m.To)
 	}
-	p.SendMsg(m)
+	p.Send(m)
 	return nil
 }
 

src/server/game/GameLogic.go

@@ -371,6 +371,9 @@ func (ad *GameLogic) VarMgrCall(m *MsgMod.Msg) interface{} {
 }
 
 func (ad *GameLogic) GetSimplePlayerByUid(Id int) *PlayerSimpleData {
+	if Id == 0 {
+		return nil
+	}
 	Idstr := strconv.Itoa(Id)
 	Value, _ := db.RedisGetKey(Idstr)
 	player := &PlayerSimpleData{}
@@ -774,6 +777,7 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	// 商店
 	RegisterMsgProcessFunc("ReqFreeShop", ReqFreeShop)                 // 领取商店免费奖励
 	RegisterMsgProcessFunc("ReqBuyChessShop", ReqBuyChessShop)         // 购买商店棋子
+	RegisterMsgProcessFunc("ReqBuyChessShop2", ReqBuyChessShop2)       // 购买商店棋子直接加入棋盘
 	RegisterMsgProcessFunc("ReqRefreshChessShop", ReqRefreshChessShop) // 刷新棋子商店
 
 	// 无尽礼包
@@ -803,6 +807,18 @@ func (ad *GameLogic) RegisterNetWorkFunc() {
 	RegisterMsgProcessFunc("ReqRaceReward", ReqRaceReward)
 	RegisterMsgProcessFunc("ReqRaceStart", ReqRaceStart)
 
+	// playroom
+	RegisterMsgProcessFunc("ReqPlayroom", ReqPlayroom)                         // 请求playroom数据
+	RegisterMsgProcessFunc("ReqPlayroomInfo", ReqPlayroomInfo)                 // 请求playroom拜访信息
+	RegisterMsgProcessFunc("ReqPlayroomGame", ReqPlayroomGame)                 // 游戏结果
+	RegisterMsgProcessFunc("ReqPlayroomInteract", ReqPlayroomInteract)         // 宠物交互
+	RegisterMsgProcessFunc("ReqPlayroomSetRoom", ReqPlayroomSetRoom)           // playroom装饰
+	RegisterMsgProcessFunc("ReqPlayroomSelectReward", ReqPlayroomSelectReward) // playroom选择奖励
+	RegisterMsgProcessFunc("ReqPlayroomLose", ReqPlayroomLose)                 // 处理偷取的棋子
+	RegisterMsgProcessFunc("ReqPlayroomWork", ReqPlayroomWork)                 // 宠物工作
+	RegisterMsgProcessFunc("ReqPlayroomRest", ReqPlayroomRest)                 // 宠物休息
+	RegisterMsgProcessFunc("ReqPlayroomDraw", ReqPlayroomDraw)                 // 转盘
+	RegisterMsgProcessFunc("ReqPlayroomChip", ReqPlayroomChip)                 // 消除碎片
 }
 
 func (ad *GameLogic) CreateHttpManager() {
@@ -842,7 +858,7 @@ func NotifyPlayer(Uid int, m *MsgMod.Msg) {
 	if p == nil || p.stop {
 		return
 	}
-	p.SendMsg(m)
+	p.Send(m)
 }
 
 func setRedisLock(key, value string, Duration time.Duration) bool {

src/server/game/Gm.go

@@ -1,9 +1,11 @@
 package game
 
 import (
+	playroomCfg "server/conf/playroom"
 	"server/game/mod/card"
 	"server/game/mod/item"
 	MsgMod "server/game/mod/msg"
+	"server/game/mod/playroom"
 	"server/msg"
 	"strconv"
 	"strings"
@@ -72,7 +74,8 @@ func ReqGmCommand(args []interface{}) error {
 	case "createOrder":
 		Lv := player.GetPlayerBaseMod().GetLevel()
 		EmitList := player.PlayMod.getChessMod().GetEmitList()
-		player.PlayMod.getOrderMod().CreateOrder(Lv, EmitList)
+		EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
+		player.PlayMod.getOrderMod().CreateOrder(Lv, EmitList, EnergyMul)
 		player.PushClientRes(player.PlayMod.getOrderMod().BackData())
 	case "resetCardReq":
 		CardMod := player.PlayMod.getCardMod()
@@ -140,6 +143,18 @@ func ReqGmCommand(args []interface{}) error {
 		RaceMod.ZeroUpdate(-1)
 		ActivityInfo := GetActivityInfo(player, ACT_TYPE_RACE)
 		RaceMod.ZeroUpdate(ActivityInfo.Id)
+	case "playroomTrigger":
+		PlayroomOrderTrigger(player)
+	case "playroomReset":
+		PlayroomMod := playroom.PlayroomMod{}
+		PlayroomMod.InitData()
+		player.PlayMod.mod_list.Playroom = PlayroomMod
+	case "playroomCollect":
+		CollectList := playroomCfg.GetDecorateList()
+		PlayroomMod := playroom.PlayroomMod{}
+		for _, v := range CollectList {
+			PlayroomMod.AddCollect(v)
+		}
 	}
 	player.PlayMod.save()
 	return nil

src/server/game/LimitedTimeTrigger.go

@@ -39,7 +39,12 @@ func LimitedTimeEventTrigger(p *Player, AddEventId int) {
 			MaxEnergyMul := p.GetPlayerBaseMod().GetMaxEnergyMul()
 			p.PlayMod.getBaseMod().ResetEnergyMul(MaxEnergyMul)
 			NewEnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
-
+			OrderMod := p.PlayMod.getOrderMod()
+			Lv := p.GetPlayerBaseMod().GetLevel()
+			Emit := p.PlayMod.getChessMod().GetEmitList()
+			ChessList := p.PlayMod.getChessMod().GetChessList()
+			OrderMod.ChangeEnergyMul(Lv, Emit, NewEnergyMul, ChessList)
+			p.PushClientRes(OrderMod.BackData())
 			p.TeLog("mutil_merge_change", map[string]interface{}{
 				"change_from": math.Pow(2, float64(EnergyMul)),
 				"change_to":   math.Pow(2, float64(NewEnergyMul)),
@@ -62,7 +67,8 @@ func LimitedTimeEventTrigger(p *Player, AddEventId int) {
 		case limitedTimeEvent.EVENT_TYPE_SUPER_ORDER:
 			Emit := p.PlayMod.getChessMod().GetEmitList()
 			Lv := p.GetPlayerBaseMod().GetLevel()
-			p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit)
+			EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
+			p.PlayMod.getOrderMod().CreateSuperOrder(Lv, Emit, EnergyMul)
 			p.PushClientRes(p.PlayMod.getOrderMod().BackData())
 		case limitedTimeEvent.EVENT_TYPE_CARD_FESTIVAL:
 			p.PlayMod.getCardMod().CreateCardFestival()
@@ -124,3 +130,25 @@ func LimitedTimeCardTrigger(p *Player) {
 		}, "LimitedTimeCard")
 	}
 }
+
+func LimitedTimePlayroomTrigger(p *Player, Id int) {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	Now := GoUtil.Now()
+	MoodInfo := PlayroomMod.GetMoodInfo(Id)
+	if MoodInfo == nil {
+		return
+	}
+	NewTime, Num := GoUtil.PlayroomTrigger(MoodInfo.Time, MoodInfo.Num)
+	MoodInfo.Time = NewTime
+	MoodInfo.Num = Num
+	p.PlayMod.save()
+	PlayroomBackData(p)
+	if NewTime > 0 {
+		NextSecond := NewTime + 1200 - Now
+		p.CallEvent(time.Duration(NextSecond)*time.Second, func() {
+			LimitedTimePlayroomTrigger(p, Id)
+			p.SendClientRes()
+		}, "Playroom")
+	}
+
+}

src/server/game/Player.go

@@ -20,6 +20,7 @@ import (
 	"server/game/mod/item"
 	"server/game/mod/limitedTimeEvent"
 	MsgMod "server/game/mod/msg"
+	"server/game/mod/playroom"
 	"server/game/mod/quest"
 	"server/msg"
 	telog "server/thinkdata"
@@ -41,28 +42,28 @@ import (
 //"fmt"
 
 type Player struct {
-	playerdata   map[string]PlayerDataModule
+	playerdata  map[string]PlayerDataModule
-	playerdataIF map[string]interface{}
+	PlayMod     PlayerMod
-	PlayMod      PlayerMod
+	M_DwUin     int32
-	M_DwUin      int32
+	agent       gate.Agent
-	agent        gate.Agent
+	lock        sync.Mutex
-	lock         sync.Mutex
+	stopSignal  chan bool
-	stopSignal   chan bool
+	Msg         map[string]PlayerMsg
-	Msg          map[string]PlayerMsg
+	Trigger     []*quest.Trigger
-	Trigger      []*quest.Trigger
+	MDispatr    *timer.Dispatcher
-	MDispatr     *timer.Dispatcher
+	McronSave   *cron.Cron
-	McronSave    *cron.Cron
+	McronSaveID cron.EntryID
-	McronSaveID  cron.EntryID
+	msgChan     chan *MsgMod.Msg
-	msgChan      chan *MsgMod.Msg
+	args        map[string]interface{}
-	args         map[string]interface{}
+	timerList   map[string]*timer.Timer
-	timerList    map[string]*timer.Timer
+	activity    map[int]*ActivityInfo
-	activity     map[int]*ActivityInfo
+	stop        bool
-	stop         bool
+	wg          sync.WaitGroup
 }
 
 type PlayerBackUp struct {
-	PlayerBaseData *PlayerBaseData
+	Data    msg.ResPlayerBaseInfo
-	PlayMod        []byte
+	PlayMod []byte
 }
 
 type PlayerMsg struct {
@@ -76,6 +77,7 @@ func (p *Player) Stop() {
 		// 通道已经关闭
 		return
 	default:
+		p.wg.Wait()
 		close(p.stopSignal)
 		close(p.msgChan)
 	}
@@ -97,6 +99,10 @@ func (p *Player) CallEvent(Duration time.Duration, F func(), Label string) {
 
 // 异步请求
 func (p *Player) Send(m *MsgMod.Msg) {
+	if m == nil {
+		return
+	}
+	p.wg.Add(1)
 	p.msgChan <- m
 }
 
@@ -160,15 +166,13 @@ func (p *Player) ProcessTrigger() {
 func (p *Player) BackUp() *PlayerBackUp {
 	BackUp := PlayerBackUp{}
 	p.PlayMod.BackUp(&BackUp)
-	BackUp.PlayerBaseData = p.GetPlayerBaseMod().BackUp()
+	BackUp.Data = p.GetPlayerBaseMod().BackUp()
 	return &BackUp
 }
 
 // 接口发生错误时 还原数据
 func (p *Player) Recover(backUp *PlayerBackUp) {
-	backUp.PlayerBaseData.PlayerData = NewPlayerData(PLAYER_BASE_DATA, p)
+	p.GetPlayerBaseMod().Data = backUp.Data
-	p.playerdata[PLAYER_BASE_DATA] = backUp.PlayerBaseData
-	p.playerdataIF[PLAYER_BASE_DATA] = backUp.PlayerBaseData
 	p.PlayMod.Recover(backUp)
 	p.Msg = make(map[string]PlayerMsg)
 }
@@ -183,10 +187,8 @@ func (p *Player) InitPlayer(UserName string) error {
 	p.MDispatr = timer.NewDispatcher(10)
 	p.stopSignal = make(chan bool)
 	p.playerdata = make(map[string]PlayerDataModule)
-	p.playerdataIF = make(map[string]interface{})
 	Base := &PlayerBaseData{PlayerData: NewPlayerData(PLAYER_BASE_DATA, p)}
 	p.playerdata[PLAYER_BASE_DATA] = Base
-	p.playerdataIF[PLAYER_BASE_DATA] = Base
 
 	// 玩家基础数据
 	ok := Base.LoadDataFromDB(UserName)
@@ -195,7 +197,6 @@ func (p *Player) InitPlayer(UserName string) error {
 		return errors.New("load PlayerBaseData failed")
 	}
 	p.playerdata[PLAYER_BASE_DATA] = Base
-	p.playerdataIF[PLAYER_BASE_DATA] = Base
 	p.M_DwUin = Base.Data.DwUin
 
 	// 棋盘数据
@@ -206,7 +207,6 @@ func (p *Player) InitPlayer(UserName string) error {
 		return errors.New("load PlayerChessData failed")
 	}
 	p.playerdata["PlayerChessData"] = Chess
-	p.playerdataIF["PlayerChessData"] = Chess
 
 	// 玩家模块数据
 	modData := &PlayerModData{PlayerData: NewPlayerData("PlayerModData", p)}
@@ -236,8 +236,11 @@ func (p *Player) InitPlayer(UserName string) error {
 					log.Debug("Timer callback or Timer is nil")
 				}
 			case msg := <-p.msgChan:
-				log.Debug("player recive msg:", msg)
+				if msg != nil {
-				go HandleMsg(p, msg)
+					p.wg.Done()
+					log.Debug("player %d recive msg %v", p.M_DwUin, msg)
+					go HandleMsg(p, msg)
+				}
 			}
 		}
 	}()
@@ -258,11 +261,6 @@ func (p *Player) InitPlayer(UserName string) error {
 	return nil
 }
 
-// 异步发送消息
-func (p *Player) SendMsg(m *MsgMod.Msg) {
-	p.msgChan <- m
-}
-
 func (p *Player) Test() {
 	p.PlayMod.getBaseMod().EnergyMul = 100
 }
@@ -342,13 +340,16 @@ func (p *Player) Login() {
 	LimitedTimeEventTrigger(p, 0)
 	// 猪猪银行触发
 	LimitedTimePiggyBankTrigger(p)
+	// playroom触发
+	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_ENTER)
+	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_FOOD)
+	LimitedTimePlayroomTrigger(p, playroom.MOOD_TYPE_CLEAN)
 	ActivityLogin(p)
 	p.PlayMod.getCardMod().Login(G_GameLogicPtr.SeverInfo.OpenTime)
 }
 
 // 离线 保存数据
 func (p *Player) ClearData() {
-
 	log.Release("uid: %d, outline save data", p.M_DwUin)
 	ctx := context.Background()
 	txOptions := &sql.TxOptions{}
@@ -404,8 +405,7 @@ func (p *Player) SetAgent(a gate.Agent) {
 }
 
 func (p *Player) GetIFGameData(key string) interface{} {
-
+	v, ok := p.playerdata[key]
-	v, ok := p.playerdataIF[key]
 	if ok {
 		return v
 	}
@@ -413,7 +413,7 @@ func (p *Player) GetIFGameData(key string) interface{} {
 }
 
 func (p *Player) GetPlayerBaseMod() *PlayerBaseData {
-	v, ok := p.playerdataIF[PLAYER_BASE_DATA]
+	v, ok := p.playerdata[PLAYER_BASE_DATA]
 	if ok {
 		return v.(*PlayerBaseData)
 	}
@@ -610,9 +610,13 @@ func (p *Player) HandleItem(itemList []*item.Item, Label string) error {
 				"avatar_id":   Effect[0],
 				"income_from": Label,
 			})
-		case item.ITEM_TYPE_ACTIVITY_RACE:
+		case item.ITEM_TYPE_ACTIVITY_RACE: // 活动竞速
 			RaceMod := p.PlayMod.getRaceMod()
 			RaceMod.AddCoin(v.Num)
+		case item.ITEM_TYPE_PLAYROOM_VISIT: // 拜访玩家
+			Target := GetVisitorPlayer(p)
+			PlayroomVisit(p, Target)
+			PlayroomBackData(p)
 		default:
 			err := ItemMod.AddItem(v.Id, v.Num)
 			if err != nil {
@@ -674,10 +678,8 @@ func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
 	p.MDispatr = timer.NewDispatcher(10)
 	p.stopSignal = make(chan bool)
 	p.playerdata = make(map[string]PlayerDataModule)
-	p.playerdataIF = make(map[string]interface{})
 	Base := &PlayerBaseData{PlayerData: NewPlayerData(PLAYER_BASE_DATA, p)}
 	p.playerdata[PLAYER_BASE_DATA] = Base
-	p.playerdataIF[PLAYER_BASE_DATA] = Base
 
 	// 玩家基础数据
 	ok := Base.GetDataByUid(Uid)
@@ -685,7 +687,6 @@ func (p *Player) GetSimpleData(Uid int, simple *PlayerSimpleData) error {
 		return errors.New("load PlayerBaseData failed")
 	}
 	p.playerdata[PLAYER_BASE_DATA] = Base
-	p.playerdataIF[PLAYER_BASE_DATA] = Base
 	p.M_DwUin = Base.Data.DwUin
 
 	// 玩家模块数据
@@ -720,6 +721,8 @@ func (p *Player) UpdateUserInfo() {
 	simple.Loginout = int64(Base.Data.LogoutTime)
 	simple.FaceBook = Base.Data.FaceBookId
 	simple.FaceBookPic = p.PlayMod.getBaseMod().FacebookUrl
+	simple.Playroom = p.PlayMod.getPlayroomMod().Room
+	simple.Chess = p.PlayMod.getChessMod().GetChessList()
 	value, _ := json.Marshal(simple)
 	IdStr := strconv.Itoa(int(p.M_DwUin))
 	db.RedisSetKey(IdStr, string(value), 0)

src/server/game/PlayerBaseMod.go

@@ -40,39 +40,30 @@ func (p *PlayerBaseData) GetData() interface{} {
 	return &p.Data
 }
 
-func (p *PlayerBaseData) BackUp() *PlayerBaseData {
+func (p *PlayerBaseData) BackUp() msg.ResPlayerBaseInfo {
-	return &PlayerBaseData{
+	return msg.ResPlayerBaseInfo{
-		Data: msg.ResPlayerBaseInfo{
+		Diamond:           p.Data.Diamond,
-			Diamond:           p.Data.Diamond,
+		DwUin:             p.Data.DwUin,
-			DwUin:             p.Data.DwUin,
+		Energy:            p.Data.Energy,
-			Energy:            p.Data.Energy,
+		Star:              p.Data.Star,
-			Star:              p.Data.Star,
+		RecoverTime:       p.Data.RecoverTime,
-			RecoverTime:       p.Data.RecoverTime,
+		Level:             p.Data.Level,
-			Level:             p.Data.Level,
+		Exp:               p.Data.Exp,
-			Exp:               p.Data.Exp,
+		StartOrderId:      p.Data.StartOrderId,
-			StartOrderId:      p.Data.StartOrderId,
+		MusicCode:         p.Data.MusicCode,
-			MusicCode:         p.Data.MusicCode,
+		Guild:             p.Data.Guild,
-			Guild:             p.Data.Guild,
+		PackUnlockCount:   p.Data.PackUnlockCount,
-			PackUnlockCount:   p.Data.PackUnlockCount,
+		LastPlayTime:      p.Data.LastPlayTime,
-			LastPlayTime:      p.Data.LastPlayTime,
+		EnergyBuyCount:    p.Data.EnergyBuyCount,
-			EnergyBuyCount:    p.Data.EnergyBuyCount,
+		LoginTime:         p.Data.LoginTime,
-			LoginTime:         p.Data.LoginTime,
+		UserName:          p.Data.UserName,
-			UserName:          p.Data.UserName,
+		LogoutTime:        p.Data.LogoutTime,
-			LogoutTime:        p.Data.LogoutTime,
+		Todayolinetime:    p.Data.Todayolinetime,
-			Todayolinetime:    p.Data.Todayolinetime,
+		Rolecreatetime:    p.Data.Rolecreatetime,
-			Rolecreatetime:    p.Data.Rolecreatetime,
+		LastChampGroupID:  p.Data.LastChampGroupID,
-			LastChampGroupID:  p.Data.LastChampGroupID,
+		ChampshipsGroupID: p.Data.ChampshipsGroupID,
-			ChampshipsGroupID: p.Data.ChampshipsGroupID,
+		NoAd:              p.Data.NoAd,
-			NoAd:              p.Data.NoAd,
+		FaceBookId:        p.Data.FaceBookId,
-			FaceBookId:        p.Data.FaceBookId,
-		},
-		MLeafTimer:     p.MLeafTimer,
-		MTicker:        p.MTicker,
-		McronSave:      p.McronSave,
-		McronSaveID:    p.McronSaveID,
-		Mdispatr:       p.Mdispatr,
-		DailyRenewTime: p.DailyRenewTime,
-		isKeyValueDb:   p.isKeyValueDb,
 	}
 }
 
@@ -609,8 +600,8 @@ func (p *PlayerBaseData) AddStar(cnt int) error {
 	if NewStar < 0 {
 		return errors.New("星星不足")
 	}
-
 	p.Data.Star = NewStar
+	p.M_Player.UpdateUserInfo()
 	return nil
 }
 

src/server/game/PlayerFunc.go

@@ -10,7 +10,9 @@ import (
 	"server/db"
 	"server/game/mod/card"
 	"server/game/mod/friend"
+	"server/game/mod/item"
 	"server/game/mod/msg"
+	"server/game/mod/playroom"
 	proto "server/msg"
 	"server/pkg/github.com/name5566/leaf/log"
 	"sort"
@@ -174,7 +176,7 @@ func handle(p *Player, m *msg.Msg) error {
 		}
 		p.PlayMod.save()
 		p.PushClientRes(CardMod.NotifyCard())
-	case msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY: // 锦标赛排名变动通知
+	case msg.HANDLE_TYPE_CHAMPSHIP_NOTIFY: // #  锦标赛排名变动通知
 		BackChampship(p)
 	case msg.HANDLE_TYPE_MAIL: // 邮件操作
 		MailMod := p.PlayMod.getMailMod()
@@ -199,6 +201,25 @@ func handle(p *Player, m *msg.Msg) error {
 				p.PushClientRes(MailMod.NotifyMail(MailId))
 			}
 		}
+	case msg.HANDLE_TYPE_PLAYROOM_LOSE: // #  玩家输了
+		PlayroomMod := p.PlayMod.getPlayroomMod()
+		Items := m.Extra.([]*item.Item)
+		if len(Items) == 0 {
+			return nil
+		}
+		PlayroomMod.AddChip()
+		PlayroomMod.AddMood(playroom.MOOD_TYPE_FOOD, -50)
+		PlayroomMod.AddMood(playroom.MOOD_TYPE_CLEAN, -50)
+		PlayroomMod.AddVisitor(m.From, m.SendT)
+		p.AddLog(m.From, friend.LOG_TYPE_PLAYROOM_VISIT, fmt.Sprintf("%d,%d", Items[0].Id, Items[0].Num))
+		if Items[0].Id == item.ITEM_STAR_ID {
+			ItemMod := p.PlayMod.getItemMod()
+			StarNum := ItemMod.GetItem(item.ITEM_STAR_ID)
+			Items[0].Num = min(Items[0].Num, StarNum)
+			p.HandleLoseItem(Items, "")
+		} else {
+			PlayroomMod.Lose(Items)
+		}
 	}
 	return nil
 }
@@ -440,3 +461,158 @@ func BackChampship(p *Player) {
 	MyPreRank := G_GameLogicPtr.ChampshipMgr.getLastMyRank(int(p.M_DwUin))
 	p.PushClientRes(ChampshipMod.BackData(MyRank, MyPreRank))
 }
+
+func PlayroomOrderTrigger(p *Player) error {
+	OrderMod := p.PlayMod.getOrderMod()
+	Lv := p.GetPlayerBaseMod().GetLevel()
+	Emit := p.PlayMod.getChessMod().GetEmitList()
+	EnergyMul := p.PlayMod.getBaseMod().GetEnergyMul()
+	Star, err := OrderMod.CreateTriggerOrder(Lv, Emit, EnergyMul)
+	if err != nil {
+		log.Debug("uid : %d, PlayroomOrderTrigger, err : %s", p.M_DwUin, err)
+		return err
+	}
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	PlayroomMod.CreateOrderReward(Star, p.PlayMod.getItemMod())
+	p.PlayMod.save()
+	return nil
+}
+
+func PlayroomBackData(p *Player) {
+	r := &proto.ResPlayroom{}
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	FriendMod := p.PlayMod.getFriendMod()
+	r.Status = int32(PlayroomMod.Status)
+	r.Items = item.ItemToMsg(PlayroomMod.Reward)
+	Opponent := make([]*proto.RoomOpponent, 0)
+	FriendList := make([]*proto.FriendRoom, 0)
+	for k, v := range PlayroomMod.Visitor {
+		ps := G_GameLogicPtr.GetSimplePlayerByUid(k)
+		if ps == nil {
+			continue
+		}
+		if FriendMod.CheckFriend(k) {
+			FriendList = append(FriendList, &proto.FriendRoom{
+				Uid:    int32(k),
+				Name:   ps.Name,
+				Face:   int32(ps.Face),
+				Avatar: int32(ps.Avatar),
+				Times:  int32(v.Times),
+			})
+		} else {
+			Opponent = append(Opponent, &proto.RoomOpponent{
+				Uid:      int32(k),
+				Name:     ps.Name,
+				Face:     int32(ps.Face),
+				Avatar:   int32(ps.Avatar),
+				LastTime: int32(v.Time),
+			})
+		}
+	}
+	r.Opponent = Opponent
+	r.Friend = FriendList
+	Collect := make([]int32, 0)
+	for k, v := range PlayroomMod.GetCollect() {
+		if v > 0 {
+			Collect = append(Collect, int32(k))
+		}
+	}
+	r.Collect = Collect
+	r.Playroom = GoUtil.MapIntToInt32(PlayroomMod.GetRoom())
+	r.Mood = GoUtil.MapIntToInt32(PlayroomMod.GetMood())
+	p.PushClientRes(r)
+}
+
+func PlayroomVisit(p *Player, Uid int) {
+	if Uid == 0 {
+		return
+	}
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	r := &proto.ResPlayroomInfo{}
+	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Uid)
+	r.Uid = int32(Uid)
+	r.Name = PlayerData.Name
+	r.Face = int32(PlayerData.Face)
+	r.Avatar = int32(PlayerData.Avatar)
+	r.Playroom = GoUtil.MapIntToInt32(PlayerData.Playroom)
+	r.GameId = int32(PlayroomMod.GameId)
+	Items := make(map[int32]*proto.ItemInfo, 0)
+	for k, v := range PlayroomMod.GameReward {
+		Items[int32(k)] = &proto.ItemInfo{
+			Id:  int32(k),
+			Num: int32(v.Num),
+		}
+	}
+	r.Items = Items
+	r.Status = int32(PlayroomMod.GameStatus)
+	p.PushClientRes(r)
+}
+
+func GetVisitorPlayer(p *Player) int {
+	PlayroomMod := p.PlayMod.getPlayroomMod()
+	VisitorList := PlayroomMod.GetVisitor()
+	HasVisit := PlayroomMod.GetHasVisit()
+	type sortData struct {
+		Uid  int
+		Time int64
+	}
+	PlayerList := make([]sortData, 0)
+
+	Now := GoUtil.Now()
+	for k, v := range VisitorList {
+		if _, ok := HasVisit[k]; ok {
+			continue
+		}
+		if v.Time < Now-86400 {
+			continue
+		}
+		PlayerList = append(PlayerList, sortData{k, v.Time})
+	}
+	if len(PlayerList) != 0 {
+		sort.Slice(PlayerList, func(i, j int) bool {
+			return PlayerList[i].Time < PlayerList[j].Time
+		})
+		return PlayerList[0].Uid
+	}
+	FriendMod := p.PlayMod.getFriendMod()
+	PlayerList2 := make([]sortData, 0)
+	for _, v := range PlayerList {
+		if FriendMod.CheckFriend(v.Uid) {
+			continue
+		}
+	}
+	if len(PlayerList2) != 0 {
+		sort.Slice(PlayerList2, func(i, j int) bool {
+			return PlayerList2[i].Time < PlayerList2[j].Time
+		})
+		return PlayerList2[0].Uid
+	}
+
+	return GetRecommendPlayer(p, 1)[0]
+}
+
+func GetRecommendPlayer(p *Player, Num int) []int {
+	PlayerList := G_GameLogicPtr.RankMgr.getAllRank(RANK_TYPE_USER)
+	PlayerList1 := make([]int, 0)
+	FriendMod := p.PlayMod.getFriendMod()
+	for _, v := range PlayerList {
+		if v.Score < 15 {
+			continue
+		}
+		if v.Uid == int(p.M_DwUin) {
+			continue
+		}
+		if FriendMod.CheckApply(v.Uid) {
+			continue
+		}
+		if FriendMod.CheckFriend(v.Uid) {
+			continue
+		}
+		PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(v.Uid)
+		if GoUtil.Now()-PlayerSimpleData.Loginout > 86400 {
+			continue
+		}
+		PlayerList1 = append(PlayerList1, v.Uid)
+	}
+	return GoUtil.RandSliceNum(PlayerList1, Num)
+}

src/server/game/PlayerMod.go

@@ -28,6 +28,7 @@ import (
 	"server/game/mod/mining"
 	"server/game/mod/order"
 	"server/game/mod/piggyBank"
+	"server/game/mod/playroom"
 	"server/game/mod/race"
 	"server/game/mod/sevenLogin"
 	Var "server/game/mod/var"
@@ -43,31 +44,32 @@ type PlayerModData struct {
 
 // PlayerModList 玩家模块列表
 type PlayerModList struct {
-	Base             base.Base
+	Base             base.Base                            // 基础信息
-	Chess            chess.ChessBorad
+	Chess            chess.ChessBorad                     // 棋盘
-	Handbook         handbook.Handbook
+	Handbook         handbook.Handbook                    // 图鉴
-	Order            order.OrderMod
+	Order            order.OrderMod                       //订单
-	Decorate         decorate.Decorate
+	Decorate         decorate.Decorate                    //装饰
-	Card             card.CardMod
+	Card             card.CardMod                         //卡牌
-	Var              Var.Var
+	Var              Var.Var                              // 变量
-	Guild            guild.Guild
+	Guild            guild.Guild                          // 引导
-	DailyTask        dailyTask.DailyTaskMod
+	DailyTask        dailyTask.DailyTaskMod               // 每日任务
-	Face             face.FaceMod
+	Face             face.FaceMod                         // 头像
-	Avatar           avatar.AvatarMod
+	Avatar           avatar.AvatarMod                     // 头像框
-	SevenLogin       sevenLogin.SevenLoginMod
+	SevenLogin       sevenLogin.SevenLoginMod             // 七天签到
-	LimitedTimeEvent limitedTimeEvent.LimitedTimeEventMod
+	LimitedTimeEvent limitedTimeEvent.LimitedTimeEventMod // 限时事件
-	Friend           friend.FriendMod
+	Friend           friend.FriendMod                     // 好友
-	Mail             mail.MailMod
+	Mail             mail.MailMod                         // 邮件
-	Charge           charge.ChargeMod
+	Charge           charge.ChargeMod                     // 商店充值
-	Endless          endless.EndlessMod
+	Endless          endless.EndlessMod                   // 无尽礼包
-	PiggyBank        piggyBank.PiggyBankMod
+	PiggyBank        piggyBank.PiggyBankMod               // 小猪存钱
-	Champship        champship.ChampshipMod
+	Champship        champship.ChampshipMod               // 锦标赛
-	Invite           invite.InviteMod
+	Invite           invite.InviteMod                     // 邀请
-	Kv               kv.KvMod
+	Kv               kv.KvMod                             //  客户端数据
-	Mining           mining.MiningMod
+	Mining           mining.MiningMod                     // 挖矿活动
-	Item             item.ItemMod
+	Item             item.ItemMod                         // 道具
-	GuessColor       guesscolor.GuessColorMod
+	GuessColor       guesscolor.GuessColorMod             // 猜颜色活动
-	Race             race.RaceMod
+	Race             race.RaceMod                         // 竞赛活动
+	Playroom         playroom.PlayroomMod                 // 玩家小屋
 }
 
 func (p *PlayerModData) LoadDataFromDB(dwUin interface{}) bool {
@@ -148,6 +150,7 @@ func (p *PlayerModData) InitMod() (bool, error) {
 	p.ModList.Mining.InitData()
 	p.ModList.Item.InitData()
 	p.ModList.GuessColor.InitData()
+	p.ModList.Playroom.InitData()
 
 	return is_update, nil
 }
@@ -298,3 +301,7 @@ func (p *PlayerMod) getGuessColorMod() *guesscolor.GuessColorMod {
 func (p *PlayerMod) getRaceMod() *race.RaceMod {
 	return &p.mod_list.Race
 }
+
+func (p *PlayerMod) getPlayroomMod() *playroom.PlayroomMod {
+	return &p.mod_list.Playroom
+}

src/server/game/RankMgr.go

@@ -78,6 +78,13 @@ func (r *RankMgr) getRank(RankType int) []*Rank {
 	return []*Rank{}
 }
 
+func (r *RankMgr) getAllRank(RankType int) []*Rank {
+	if v, ok := r.getData().List[RankType]; ok {
+		return v
+	}
+	return []*Rank{}
+}
+
 func (r *RankMgr) getMyRank(Uid, RankType int) (int, float64) {
 	if d, ok := r.getData().List[RankType]; ok {
 		for k, v := range d {

src/server/game/RegisterNetworkFunc.go

@@ -17,6 +17,7 @@ import (
 	"server/game/mod/limitedTimeEvent"
 	MsqMod "server/game/mod/msg"
 	"server/game/mod/piggyBank"
+	"server/game/mod/quest"
 	"server/msg"
 	"strconv"
 
@@ -37,7 +38,6 @@ func ReqPlayerBaseInfofunction(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerBaseData"] = data
-			player.playerdataIF["PlayerBaseData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).ResPlayerBaseInfo(player)
@@ -88,7 +88,6 @@ func ReqPlayerChessDataFunc(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerChessData"] = data
-			player.playerdataIF["PlayerChessData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerChessData").(*PlayerChessData).ResPlayerChessData(player)
@@ -103,7 +102,6 @@ func ReqBindFacebookAccount(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerBaseData"] = data
-			player.playerdataIF["PlayerBaseData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).ReqBindFacebookAccount(buf)
@@ -118,7 +116,6 @@ func ReqUnBindFacebook(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerBaseData"] = data
-			player.playerdataIF["PlayerBaseData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).ReqUnBindFacebook(buf)
@@ -133,7 +130,6 @@ func ReqOnlyBindFacebook(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerBaseData"] = data
-			player.playerdataIF["PlayerBaseData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).ReqOnlyBindFacebook(buf)
@@ -148,7 +144,6 @@ func ReqSynGameData(args []interface{}) error {
 		ok := data.LoadDataFromDB(player.M_DwUin)
 		if ok {
 			player.playerdata["PlayerBaseData"] = data
-			player.playerdataIF["PlayerBaseData"] = data
 		}
 	}
 	player.GetIFGameData("PlayerBaseData").(*PlayerBaseData).ReqSynGameData(buf)
@@ -172,8 +167,13 @@ func RegSetEneryFunc(args []interface{}) error {
 		"change_to":   math.Pow(2, float64(req.EnergyMul)),
 		"is_auto":     false,
 	})
-
 	player.PlayMod.getBaseMod().SetEnergyMul(int(req.EnergyMul))
+	OrderMod := player.PlayMod.getOrderMod()
+	Lv := player.GetPlayerBaseMod().GetLevel()
+	Emit := player.PlayMod.getChessMod().GetEmitList()
+	ChessList := player.PlayMod.getChessMod().GetChessList()
+	OrderMod.ChangeEnergyMul(Lv, Emit, int(req.EnergyMul), ChessList)
+	player.PushClientRes(OrderMod.BackData())
 	player.PushClientRes(player.PlayMod.getBaseMod().BackData())
 	return nil
 }
@@ -192,7 +192,7 @@ func ReqGetHandbookReward(args []interface{}) error {
 		return err
 	}
 	var itemList []*item.Item
-	itemList = append(itemList, &item.Item{Id: item.ITEM_DIAMOND_ID, Num: 1})
+	itemList = append(itemList, &item.Item{Id: item.ITEM_ENERGY_ID, Num: 5})
 	err = player.HandleItem(itemList, "HandbookReward")
 	if err != nil {
 		player.SendErrClienRes(&msg.ResGetHandbookReward{
@@ -289,6 +289,8 @@ func ReqRewardOrder(args []interface{}) error {
 		return err
 	}
 
+	// 每日任务
+	player.QuestTrigger(&quest.Trigger{Label: quest.TRIGGER_LABEL_FINISHORDER})
 	player.TeLog("order_finish", map[string]interface{}{
 		"order_id":          int(req.OrderId),
 		"order_item_id":     mergeList,
@@ -297,8 +299,9 @@ func ReqRewardOrder(args []interface{}) error {
 	})
 
 	Lv := player.GetPlayerBaseMod().GetLevel()
+	EnergyMul := player.PlayMod.getBaseMod().GetEnergyMul()
 	Emit := ChessMod.GetEmitList()
-	OrderMod.CreateOrder(Lv, Emit)
+	OrderMod.CreateOrder(Lv, Emit, EnergyMul)
 
 	// 存钱罐增加钻石
 	PiggyBankMod := player.PlayMod.getPiggyBankMod()
@@ -309,6 +312,15 @@ func ReqRewardOrder(args []interface{}) error {
 		ChampshipMod := player.PlayMod.getChampshipMod()
 		ChampshipMod.AddScore(mergeList)
 	}
+	// playroom 触发式订单
+	err = PlayroomOrderTrigger(player)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResRewardOrder{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
 
 	// 限时事件增加进度
 	LimitedTimeEventMod.AddProgress(player.GetPlayerBaseMod().GetLevel())
@@ -472,6 +484,7 @@ func UpdatePlayerChessDataFunc(args []interface{}) error {
 	data := player.GetIFGameData("PlayerChessData")
 	err := data.(*PlayerChessData).UpdatePlayerChessData(buf)
 	RedBackData(player)
+	player.UpdateUserInfo()
 	return err
 }
 
@@ -516,6 +529,7 @@ func ReqGetChessFromBuff(args []interface{}) error {
 	player.PushClientRes(&msg.ResGetChessFromBuff{
 		Code: msg.RES_CODE_SUCCESS,
 	})
+	player.UpdateUserInfo()
 	return nil
 }
 
@@ -547,6 +561,7 @@ func ReqPutChessInBag(args []interface{}) error {
 	player.PushClientRes(&msg.ResPutChessInBag{
 		Code: msg.RES_CODE_SUCCESS,
 	})
+	player.UpdateUserInfo()
 	return nil
 }
 
@@ -577,6 +592,7 @@ func ReqTakeChessOutBag(args []interface{}) error {
 	player.PushClientRes(&msg.ResTakeChessOutBag{
 		Code: msg.RES_CODE_SUCCESS,
 	})
+	player.UpdateUserInfo()
 	return nil
 }
 
@@ -643,6 +659,8 @@ func ReqChessEx(args []interface{}) error {
 		})
 		return err
 	}
+	HandbookMod := player.PlayMod.getHandbookMod()
+	HandbookMod.SetHandbook(int(req.NewChessId))
 	data := player.GetIFGameData("PlayerChessData")
 	err = data.(*PlayerChessData).UpdateChessData(req.MChessData)
 	if err != nil {
@@ -1902,7 +1920,7 @@ func ReqBuyChessShop(args []interface{}) error {
 	req := &msg.ReqBuyChessShop{}
 	proto.Unmarshal(buf, req)
 	ChargeMod := player.PlayMod.getChargeMod()
-	Item, err := ChargeMod.BuyChess(int(req.Id))
+	LostItem, Item, _, err := ChargeMod.BuyChess(int(req.Id))
 	if err != nil {
 		player.SendErrClienRes(&msg.ResBuyChessShop{
 			Code: msg.RES_CODE_FAIL,
@@ -1910,6 +1928,14 @@ func ReqBuyChessShop(args []interface{}) error {
 		})
 		return err
 	}
+	err = player.HandleLoseItem(LostItem, "ChessShop")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResBuyChessShop2{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
 	err = player.HandleItem(Item, "ChessShop")
 	if err != nil {
 		player.SendErrClienRes(&msg.ResBuyChessShop{
@@ -1937,6 +1963,65 @@ func ReqBuyChessShop(args []interface{}) error {
 	return nil
 }
 
+// 购买棋子商店物品
+func ReqBuyChessShop2(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqBuyChessShop2{}
+	proto.Unmarshal(buf, req)
+	ChargeMod := player.PlayMod.getChargeMod()
+	LostItem, _, ChessId, err := ChargeMod.BuyChess(int(req.Id))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResBuyChessShop2{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleLoseItem(LostItem, "ChessShop")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResBuyChessShop2{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	ChessMod := player.PlayMod.getChessMod()
+	err = ChessMod.AddChess(ChessId)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResBuyChessShop2{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	data := player.GetIFGameData("PlayerChessData")
+	err = data.(*PlayerChessData).UpdateChessData(req.MChessData)
+	if err != nil {
+		player.SendErrClienRes(&msg.ResBuyChessShop2{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.TeLog("store_buy", map[string]interface{}{
+		"item_id":    int(req.Id),
+		"change_num": 1,
+		"cost_type":  "diamond",
+		"cost_num":   LostItem[0].Num,
+	})
+	player.PlayMod.save()
+	player.PushClientRes(ChargeMod.BackData())
+	player.PushClientRes(&msg.ResBuyChessShop2{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	player.TeLog("buy_product_diamond", map[string]interface{}{
+		"diamond_cost": LostItem[0].Num,
+		"product_id":   int(req.Id),
+		"product_name": mergeDataCfg.GetNameById(int(req.Id)),
+	})
+	return nil
+}
+
 // 刷新棋子商店
 func ReqRefreshChessShop(args []interface{}) error {
 	_, player, _ := ParseArgs(args)
@@ -2146,25 +2231,26 @@ func ReqKv(args []interface{}) error {
 func ReqFriendRecommend(args []interface{}) error {
 	_, player, _ := ParseArgs(args)
 	FriendMod := player.PlayMod.getFriendMod()
-	List := G_GameLogicPtr.RankMgr.getRank(RANK_TYPE_USER)
 	RecommendList := make([]*msg.ResPlayerSimple, 0)
-	n := 0
+	FriendNum := FriendMod.GetFriendNum()
-	for _, v := range List {
+	var n int
-		if n > 3 {
+	if FriendNum < 10 {
-			break
+		n = 3
-		}
+	} else {
-		PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(v.Uid)
+		Active := 0
-		if v.Uid == int(player.M_DwUin) {
+		for k := range FriendMod.FriendList {
-			continue
+			PlayerSimpleData := G_GameLogicPtr.GetSimplePlayerByUid(k)
-		}
+			if PlayerSimpleData.Login > GoUtil.Now()-86400 {
-		if FriendMod.CheckFriend(v.Uid) {
+				Active++
-			continue
+			}
-		}
-		if FriendMod.CheckApply(v.Uid) {
-			continue
 		}
+		n = max(0, 3-(Active/10))
+	}
+	PlayerList := GetRecommendPlayer(player, n)
+
+	for _, v := range PlayerList {
+		PlayerSimpleData := G_GameLogicPtr.GetResSimplePlayerByUid(v)
 		RecommendList = append(RecommendList, PlayerSimpleData)
-		n++
 	}
 	player.PushClientRes(&msg.ResFriendRecommend{
 		List: RecommendList,
@@ -2627,3 +2713,276 @@ func ReqRaceReward(args []interface{}) error {
 	})
 	return nil
 }
+
+// 请求playroom基础数据
+func ReqPlayroom(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	PlayroomBackData(player)
+	return nil
+}
+
+// 请求playroom拜访信息
+func ReqPlayroomInfo(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomInfo{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Targer := int(req.Uid)
+	if req.Uid == 0 {
+		Targer = PlayroomMod.GetTarget()
+	}
+	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Targer)
+	PlayroomMod.SetTarget(Targer)
+	if PlayerData.Loginout < GoUtil.Now()-300 {
+		PlayroomMod.SetGameId(1)
+	} else {
+		PlayroomMod.SetGameId(2)
+	}
+	PlayroomVisit(player, Targer)
+	return nil
+}
+
+// 请求playroom交互
+func ReqPlayroomInteract(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomInteract{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Items, err := PlayroomMod.Interact(int(req.Id), int(req.Type))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomInteract{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, "PlayroomInteract")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomInteract{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	player.PushClientRes(&msg.ResPlayroomInteract{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+// 请求playroom设置房间
+func ReqPlayroomSetRoom(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomSetRoom{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	err := PlayroomMod.SetRoom(int(req.Id), int(req.Pos))
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomSetRoom{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	player.PushClientRes(&msg.ResPlayroomSetRoom{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqPlayroomGame(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomGame{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Target := PlayroomMod.GetTarget()
+	if Target == 0 {
+		player.SendErrClienRes(&msg.ResPlayroomGame{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  "no target",
+		})
+		return fmt.Errorf("no target")
+	}
+	PlayerData := G_GameLogicPtr.GetSimplePlayerByUid(Target)
+	Items := make([]*item.Item, 0)
+	if req.Type == 1 {
+		Items = append(Items, item.NewItem(item.ITEM_STAR_ID, PlayerData.Level*2))
+		PlayroomMod.ResetGame()
+	}
+	if req.Type == 2 {
+		Items = append(Items, item.NewItem(item.ITEM_STAR_ID, PlayerData.Level*3))
+		PlayroomMod.ResetGame()
+	}
+	if req.Type == 3 {
+		Star := min(500, max(PlayerData.Star/10, 10))
+		ChessMod := player.PlayMod.getChessMod()
+		EmitList := ChessMod.GetEmitList()
+		ColorList := make([]string, 0)
+		for _, v := range EmitList {
+			Color := mergeDataCfg.GetEmitProduceChessType(v)
+			ColorList = append(ColorList, Color...)
+		}
+		RandList := make([]int, 0)
+		for _, v := range PlayerData.Chess {
+			Color := mergeDataCfg.GetColorById(v)
+			Lv := mergeDataCfg.GetLvById(v)
+			if GoUtil.InStringArray(Color, ColorList) && Lv <= 8 {
+				RandList = append(RandList, v)
+			}
+		}
+		if len(RandList) == 0 {
+			PlayroomMod.SetGameReward(0, 0, Star)
+		} else if len(RandList) == 1 {
+			PlayroomMod.SetGameReward(0, RandList[0], Star)
+		} else {
+			ChessList := GoUtil.RandSliceNum(RandList, 2)
+			PlayroomMod.SetGameReward(ChessList[0], ChessList[1], Star)
+		}
+	}
+	err := player.HandleItem(Items, "playroomGame")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomGame{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	PlayroomVisit(player, PlayroomMod.GetTarget())
+	player.PushClientRes(&msg.ResPlayroomGame{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqPlayroomSelectReward(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomSelectReward{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Items := PlayroomMod.SelectReward(int(req.Id))
+	err := player.HandleItem(Items, "playroomGame")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomSelectReward{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	Target := PlayroomMod.GetTarget()
+	G_GameLogicPtr.FriendMgrSend(&MsqMod.Msg{
+		From:  int(player.M_DwUin),
+		To:    Target,
+		Type:  MsqMod.HANDLE_TYPE_DEL,
+		SendT: GoUtil.Now(),
+	})
+	PlayroomMod.ResetGame()
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	PlayroomVisit(player, PlayroomMod.GetTarget())
+	player.PushClientRes(&msg.ResPlayroomSelectReward{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqPlayroomLose(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	PlayroomMod.ResetGame()
+	return nil
+}
+
+func ReqPlayroomWork(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomWork{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Items, err := PlayroomMod.Work()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomWork{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, "playroomWork")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomWork{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	player.PushClientRes(PlayroomMod.NotifyWork())
+	// PlayroomBackData(player)
+	player.PushClientRes(&msg.ResPlayroomWork{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}
+
+func ReqPlayroomRest(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	PlayroomMod.Rest()
+	player.PlayMod.save()
+	player.PushClientRes(PlayroomMod.NotifyWork())
+	return nil
+}
+
+func ReqPlayroomDraw(args []interface{}) error {
+	_, player, _ := ParseArgs(args)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Id, Items, err := PlayroomMod.Draw()
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomDraw{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	err = player.HandleItem(Items, "playroomDraw")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomDraw{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	player.PushClientRes(&msg.ResPlayroomDraw{
+		Code: msg.RES_CODE_SUCCESS,
+		Id:   int32(Id),
+	})
+	return nil
+}
+
+func ReqPlayroomChip(args []interface{}) error {
+	_, player, buf := ParseArgs(args)
+	req := &msg.ReqPlayroomChip{}
+	proto.Unmarshal(buf, req)
+	PlayroomMod := player.PlayMod.getPlayroomMod()
+	Items := PlayroomMod.RemoveChip(int(req.Num))
+	err := player.HandleItem(Items, "playroomChip")
+	if err != nil {
+		player.SendErrClienRes(&msg.ResPlayroomChip{
+			Code: msg.RES_CODE_FAIL,
+			Msg:  err.Error(),
+		})
+		return err
+	}
+	player.PlayMod.save()
+	PlayroomBackData(player)
+	player.PushClientRes(&msg.ResPlayroomChip{
+		Code: msg.RES_CODE_SUCCESS,
+	})
+	return nil
+}

src/server/game/ServerMod.go

@@ -1,6 +1,8 @@
 package game
 
 import (
+	"context"
+	"database/sql"
 	"fmt"
 	"server/GoUtil"
 	"server/db"
@@ -45,7 +47,7 @@ func (s *ServerMod) init() {
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Debug("FriendMgr panic: %s", r)
+				log.Debug("%s panic: %s", s.key, r)
 				s.lock.Unlock()
 			}
 		}()
@@ -137,10 +139,15 @@ func (s *ServerMod) SaveData() {
 		log.Debug("SaveData Marshal failed,Mod Key: %s err:%v", s.key, err)
 	}
 	// log.Debug("SaveData Marshal success,Mod Key: %s", s.key)
+	ctx := context.Background()
+	txOptions := &sql.TxOptions{}
+	tx, err := db.SqlDb.BeginTx(ctx, txOptions)
 	err = db.SaveServerData(&DbData)
 	if err != nil {
+		tx.Rollback()
 		log.Debug("SaveData sql exec ,Mod Key: %s err:%v", s.key, err)
 	}
+	tx.Commit()
 }
 
 func (s *ServerMod) LoadData() {

src/server/game/Type.go

@@ -7,10 +7,13 @@ type PlayerSimpleData struct {
 	Level       int
 	Face        int
 	Decorate    int
+	Star        int
 	Login       int64
 	Loginout    int64
 	FaceBook    string
 	FaceBookPic string
+	Playroom    map[int]int
+	Chess       []int
 }
 
 type VarGoldCard struct {

src/server/game/UnitTest.go

@@ -1,6 +1,9 @@
 package game
 
-import "fmt"
+import (
+	"fmt"
+	"server/game/mod/order"
+)
 
 func UnitEndlessReward(p *Player) error {
 	EndlessMod := p.PlayMod.getEndlessMod()
@@ -44,6 +47,12 @@ func UnitChessShop(p *Player) error {
 func UnitOrder(p *Player) error {
 	OrderMod := p.PlayMod.getOrderMod()
 	ChessMod := p.PlayMod.getChessMod()
-	err := OrderMod.CreateOrder(6, ChessMod.GetEmitList())
+	OrderMod.OrderList = make(map[int]order.Order)
-	return err
+	for i := 0; i < 150; i++ {
+		err := OrderMod.CreateNormalOrder(6, ChessMod.GetEmitList(), 3)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }

src/server/game/VarMgr.go

@@ -27,8 +27,6 @@ func (f *VarMgr) Init() {
 	// 注册处理函数
 	f.init()
 	f.initData()
-	f.RegisterHandler(msg.HANDLE_TYPE_VAR_GET, f.GetVar)
-	f.RegisterHandler(msg.HANDLE_TYPE_VAR_SET, f.SetVar)
 	f.RegisterHandler(msg.SERVER_ZERO_UPDATE, f.ZeroUpdate)
 }
 
@@ -46,13 +44,14 @@ func (f *VarMgr) initData() {
 	}
 }
 
-func (f *VarMgr) ZeroUpdate() {
+func (f *VarMgr) ZeroUpdate(m *msg.Msg) (interface{}, error) {
 	// 随机生成两个金卡
 	Card1, Card2 := card.RankGoldCard()
 	f.SetVar(VAR_GOLD_CARD, &VarGoldCard{
 		Four: Card1,
 		Five: Card2,
 	})
+	return nil, nil
 }
 
 func (f *VarMgr) SetVar(key string, value interface{}) {

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

@@ -231,7 +231,7 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 	list := make([]int, 0)
 	for _, v := range Emit {
 		n := 6
-		ProductColor := mergeDataCfg.GetEmitProduceType(v)
+		ProductColor := mergeDataCfg.GetEmitProduceChessType(v)
 		if len(ProductColor) == 0 {
 			continue
 		}
@@ -264,20 +264,21 @@ func (c *ChargeMod) InitChessShop(Emit []int) {
 	}
 }
 
-func (c *ChargeMod) BuyChess(Chess int) ([]*item.Item, error) {
+func (c *ChargeMod) BuyChess(Chess int) ([]*item.Item, []*item.Item, int, error) {
 	v, ok := c.ChessShop[Chess]
 	if !ok {
-		return nil, fmt.Errorf("BuyChess chess id not exist id:%d", Chess)
+		return nil, nil, 0, fmt.Errorf("BuyChess chess id not exist id:%d", Chess)
 	}
 
 	if v.Count <= 0 {
-		return nil, fmt.Errorf("BuyChess chess count less zero id:%d", Chess)
+		return nil, nil, 0, fmt.Errorf("BuyChess chess count less zero id:%d", Chess)
 	}
 	v.Count--
 	return []*item.Item{
-		item.NewItem(item.ITEM_DIAMOND_ID, -v.Diamond),
+			item.NewItem(item.ITEM_DIAMOND_ID, v.Diamond),
-		item.NewItem(v.Id, 1),
+		}, []*item.Item{
-	}, nil
+			item.NewItem(v.Id, 1),
+		}, v.Id, nil
 }
 
 func (c *ChargeMod) TriggerChargeUnlock(Lv int, Emit []int) {

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

@@ -27,6 +27,7 @@ const (
 	LOG_TYPE_CARD_EX_SUCCESS_1 = 10 // 卡牌交换成功
 	LOG_TYPE_CARD_EX_SUCCESS_2 = 11 // 卡牌交换成功
 	LOG_TYPE_FRIEND_DELETE     = 14 // 删除好友
+	LOG_TYPE_PLAYROOM_VISIT    = 15 // 拜访玩家
 )
 
 const (
@@ -94,6 +95,9 @@ func (f *FriendMod) CheckApply(id int) bool {
 	_, ok := f.ApplyList[id]
 	return ok
 }
+func (f *FriendMod) GetFriendNum() int {
+	return len(f.FriendList)
+}
 
 func (f *FriendMod) AddFriendApply(Uid int) {
 	f.ApplyList[Uid] = GoUtil.Now()

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

@@ -36,6 +36,7 @@ const (
 	ITEM_TYPE_AVATAR            = 105 // 头像框
 	ITEM_TYPE_ACTIVITY          = 106 // 活动道具
 	ITEM_TYPE_ACTIVITY_RACE     = 107 // 竞赛活动道具
+	ITEM_TYPE_PLAYROOM_VISIT    = 108 // playroom拜访道具
 )
 
 func (i *ItemMod) InitData() {

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

@@ -222,6 +222,7 @@ func (l *LimitedTimeEventMod) AddProgress(Lv int) {
 	if l.Progress == ProgressMax {
 		SelectNum := limitedTimeEventCfg.GetProgressSelectNum(Lv)
 		RandMap := limitedTimeEventCfg.GetProgressRewardRand(Lv)
+		delete(RandMap, l.LastSelect)
 		r := GoUtil.RandMapNum(RandMap, SelectNum)
 		Id := 1
 		for _, v := range r {

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

@@ -16,52 +16,53 @@ var MSG_ZERO_UPDATE = &Msg{Type: SERVER_ZERO_UPDATE}
 
 const (
 	//好友操作
-	HANDLE_TYPE_APPLY  = 1  //申请好友
+	HANDLE_TYPE_APPLY  = iota //申请好友
-	HANDLE_TYPE_DEL    = 2  //删除好友
+	HANDLE_TYPE_DEL           //删除好友
-	HANDLE_TYPE_SYNC   = 3  //同步请求
+	HANDLE_TYPE_SYNC          //同步请求
-	HADNLE_TYPE_AGREE  = 4  //同意好友
+	HADNLE_TYPE_AGREE         //同意好友
-	HANDLE_TYPE_REFUSE = 12 //拒绝申请
+	HANDLE_TYPE_REFUSE        //拒绝申请
 
 	//卡牌操作
-	HANDLE_TYPE_REQ_CARD        = 5  //请求卡牌
+	HANDLE_TYPE_REQ_CARD        //请求卡牌
-	HANDLE_TYPE_AGREE_CARD      = 6  //同意卡牌
+	HANDLE_TYPE_AGREE_CARD      //同意卡牌
-	HANDLE_TYPE_REG_CARD_REFUSE = 12 //拒绝请求卡牌
+	HANDLE_TYPE_REG_CARD_REFUSE //拒绝请求卡牌
-	HANDLE_TYPE_REG_CARD_FINISH = 13 //请求卡牌已结束
+	HANDLE_TYPE_REG_CARD_FINISH //请求卡牌已结束
-	HANDLE_TYPE_AGREE_CARD_FAIL = 14 //同意卡牌失败
+	HANDLE_TYPE_AGREE_CARD_FAIL //同意卡牌失败
 
-	HANDLE_TYPE_EX_CARD            = 7  //置换卡牌
+	HANDLE_TYPE_EX_CARD            //置换卡牌
-	HANDLE_TYPE_SELECT_EX_CARD     = 8  //选择置换卡牌
+	HANDLE_TYPE_SELECT_EX_CARD     //选择置换卡牌
-	HANDLE_TYPE_ARGREE_EX_CARD     = 9  //同意置换卡牌
+	HANDLE_TYPE_ARGREE_EX_CARD     //同意置换卡牌
-	HANDLE_TYPE_REFUSE_SELECT_CARD = 10 //B拒绝选择置换卡牌
+	HANDLE_TYPE_REFUSE_SELECT_CARD //B拒绝选择置换卡牌
-	HANDLE_TYPE_REFUSE_EX_CARD     = 11 //A拒绝置换卡牌
+	HANDLE_TYPE_REFUSE_EX_CARD     //A拒绝置换卡牌
 
-	HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT = 18 //置换卡牌选择超时
+	HANDLE_TYPE_EX_CARD_SELECT_TIMEOUT //置换卡牌选择超时
-	HANDLE_TYPE_EX_CARD_TIMEOUT        = 19 //置换卡牌超时
+	HANDLE_TYPE_EX_CARD_TIMEOUT        //置换卡牌超时
 
-	HANDLE_TYPE_SEND_CARD = 15 //赠送卡牌
+	HANDLE_TYPE_SEND_CARD //赠送卡牌
 
-	HANDLE_TYPE_INVITE_FRIEND     = 16 //邀请好友
+	HANDLE_TYPE_INVITE_FRIEND     //邀请好友
-	HANDLE_TYPE_INVITE_ADD_FRIEND = 17 //自动添加好友
+	HANDLE_TYPE_INVITE_ADD_FRIEND //自动添加好友
 	// 榜单操作
-	HANDLE_TYPE_RANK        = 101 //榜单操作
+	HANDLE_TYPE_RANK        //榜单操作
-	HANDLE_TYPE_RANK_INFO   = 102 //榜单信息
+	HANDLE_TYPE_RANK_INFO   //榜单信息
-	HANDLE_TYPE_RANK_NOTIFY = 103 //榜单信息
+	HANDLE_TYPE_RANK_NOTIFY //榜单信息
 	// 邮件操作
-	HANDLE_TYPE_MAIL = 201 //邮件操作
+	HANDLE_TYPE_MAIL //邮件操作
 
 	// 锦标赛
-	HANDLE_TYPE_CHAMPSHIP_GROUP   = 301 //锦标赛分组操作
+	HANDLE_TYPE_CHAMPSHIP_GROUP   //锦标赛分组操作
-	HANDLE_TYPE_CHAMPSHIP_INRANK  = 302 //锦标赛入榜操作
+	HANDLE_TYPE_CHAMPSHIP_INRANK  //锦标赛入榜操作
-	HANDLE_TYPE_CHAMPSHIP_AI      = 303 //锦标赛入榜操作
+	HANDLE_TYPE_CHAMPSHIP_AI      //锦标赛入榜操作
-	HANDLE_TYPE_CHAMPSHIP_NOTIFY  = 304 //锦标赛排名变动通知
+	HANDLE_TYPE_CHAMPSHIP_NOTIFY  //锦标赛排名变动通知
-	HANDLE_TYPE_CHAMPSHIP_ZERO    = 305 //锦标赛0点更新
+	HANDLE_TYPE_CHAMPSHIP_ZERO    //锦标赛0点更新
-	HANDLE_TYPE_CHAMPSHIP_NOTIFY2 = 306 //锦标赛0.30点通知
+	HANDLE_TYPE_CHAMPSHIP_NOTIFY2 //锦标赛0.30点通知
 	// 服务器变量
-	HANDLE_TYPE_VAR_GET = 401 //获取变量
+	HANDLE_TYPE_VAR_GET //获取变量
-	HANDLE_TYPE_VAR_SET = 402 //设置变量
+	HANDLE_TYPE_VAR_SET //设置变量
 
 	//server mod handle
-	SERVER_ZERO_UPDATE = 1000 //zero update
+	SERVER_ZERO_UPDATE        //zero update
+	HANDLE_TYPE_PLAYROOM_LOSE // playroom偷取物品
 )
 
 const (

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

@@ -1,25 +1,26 @@
 package order
 
 import (
-	"errors"
+	"fmt"
 	"server/GoUtil"
 	startOrderCfg "server/conf/StartOrder"
 	limitedTimeEventCfg "server/conf/limitedTimeEvent"
 	mergeDataCfg "server/conf/mergeData"
-	orderCfg "server/conf/order"
+	playroomCfg "server/conf/playroom"
-	userCfg "server/conf/user"
 	"server/game/mod/item"
 	"server/msg"
+	"sort"
 	"time"
 )
 
 type OrderMod struct {
-	OrderList map[int]Order // 订单列表
+	OrderList       map[int]Order // 订单列表
-	Auto_id   int           // 订单自增id
+	Auto_id         int           // 订单自增id
-	Step      int           // 当前订单步骤
+	Step            int           // 当前订单步骤
-	LastDiff  int           // 上一个订单难度
+	LastDiff        int           // 上一个订单难度
-	LastOrder Order         // 上一个订单
+	LastOrder       Order         // 上一个订单
-	EimtOrder map[string]struct{}
+	LastNormalOrder Order         // 上一个普通订单
+	EimtOrder       map[string]struct{}
 }
 
 type Order struct {
@@ -34,6 +35,7 @@ const (
 	Extra_type   = 2 // 额外订单
 	Super_type   = 3 // 超级订单
 	Preheat_type = 4 // 预热订单
+	Trigger_type = 5 // 触发订单
 
 	diff_low  = 1 // 低难度
 	diff_mid  = 2 // 中难度
@@ -79,11 +81,11 @@ func (o *OrderMod) RewardOrder(id int) ([]*item.Item, []int, int, int, error) {
 		}
 		return ItemList, v.MergeId, v.Type, Star, nil
 	}
-	return ItemList, MergeList, 0, 0, errors.New("order not exist")
+	return ItemList, MergeList, 0, 0, fmt.Errorf("订单不存在, 订单id%d", id)
 }
 
 // 生成新订单
-func (o *OrderMod) CreateOrder(lv int, Emit []int) error {
+func (o *OrderMod) CreateOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
@@ -126,7 +128,7 @@ func (o *OrderMod) CreateOrder(lv int, Emit []int) error {
 				}
 			}
 			for i := n; i < MaxOrderNum; i++ {
-				err := o.CreateNormalOrder(lv, Emit)
+				err := o.CreateNormalOrder(lv, Emit, EnergyMul)
 				if err != nil {
 					return err
 				}
@@ -190,130 +192,187 @@ func (o *OrderMod) CreatePriorityOrder(lv int, Emit []int) bool {
 }
 
 // 生成新订单
-func (o *OrderMod) CreateNormalOrder(lv int, Emit []int) error {
+func (o *OrderMod) CreateNormalOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
-	OrderN, err := userCfg.GetOrderNByLv(lv)
+	randNum := 0
-	RandChessNum := getChessNumRand(OrderN)
+	mergeList := make([]int, 0)
-	if err != nil {
+	OrderDiff := diff_low
-		return err
+	var err error
-	}
+	for {
-	ChessNum := GoUtil.RandMap(RandChessNum)
+		if randNum > 50 {
-
+			break
-	OrderDiffRand := getOrderDiffRand(o.LastDiff, OrderN)
+		}
-
+		randNum++
-	OrderDiff := GoUtil.RandMap(OrderDiffRand)
+		mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul)
-
+		if err != nil {
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
-
-	EnergyMul := userCfg.GetEnergyMulByLv(lv)
-	ColorArr := make([]string, 0)
-	RandEmit := 0
-	mergeList := make([]int, 0, len(ChessDiff))
-	for _, v := range ChessDiff {
-		Emit, RandEmit = GoUtil.RandPopSlice(Emit)
-		RandEmitLv := mergeDataCfg.GetLvById(RandEmit)
-		RandMaxLv := mergeDataCfg.GetMaxLvById(RandEmit)
-		m := int(float64(1+RandEmitLv-4) / float64(1+RandMaxLv-4) * 100)
-		ChessMinLev := orderCfg.GetLvMin(EnergyMul)
-		ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
-		NewLev := getChessLv(ChessMinLev, ChessMaxLev, v)
-		ChessColor := getRandChessColor(RandEmit)
-		if GoUtil.InStringArray(ChessColor, ColorArr) {
 			continue
 		}
-		ColorArr = append(ColorArr, ChessColor)
+		lastMergelist := o.LastNormalOrder.MergeId
-		ColorMaxLv := mergeDataCfg.GetMaxLvByColor(ChessColor)
+		conbine := false
-		NewLev = min(NewLev, ColorMaxLv)
+		for _, v := range mergeList {
-		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev, ChessColor)
+			if GoUtil.InArray(v, lastMergelist) {
-		Type := mergeDataCfg.GetTypeById(ChessId)
+				conbine = true
-		if Type != "Product" {
+				break
+			}
+		}
+		if conbine {
 			continue
 		}
-		if ChessId == 0 {
+		break
-			continue
-		}
-		mergeList = append(mergeList, ChessId)
-	}
-	if len(mergeList) == 0 {
-		return errors.New("mergeList is nil")
 	}
+
 	o.addOrder(mergeList, OrderDiff, Common_type)
 	return nil
 }
 
 // 生成超级订单
-func (o *OrderMod) CreateSuperOrder(lv int, Emit []int) error {
+func (o *OrderMod) CreateSuperOrder(lv int, Emit []int, EnergyMul int) error {
 	if len(Emit) == 0 {
 		return nil
 	}
-	OrderN, err := userCfg.GetOrderNByLv(lv)
+	randNum := 0
-	RandChessNum := getChessNumRandSuper(OrderN)
+	mergeList := make([]int, 0)
-	if err != nil {
+	OrderDiff := diff_low
-		return err
+	var err error
-	}
+	for {
-	ChessNum := GoUtil.RandMap(RandChessNum)
+		if randNum > 50 {
-
+			break
-	OrderDiff := diff_high // 默认高难度
-	PreheatColor := ""
-	for _, v := range o.OrderList {
-		if v.Type == Preheat_type {
-			PreheatColor = mergeDataCfg.GetColorById(v.MergeId[0])
 		}
-	}
+		randNum++
-
+		mergeList, OrderDiff, err = randOrderChess(o, lv, Emit, EnergyMul)
-	NewEmit := make([]int, 0)
+		if err != nil {
-
-	for _, v := range Emit {
-		ProduceType := mergeDataCfg.GetEmitProduceType(v)
-		if GoUtil.InStringArray(PreheatColor, ProduceType) {
 			continue
 		}
-		NewEmit = append(NewEmit, v)
+		lastMergelist := o.LastNormalOrder.MergeId
-	}
+		conbine := false
-	ChessNum = min(ChessNum, len(NewEmit))
+		for _, v := range mergeList {
-	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
+			if GoUtil.InArray(v, lastMergelist) {
-	EnergyMul := userCfg.GetEnergyMulByLv(lv)
+				conbine = true
-	RandEmit := 0
+				break
-	mergeList := make([]int, 0, len(ChessDiff))
+			}
-	for _, v := range ChessDiff {
+		}
-		NewEmit, RandEmit = GoUtil.RandPopSlice(NewEmit)
+		if conbine {
-		RandEmitLv := mergeDataCfg.GetLvById(RandEmit)
-		RandMaxLv := mergeDataCfg.GetMaxLvById(RandEmit)
-		m := int(float64(1+RandEmitLv-4) / float64(1+RandMaxLv-4) * 100)
-		ChessMinLev := orderCfg.GetLvMin(EnergyMul)
-		ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
-		NewLev := getChessLv(ChessMinLev, ChessMaxLev, v)
-		ChessColor := getRandChessColor(RandEmit)
-		ColorMaxLv := mergeDataCfg.GetMaxLvByColor(ChessColor)
-		NewLev = min(NewLev, ColorMaxLv)
-		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev, ChessColor)
-		Type := mergeDataCfg.GetTypeById(ChessId)
-		if Type != "Product" {
 			continue
 		}
-		if ChessId == 0 {
+		break
-			continue
-		}
-		mergeList = append(mergeList, ChessId)
-	}
-	if len(mergeList) == 0 {
-		return errors.New("mergeList is nil")
 	}
 	o.addOrder(mergeList, OrderDiff, Super_type)
 	return nil
 }
 
+/*
+*
+触发订单生成规则：
+1.有触发订单时，不重复生成
+2.检索当前已有的订单中，除特殊订单外星星基础收益数值(订单收益数低于1000)最高的订单
+*/
+func (o *OrderMod) CreateTriggerOrder(lv int, Emit []int, EnergyMul int) (int, error) {
+	if lv < playroomCfg.GetUnLockLv() {
+		return 0, nil
+	}
+	StarCfg := playroomCfg.GetOrderStar()
+	type info struct {
+		k int
+		v Order
+	}
+	orderList := make([]info, 0)
+	// 查找奖励小于1000的订单， 取最大的订单
+	for k, v := range o.OrderList {
+		if v.Type == Trigger_type {
+			return 0, nil
+		}
+		if v.Type != Common_type {
+			continue
+		}
+		Star := getOrderStar(v.MergeId)
+		if Star > StarCfg {
+			continue
+		}
+		orderList = append(orderList, info{k, v})
+	}
+	sort.Slice(orderList, func(i, j int) bool {
+		return getOrderStar(orderList[i].v.MergeId) > getOrderStar(orderList[j].v.MergeId)
+	})
+	// 没有奖励小于1000的订单且无法生成，去最小的订单
+	if len(orderList) == 0 && EnergyMul >= 8 {
+		for k, v := range o.OrderList {
+			if v.Type != Common_type {
+				continue
+			}
+			orderList = append(orderList, info{k, v})
+		}
+		sort.Slice(orderList, func(i, j int) bool {
+			return getOrderStar(orderList[i].v.MergeId) < getOrderStar(orderList[j].v.MergeId)
+		})
+	}
+	if len(orderList) != 0 {
+		o.OrderList[orderList[0].k] = Order{
+			MergeId:   orderList[0].v.MergeId,
+			Diff:      orderList[0].v.Diff,
+			Type:      Trigger_type,
+			Timestamp: time.Now().Unix(),
+		}
+		return getOrderStar(orderList[0].v.MergeId), nil
+	}
+
+	// 随机生成新的订单
+	if len(Emit) == 0 {
+		return 0, nil
+	}
+	randNum := 0
+	mergeList := make([]int, 0)
+	for {
+		if randNum > 50 {
+			break
+		}
+		randNum++
+		mergeList1, _, err := randOrderChess(o, lv, Emit, EnergyMul)
+		if err != nil {
+			continue
+		}
+
+		if getOrderStar(mergeList1) < StarCfg {
+			mergeList = mergeList1
+			break
+		}
+	}
+	if len(mergeList) > 0 {
+		o.addOrder(mergeList, diff_low, Trigger_type)
+		return getOrderStar(mergeList), nil
+	} else {
+		for k, v := range o.OrderList {
+			if v.Type != Common_type {
+				continue
+			}
+			orderList = append(orderList, info{k, v})
+		}
+		sort.Slice(orderList, func(i, j int) bool {
+			return getOrderStar(orderList[i].v.MergeId) < getOrderStar(orderList[j].v.MergeId)
+		})
+		o.OrderList[orderList[0].k] = Order{
+			MergeId:   orderList[0].v.MergeId,
+			Diff:      orderList[0].v.Diff,
+			Type:      Trigger_type,
+			Timestamp: time.Now().Unix(),
+		}
+		return getOrderStar(orderList[0].v.MergeId), nil
+	}
+}
+
 func (o *OrderMod) addOrder(ChessList []int, Diff int, Type int) {
 	o.Auto_id++
-	o.OrderList[o.Auto_id] = Order{
+	Order := Order{
 		MergeId:   ChessList,
 		Diff:      Diff,
 		Type:      Type,
 		Timestamp: time.Now().Unix(),
 	}
-
+	o.OrderList[o.Auto_id] = Order
+	if Type == Common_type {
+		o.LastNormalOrder = Order
+	}
 }
 
 func (o *OrderMod) CreateExtraOrder(AddChess, AddNewEmit, ChessList []int) bool {
@@ -396,3 +455,32 @@ func (o *OrderMod) CheckSuperOrder() bool {
 	}
 	return false
 }
+
+func (o *OrderMod) ChangeEnergyMul(lv int, Emit []int, EnergyMul int, ChessList []int) {
+	for k, v := range o.OrderList {
+		if v.Type != Common_type {
+			continue
+		}
+		NeedTrigger := false
+		for _, vv := range v.MergeId {
+			Lv := mergeDataCfg.GetLvById(vv)
+			if Lv >= EnergyMul+1 && Lv <= EnergyMul+12 {
+				continue
+			}
+			if GoUtil.InArray(vv, ChessList) {
+				NeedTrigger = true
+				break
+			}
+		}
+		/**
+		当每次倍数调整（玩家主动调整或因为体力不足跌落）时，在普通订单中（即不包括偷猫订单、超级订单），如果出现超出上下阈值：
+		订单棋子等级<n且该棋子棋盘上没有
+		订单棋子等级>n+11 且该棋子在棋盘上没有
+		则删除该订单，重新生成一个普通订单
+		*/
+		if NeedTrigger {
+			delete(o.OrderList, k)
+			o.CreateNormalOrder(lv, Emit, EnergyMul)
+		}
+	}
+}

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

@@ -3,6 +3,8 @@ package order
 import (
 	"server/GoUtil"
 	mergeDataCfg "server/conf/mergeData"
+	orderCfg "server/conf/order"
+	userCfg "server/conf/user"
 )
 
 func getChessNumRand(OrderN int) map[int]int {
@@ -129,17 +131,18 @@ func getChessDiff(ChessNum, OrderDiff, OrderN int) map[int]int {
 }
 
 func getChessLv(Min, Max, Diff int) int {
-	dur := int((Max - Min) / 3)
+	Start := Min
-	var rand []int
+	End := Max
-	start := Diff * dur
+	switch Diff {
-	end := (Diff + 1) * dur
+	case diff_low:
-	if Diff == diff_high {
+		End = Min + (Max-Min+1)/3 - 1
-		end = Max
+	case diff_mid:
+		Start = Min + (Max-Min+1)/3
+		End = Min + (Max-Min+1)/3*2 - 1
+	case diff_high:
+		Start = Min + (Max-Min+1)/3*2
 	}
-	for i := start; i < end; i++ {
+	return GoUtil.RandNum(Start, End)
-		rand = append(rand, i)
-	}
-	return GoUtil.RandSlice(rand) + Min
 }
 
 func getRandChessColor(Emit int) string {
@@ -153,3 +156,109 @@ func getRandChessColor(Emit int) string {
 	})
 	return Produce[key]
 }
+
+func getRandChessColorList(o *OrderMod, Emit []int, EnergyMul int) map[string]int {
+	r := make(map[string]int)
+	ChessList := make([]int, 0)
+	for _, v := range o.OrderList {
+		if v.Type == Common_type {
+			ChessList = append(ChessList, v.MergeId...)
+		}
+	}
+	for _, v := range Emit {
+		Produce := mergeDataCfg.GetEmitProduceChessType(v)
+		if len(Produce) == 0 {
+			continue
+		}
+		if len(Produce) == 1 {
+			r[Produce[0]] = 100
+			continue
+		}
+		r[Produce[0]] = 80
+		r[Produce[1]] = 20
+		if checkA1High(ChessList, v, EnergyMul) {
+			r[Produce[1]] += 20
+		}
+	}
+	return r
+}
+
+func checkA1High(ChessList []int, Emit int, EnergyMul int) bool {
+	ChessMinLev, ChessMaxLev := getChesslvRange(Emit, EnergyMul)
+	HighLv := ChessMinLev + ((ChessMaxLev-ChessMinLev)/3)*2
+	Produce := mergeDataCfg.GetEmitProduceChessType(Emit)
+	for _, v := range ChessList {
+		ChessColor := mergeDataCfg.GetColorById(v)
+		if ChessColor == Produce[0] {
+			ChessLv := mergeDataCfg.GetLvById(v)
+			if ChessLv >= HighLv {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func getChesslvRange(Emit int, EnergyMul int) (int, int) {
+	RandEmitLv := mergeDataCfg.GetLvById(Emit)
+	RandMaxLv := mergeDataCfg.GetMaxLvById(Emit)
+	RandEmitMinLv := mergeDataCfg.GetEmitMinLvById(Emit)
+	m := int(float64(1+RandEmitLv-RandEmitMinLv) / float64(1+RandMaxLv-RandEmitMinLv) * 100)
+	ChessMinLev := orderCfg.GetLvMin(EnergyMul)
+	ChessMaxLev := orderCfg.GetLvMax(EnergyMul, m)
+	return ChessMinLev, ChessMaxLev
+}
+
+func getEmitByColor(Emit []int, color string) int {
+	for _, v := range Emit {
+		Produce := mergeDataCfg.GetEmitProduceChessType(v)
+		for _, c := range Produce {
+			if c == color {
+				return v
+			}
+		}
+	}
+	return 0
+}
+
+func randOrderChess(o *OrderMod, lv int, Emit []int, EnergyMul int) ([]int, int, error) {
+	OrderN, err := userCfg.GetOrderNByLv(lv)
+	RandChessNum := getChessNumRand(OrderN)
+	if err != nil {
+		return nil, diff_low, err
+	}
+	ChessNum := GoUtil.RandMap(RandChessNum)
+	OrderDiffRand := getOrderDiffRand(o.LastDiff, OrderN)
+	OrderDiff := GoUtil.RandMap(OrderDiffRand)
+	ChessDiff := getChessDiff(ChessNum, OrderDiff, OrderN)
+	mergeList := make([]int, 0, len(ChessDiff))
+	ColorRand := getRandChessColorList(o, Emit, EnergyMul)
+	var Color string
+	for _, v := range ChessDiff {
+		Color = GoUtil.RandStringMap(ColorRand)
+		delete(ColorRand, Color)
+		Emit := getEmitByColor(Emit, Color)
+		ChessMinLv, ChessMaxLv := getChesslvRange(Emit, EnergyMul)
+		NewLev := getChessLv(ChessMinLv, ChessMaxLv, v)
+		ColorMaxLv := mergeDataCfg.GetMaxLvByColor(Color)
+		NewLev = min(NewLev, ColorMaxLv)
+		ChessId := mergeDataCfg.GetChessIdByLvAndColor(NewLev, Color)
+		Type := mergeDataCfg.GetTypeById(ChessId)
+		if Type != "Product" {
+			continue
+		}
+		if ChessId == 0 {
+			continue
+		}
+		mergeList = append(mergeList, ChessId)
+	}
+	return mergeList, OrderDiff, nil
+}
+
+func getOrderStar(ChessList []int) int {
+	Star := 0
+	for _, v := range ChessList {
+		Star += mergeDataCfg.GetStarById(v)
+	}
+	return Star
+}

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

@@ -0,0 +1,310 @@
+package playroom
+
+import (
+	"fmt"
+	"math"
+	"server/GoUtil"
+	limitedTimeEventCfg "server/conf/limitedTimeEvent"
+	playroomCfg "server/conf/playroom"
+	"server/game/mod/item"
+	"server/msg"
+)
+
+type PlayroomMod struct {
+	Collect    map[int]int
+	Room       map[int]int
+	Status     int           // 0: 未开始 1: 进行中 2: 结束
+	Endtime    int64         // 结束时间
+	Starttime  int64         // 开始时间
+	WorkStatus int           // 0: 未开始 1: 进行中 2: 结束
+	Visitor    map[int]*Info // 访客
+	MoodInfo   map[int]*Mood // 心情
+	AllMood    int           // 总心情
+	Reward     []*item.Item
+	DayFirstT  int                // 每日未首次触发次数
+	Trigger    int                // 未触发次数
+	HasVisit   map[int]int64      // 今日已拜访的玩家
+	Target     int                // 拜访的目标
+	GameId     int                // 游戏ID
+	GameReward map[int]*item.Item // 游戏奖励
+	GameStatus int                // 游戏状态
+	Exclude    bool
+	LoseItem   []*item.Item
+	Chip       int
+}
+
+const (
+	MOOD_TYPE_ENTER = 1 // 娱乐
+	MOOD_TYPE_FOOD  = 2 // 食物
+	MOOD_TYPE_CLEAN = 3 // 清洁
+)
+
+type Mood struct {
+	Id   int
+	Num  int
+	Time int64
+}
+
+type Info struct {
+	Time  int64
+	Times int
+}
+
+func (p *PlayroomMod) InitData() {
+	if p.Collect == nil {
+		p.Collect = make(map[int]int)
+		InitCollect := playroomCfg.GetInitDecorate()
+		for _, v := range InitCollect {
+			p.Collect[v] = 1
+		}
+	}
+	if p.Room == nil {
+		p.Room = make(map[int]int)
+	}
+	if p.Visitor == nil {
+		p.Visitor = make(map[int]*Info)
+	}
+	if p.MoodInfo == nil {
+		p.MoodInfo = make(map[int]*Mood)
+	}
+	if p.Reward == nil {
+		p.Reward = make([]*item.Item, 0)
+	}
+	if p.HasVisit == nil {
+		p.HasVisit = make(map[int]int64)
+	}
+	if p.GameReward == nil {
+		p.GameReward = make(map[int]*item.Item)
+	}
+	if p.LoseItem == nil {
+		p.LoseItem = make([]*item.Item, 0)
+	}
+}
+
+func (p *PlayroomMod) GetVisitor() map[int]*Info {
+	return p.Visitor
+}
+
+func (p *PlayroomMod) GetTarget() int {
+	return p.Target
+}
+
+func (p *PlayroomMod) GetHasVisit() map[int]int64 {
+	return p.HasVisit
+}
+
+func (p *PlayroomMod) GetMood() map[int]int {
+	Mood := make(map[int]int)
+	for k, v := range p.MoodInfo {
+		Mood[k] = v.Num
+	}
+	return Mood
+}
+
+func (p *PlayroomMod) GetMoodInfo(Id int) *Mood {
+	return p.MoodInfo[Id]
+}
+
+func (p *PlayroomMod) GetCollect() map[int]int {
+	return p.Collect
+}
+
+func (p *PlayroomMod) GetRoom() map[int]int {
+	return p.Room
+}
+
+func (p *PlayroomMod) GetStatus() int {
+	return p.Status
+}
+
+func (p *PlayroomMod) GetChip() int {
+	return p.Chip
+}
+
+func (p *PlayroomMod) AddChip() {
+	p.Chip = min(p.Chip+1, 5)
+}
+
+func (p *PlayroomMod) SetTarget(Target int) {
+	p.Target = Target
+	p.Status = 1
+	p.HasVisit[Target] = GoUtil.Now()
+}
+
+func (p *PlayroomMod) SetGameId(GameId int) {
+	if p.GameId != 0 {
+		return
+	}
+	p.GameId = GameId
+}
+
+func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) {
+	if Star == 0 {
+		return
+	}
+	var Item1, Item2 int
+	VisitorItem := playroomCfg.GetVisitorItem()
+	if Star < playroomCfg.GetOrderStar() {
+		Item1, Item2 = playroomCfg.GetNormalItem()
+	} else {
+		Item1, Item2 = playroomCfg.GetPremiumItem()
+	}
+
+	Item1Num := itemMod.GetItem(Item1)
+	Item2Num := itemMod.GetItem(Item2)
+	if p.DayFirstT == 2 {
+		p.Reward = append(p.Reward, &item.Item{Id: VisitorItem, Num: 1})
+		return
+	}
+	if p.Trigger == 4 {
+		p.Reward = append(p.Reward, &item.Item{Id: VisitorItem, Num: 1})
+		p.Trigger = 0
+		return
+	}
+	if Item1Num == 0 && Item2Num == 0 {
+		Prob := GoUtil.RandSlice([]int{Item1, Item2})
+		p.Reward = append(p.Reward, &item.Item{Id: Prob, Num: 1})
+		p.DayFirstT++
+		p.Trigger++
+		return
+	}
+	if math.Abs(float64(Item1Num-Item2Num)) > 3 {
+		RI := GoUtil.IfTrue(Item1Num > Item2Num, Item2, Item1).(int)
+		p.Reward = append(p.Reward, &item.Item{Id: RI, Num: 1})
+		p.DayFirstT++
+		p.Trigger++
+		return
+	}
+	var RandSlice []int
+	if Star < playroomCfg.GetOrderStar() {
+		RandSlice = []int{Item1, Item2}
+	} else {
+		RandSlice = []int{Item1, Item2, VisitorItem}
+	}
+	Prob := GoUtil.RandSlice(RandSlice)
+	p.Reward = append(p.Reward, &item.Item{Id: Prob, Num: 1})
+	if Prob == VisitorItem {
+		p.DayFirstT = 3
+		p.Trigger = 0
+	} else {
+		p.DayFirstT++
+		p.Trigger++
+	}
+}
+
+func (p *PlayroomMod) GetReward() []*item.Item {
+	p.Reward = make([]*item.Item, 0)
+	return p.Reward
+}
+
+func (p *PlayroomMod) Interact(Id, Type int) ([]*item.Item, error) {
+	MoodType, ItemList, Effect := playroomCfg.GetInteract(Id, Type)
+	if MoodType == 0 {
+		return nil, fmt.Errorf("Interact MoodType is 0")
+	}
+	if Effect > 0 {
+		p.AllMood += 10
+	}
+	p.AddMood(MoodType, Effect)
+	return ItemList, nil
+}
+
+func (p *PlayroomMod) AddMood(Id, Num int) {
+	p.MoodInfo[Id].Num = max(0, min(p.MoodInfo[Id].Num+Num, 100))
+}
+
+func (p *PlayroomMod) AddVisitor(Id int, Time int64) {
+	v, ok := p.Visitor[Id]
+	if !ok {
+		p.Visitor[Id] = &Info{Time: Time, Times: 1}
+		return
+	}
+	v.Times++
+	v.Time = Time
+}
+
+func (p *PlayroomMod) SetRoom(Id, Pos int) error {
+	_, ok := p.Collect[Id]
+	if !ok {
+		return fmt.Errorf("SetRoom Collect Id not found")
+	}
+	p.Room[Pos] = Id
+	return nil
+}
+
+func (p *PlayroomMod) AddCollect(Id int) {
+	p.Collect[Id]++
+}
+
+func (p *PlayroomMod) ResetGame() {
+	p.Target = 0
+	p.Status = 0
+	p.GameId = 0
+	p.GameReward = make(map[int]*item.Item)
+}
+
+func (p *PlayroomMod) SetGameReward(Chess1, Chess2, Star int) {
+	p.GameReward[1] = &item.Item{Id: Chess1, Num: 1}
+	p.GameReward[2] = &item.Item{Id: Chess2, Num: 1}
+	p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
+}
+
+func (p *PlayroomMod) SelectReward(Id int) []*item.Item {
+	v, ok := p.GameReward[Id]
+	if !ok {
+		return nil
+	}
+	return []*item.Item{v}
+}
+
+func (p *PlayroomMod) Lose(Item []*item.Item) {
+	p.LoseItem = append(p.LoseItem, Item...)
+}
+
+func (p *PlayroomMod) Work() ([]*item.Item, error) {
+	if p.Endtime > GoUtil.Now() {
+		p.WorkStatus = 1
+		return nil, nil
+	}
+	p.Starttime = GoUtil.Now()
+	p.Endtime = GoUtil.Now() + 86400
+	p.WorkStatus = 1
+	ItemId := playroomCfg.GetWorkItem()
+	return []*item.Item{item.NewItem(ItemId, 1)}, nil
+}
+
+func (p *PlayroomMod) Rest() {
+	p.WorkStatus = 2
+}
+
+func (p *PlayroomMod) Draw() (int, []*item.Item, error) {
+	if p.AllMood < 100 {
+		return 0, nil, fmt.Errorf("Draw AllMood < 100")
+	}
+	p.AllMood = 0
+	ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
+	Id := GoUtil.RandMap(ProbList)
+	return Id, limitedTimeEventCfg.GetSenceJackpotReward(Id), nil
+}
+
+func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
+	return &msg.NotifyPlayroomWork{
+		WorkStatus: int32(p.WorkStatus),
+		StartTime:  int32(p.Starttime),
+	}
+}
+
+func (p *PlayroomMod) Fire(ChargeId int) []*item.Item {
+	WorkChargeId := playroomCfg.GetWorkChargeId()
+	if ChargeId == WorkChargeId {
+		ItemId := playroomCfg.GetWorkItem()
+		return []*item.Item{item.NewItem(ItemId, 1)}
+	}
+	return nil
+}
+
+func (p *PlayroomMod) RemoveChip(Num int) []*item.Item {
+	Num = min(Num, p.Chip)
+	p.Chip -= Num
+	return []*item.Item{item.NewItem(item.ITEM_STAR_ID, Num*50)}
+}

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

@@ -56,20 +56,15 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 	}
 
 	switch q.Label {
-	case "Energy": // 消耗x能量
+	case TRIGGER_LABEL_ENERGY: // 消耗x能量
 		AddNum := Tr.A[0].(int)
 		q.Num += AddNum
 		if q.Num >= q.Target {
 			q.Num = q.Target
 			q.Status = true
 		}
-	case "MergeTime": // 合成x次
+
-		q.Num += 1
+	case TRIGGER_LABEL_MERGELVTIME: // 合成x级棋子y次
-		if q.Num >= q.Target {
-			q.Num = q.Target
-			q.Status = true
-		}
-	case "MergeLvTime": // 合成x级棋子y次
 		Lv, _ := Tr.A[0].(int)
 		TargetLv, _ := strconv.Atoi(q.A[0].(string))
 		if TargetLv == Lv {
@@ -79,6 +74,13 @@ func TriggerQuestProgress(q *QuestProgress, Tr *Trigger) bool {
 				q.Status = true
 			}
 		}
+	case TRIGGER_LABEL_MERGETIME, // 合成x次
+		TRIGGER_LABEL_FINISHORDER: // 完成x次订单
+		q.Num += 1
+		if q.Num >= q.Target {
+			q.Num = q.Target
+			q.Status = true
+		}
 	}
 	return true
 }

src/server/gamedata/reader.go

@@ -9,6 +9,7 @@ import (
 	"path/filepath"
 	"strconv"
 
+	"server/conf"
 	"server/game/mod/item"
 	"server/pkg/github.com/name5566/leaf/log"
 	"server/pkg/github.com/name5566/leaf/recordfile"
@@ -17,10 +18,14 @@ import (
 )
 
 var watcher *fsnotify.Watcher
+var ConfPath = "./gamedata/config/"
 
 func init() {
+	if conf.Server.GameConfPath != "" {
+		ConfPath = conf.Server.GameConfPath
+	}
 	watcher, _ = fsnotify.NewWatcher()
-	watcher.Add("./gamedata/config/reload")
+	watcher.Add(ConfPath + "reload")
 	go func() {
 		for {
 			select {
@@ -52,7 +57,7 @@ func readRfNew(st interface{}, ralativePath string) *recordfile.RecordFile {
 		log.Fatal("%v", err)
 	}
 	fn := ralativePath + ".txt"
-	err = rf.Read("gamedata/config/" + fn)
+	err = rf.Read(ConfPath + fn)
 	if err != nil {
 		log.Fatal("%v: %v", fn, err)
 	}
@@ -62,7 +67,7 @@ func readRfNew(st interface{}, ralativePath string) *recordfile.RecordFile {
 
 func InitCfg(cfgname string) {
 	// 读取文件内容
-	filePath := "./gamedata/config/" + cfgname + ".json"
+	filePath := ConfPath + cfgname + ".json"
 	absPath, _ := filepath.Abs(filePath)
 
 	file, err := os.Open(absPath)