Revert "架构优化"

This reverts commit 806780b5b3.

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

@@ -161,71 +161,70 @@ type Info struct {
 }
 
 func (p *PlayroomMod) InitData() {
-	InitCollect := playroomCfg.GetInitDecorate()
-
 	if p.Collect == nil {
-		p.Collect = make(map[int]int, 16)
+		p.Collect = make(map[int]int)
 	}
 	if p.Dress == nil {
-		p.Dress = make(map[int][]int, 8)
+		p.Dress = make(map[int][]int)
 	}
 	if p.DressSet == nil {
-		p.DressSet = make(map[int]int, 8)
+		p.DressSet = make(map[int]int)
 	}
 	if p.GameInfo == nil {
-		p.GameInfo = make(map[int]interface{}, 8)
+		p.GameInfo = make(map[int]interface{})
 	}
 	if p.NewCollect == nil {
-		p.NewCollect = make(map[int]*CollectInfo, len(InitCollect))
+		p.NewCollect = make(map[int]*CollectInfo)
 	}
-
+	InitCollect := playroomCfg.GetInitDecorate()
 	if len(p.NewCollect) == 0 {
-		now := GoUtil.Now()
 		for _, v := range InitCollect {
 			p.NewCollect[v] = &CollectInfo{
 				Id:      v,
-				AddTime: now,
+				AddTime: GoUtil.Now(),
 				EndTime: 0,
 				Num:     1,
 			}
 		}
 	}
 	if len(p.Collect) > 0 {
-		now := GoUtil.Now()
 		for k, v := range p.Collect {
 			p.NewCollect[k] = &CollectInfo{
 				Id:      k,
-				AddTime: now,
+				AddTime: GoUtil.Now(),
 				EndTime: 0,
 				Num:     v,
 			}
 		}
-		p.Collect = nil
+		p.Collect = make(map[int]int)
+	}
+	for _, v := range InitCollect {
+		p.Collect[v] = 1
 	}
 	if p.Room == nil {
-		p.Room = make(map[int]int, 8)
+		p.Room = make(map[int]int)
 		p.JackpotNum = playroomCfg.GetJackpotNum()
 	}
 	if p.Visitor == nil {
-		p.Visitor = make(map[int]*Info, 16)
+		p.Visitor = make(map[int]*Info)
 	}
 	if p.MoodInfo == nil {
-		p.MoodInfo = make(map[int]*Mood, 4)
+		p.MoodInfo = make(map[int]*Mood)
 	}
 	if p.Physiology == nil {
-		p.Physiology = make(map[int]*Physiology, 4)
+		p.Physiology = make(map[int]*Physiology)
 	}
 	if p.Reward == nil {
-		p.Reward = make([]*item.Item, 0, 8)
+		p.Reward = make([]*item.Item, 0)
 	}
 	if p.HasVisit == nil {
-		p.HasVisit = make(map[int]int64, 16)
+		p.HasVisit = make(map[int]int64)
 	}
 	if p.GameReward == nil {
-		p.GameReward = make(map[int]*item.Item, 4)
+		p.GameReward = make(map[int]*item.Item)
 	}
 	if p.LoseItem == nil {
-		p.LoseItem = make([]*item.Item, 0, 8)
+		p.LoseItem = make([]*item.Item, 0)
 	}
 	if p.Flip == nil {
 		p.Flip = make(map[int]int)

src/server/game/player_data.go

@@ -207,9 +207,9 @@ func (p *Player) InitPlayer(UserName string) error {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 	p.msgChan = make(chan *MsgMod.Msg, 100)
-	p.Msg = make([]PlayerMsg, 0, 16)                     // 添加容量提示
+	p.Msg = make([]PlayerMsg, 0)
-	p.args = make(map[string]interface{}, 8)             // 添加容量提示
+	p.args = make(map[string]interface{})
-	p.timerList = make(map[string]*timer.Timer, 8)       // 添加容量提示
+	p.timerList = make(map[string]*timer.Timer)
 	p.MDispatr = timer.NewDispatcher(100)
 	p.stopSignal = make(chan bool)
 	Base := &PlayerBaseData{p: p}

src/server/game/player_mod.go

@@ -45,64 +45,13 @@ import (
 	"time"
 )
 
-// encoderPair 封装 encoder 和 buffer
+// buffer 对象池，复用 bytes.Buffer 减少内存分配
-type encoderPair struct {
+var bufferPool = sync.Pool{
-	encoder *gob.Encoder
-	buffer  *bytes.Buffer
-}
-
-// decoderPair 封装 decoder 和 reader
-type decoderPair struct {
-	decoder *gob.Decoder
-	reader  *bytes.Reader
-}
-
-// gob 编码器对象池，复用 Encoder 减少反射开销
-var gobEncoderPool = sync.Pool{
 	New: func() interface{} {
-		buf := bytes.NewBuffer(make([]byte, 0, 128*1024))
+		return bytes.NewBuffer(make([]byte, 0, 128*1024))
-		return &encoderPair{
-			encoder: gob.NewEncoder(buf),
-			buffer:  buf,
-		}
 	},
 }
 
-// gob 解码器对象池，复用 Decoder 减少反射开销
-var gobDecoderPool = sync.Pool{
-	New: func() interface{} {
-		reader := bytes.NewReader(nil)
-		return &decoderPair{
-			decoder: gob.NewDecoder(reader),
-			reader:  reader,
-		}
-	},
-}
-
-// getEncoder 从对象池获取 encoder
-func getEncoder() *encoderPair {
-	pair := gobEncoderPool.Get().(*encoderPair)
-	pair.buffer.Reset()
-	return pair
-}
-
-// putEncoder 归还 encoder 到对象池
-func putEncoder(pair *encoderPair) {
-	gobEncoderPool.Put(pair)
-}
-
-// getDecoder 从对象池获取 decoder
-func getDecoder(data []byte) *decoderPair {
-	pair := gobDecoderPool.Get().(*decoderPair)
-	pair.reader.Reset(data)
-	return pair
-}
-
-// putDecoder 归还 decoder 到对象池
-func putDecoder(pair *decoderPair) {
-	gobDecoderPool.Put(pair)
-}
-
 type PlayerData struct {
 	Name         string
 	IsHaveDataDb bool
@@ -209,13 +158,11 @@ func (p *PlayerModData) Reconnect(b bool) []byte {
 func (p *PlayerModData) InitMod(player *Player) (bool, error) {
 	playerModList := PlayerModList{}
 	if len(p.Data.ModData) > 0 {
-		// 从对象池获取 decoder
+		buf := bytes.NewBuffer(p.Data.ModData)
-		pair := getDecoder(p.Data.ModData)
+		decoder := gob.NewDecoder(buf)
-		defer putDecoder(pair)
+		err := decoder.Decode(&playerModList)
-
-		err := pair.decoder.Decode(&playerModList)
 		if err != nil {
-			log.Debug("playmod get data failed, err:%v, uid=%d", err, player.M_DwUin)
+			log.Debug("playmod get data failed, err:%v\n", err)
 			return false, fmt.Errorf("playmod get data failed, err:%v", err)
 		}
 	}
@@ -294,64 +241,64 @@ func (p *PlayerMod) IsBlackList() bool {
 func (p *PlayerMod) ClearData(player *Player) {
 	ChessMod := p.getChessMod()
 	if len(ChessMod.ChessMap) > 0 && len(ChessMod.ChessList) != len(ChessMod.ChessMap) {
-		log.Debug("uid: %d, SaveData, chess error", player.M_DwUin)
+		log.Debug("uid: %d, SaveData, chess error ", player.M_DwUin)
 		return
 	}
 	if p.is_update && !p.IsBlackList() {
-		// 从对象池获取 encoder
+		//序列化模块
-		pair := getEncoder()
+		buf := bufferPool.Get().(*bytes.Buffer)
-		defer putEncoder(pair)
+		buf.Reset() // 清空之前的数据
-
+		encode := gob.NewEncoder(buf)
-		// 序列化模块
+		err := encode.Encode(p.mod_list)
-		err := pair.encoder.Encode(p.mod_list)
 		if err != nil {
-			log.Debug("uid: %d, SaveData, playmod encode error %v", player.M_DwUin, err)
+			bufferPool.Put(buf) // 即使出错也要归还
+			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
 			return
 		}
-
+		// log.Debug("uid: %d, ClearData, playmod", player.M_DwUin)
-		// 复制数据，避免 buf 放回池后数据被清空
-		modDataBytes := make([]byte, pair.buffer.Len())
-		copy(modDataBytes, pair.buffer.Bytes())
-
 		modData := &db.SqlModStruct{
 			DwUin:      player.M_DwUin,
-			ModData:    modDataBytes,
+			ModData:    buf.Bytes(),
 			UpdataTime: int32(time.Now().Unix()),
 		}
 
 		err = db.SavePlayerModData(modData)
 		if err != nil {
-			log.Debug("uid: %d, SaveData, db save error %v", player.M_DwUin, err)
+			bufferPool.Put(buf) // 即使出错也要归还
+			log.Debug("uid: %d, SaveData, playmod error %v", player.M_DwUin, err)
 			return
 		}
 		p.is_update = false
+		bufferPool.Put(buf) // 归还到对象池
 	}
 }
 
 func (p *PlayerMod) BackUp(B *PlayerBackUp) {
-	// 从对象池获取 encoder
+	// 从对象池获取 buffer，复用以减少内存分配
-	pair := getEncoder()
+	buf := bufferPool.Get().(*bytes.Buffer)
-	defer putEncoder(pair)
+	buf.Reset() // 清空之前的数据
 
-	err := pair.encoder.Encode(p.mod_list)
+	encode := gob.NewEncoder(buf)
+	err := encode.Encode(p.mod_list)
 	if err != nil {
 		log.Debug("Backup, playmod error %v", err)
+		bufferPool.Put(buf) // 即使出错也要归还
 		return
 	}
 
 	// 复制数据，因为 buf 会被放回池中
-	B.PlayMod = make([]byte, pair.buffer.Len())
+	B.PlayMod = append([]byte(nil), buf.Bytes()...)
-	copy(B.PlayMod, pair.buffer.Bytes())
+
+	// 归还到对象池供下次使用
+	bufferPool.Put(buf)
 }
 
 func (p *PlayerMod) Recover(B *PlayerBackUp) {
 	if len(B.PlayMod) > 0 {
 		PlayMod := PlayerModList{}
-		// 从对象池获取 decoder
+		buf := bytes.NewBuffer(B.PlayMod)
-		pair := getDecoder(B.PlayMod)
+		decoder := gob.NewDecoder(buf)
-		defer putDecoder(pair)
+		err := decoder.Decode(&PlayMod)
-
-		err := pair.decoder.Decode(&PlayMod)
 		if err != nil {
 			log.Debug("Recover, playmod error %v", err)
 			return

src/server/game/unit_test.go

@@ -339,6 +339,8 @@ func UnitDecoratePartCost(p *Player) error {
 		fmt.Print(err)
 	}
 	return nil
+	ChessMod := p.PlayMod.getChessMod()
+	return ChessMod.PutPartInBag(1515)
 }
 
 func UnitOrderTrigger(p *Player) error {

src/server/game_util/randUtil.go

@@ -52,15 +52,13 @@ func RandStringMap(d map[string]int) string {
 
 // 从d中随机选取n个元素 不放回
 func RandMapNum(d map[int]int, n int) []int {
-	if n <= 0 {
+	if n <= 0 || n > len(d) {
 		return nil
 	}
-	if n >= len(d) {
+	if n == len(d) {
-		r := make([]int, 0, len(d))
 		for k := range d {
-			r = append(r, k)
+			return []int{k}
 		}
-		return r
 	}
 	r := make([]int, 0, n)
 	for i := 0; i < n; i++ {

src/server/game_util/sliceUtil.go

@@ -12,13 +12,13 @@ import (
 
 func IntSlice(d interface{}) []int {
 	if d == nil {
-		return nil
+		return []int{}
 	}
 
 	// Type assertion with safety check
 	result, ok := d.([]int)
 	if !ok {
-		return nil
+		return []int{}
 	}
 	return result
 }
@@ -77,18 +77,12 @@ func RandItem(slice []*item.Item) *item.Item {
 }
 
 func RandSliceNum(s []int, num int) []int {
-	if num <= 0 || len(s) == 0 {
-		return nil
-	}
-	if len(s) <= num {
-		result := make([]int, len(s))
-		copy(result, s)
-		return result
-	}
-
 	slice := make([]int, len(s))
 	copy(slice, s)
 	r := make([]int, 0, num)
+	if num <= 0 || len(slice) < num {
+		return slice
+	}
 
 	for i := 0; i < num; i++ {
 		Id := rand.Intn(len(slice))
@@ -99,18 +93,12 @@ func RandSliceNum(s []int, num int) []int {
 }
 
 func RandSliceNum2(s []interface{}, num int) []interface{} {
-	if num <= 0 || len(s) == 0 {
-		return nil
-	}
-	if len(s) <= num {
-		result := make([]interface{}, len(s))
-		copy(result, s)
-		return result
-	}
-
 	slice := make([]interface{}, len(s))
 	copy(slice, s)
 	r := make([]interface{}, 0, num)
+	if num <= 0 || len(slice) < num {
+		return slice
+	}
 
 	for i := 0; i < num; i++ {
 		Id := rand.Intn(len(slice))
@@ -137,7 +125,7 @@ func RandSliceNumNonAdjacent(s []int, num int) []int {
 }
 
 func SubAdjacentElemSlice(s []int, Id int) []int {
-	r := make([]int, 0)
+	r := make([]int, 0, len(s))
 	for k, v := range s {
 		if k < Id-1 || k > Id+1 {
 			r = append(r, v)
@@ -157,7 +145,7 @@ func RandStringSlice(slice []string) string {
 
 func SliceStringToInt(s []string) []int {
 	if len(s) == 0 {
-		return nil
+		return []int{}
 	}
 	r := make([]int, 0, len(s))
 	for _, v := range s {
@@ -309,7 +297,6 @@ func SlicesEqualString(a, b []string) bool {
 }
 
 // IsContainSlice checks if all elements of s2 are contained in s.
-// 注意：此函数会考虑重复元素，s2中的每个元素在s中必须有对应数量
 func IsContainSlice(s []int, s2 []int) bool {
 	if len(s2) == 0 {
 		return true
@@ -365,14 +352,7 @@ func ShuffleArray(s []int) []int {
 	return r
 }
 
-// IsContain 与 IsContainSlice 功能相同，建议使用 IsContainSlice
 func IsContain(s []int, s2 []int) bool {
-	if len(s2) == 0 {
-		return true
-	}
-	if len(s) < len(s2) {
-		return false
-	}
 	for _, v := range s2 {
 		if !InArray(v, s) {
 			return false