sonet/internal/mahjong/helper/conver.go

package helper

import (
	"fmt"
	"github.com/bytedance/sonic"
	"sonet/api/gen/mahjong"
	"sonet/internal/mahjong/game"
	"sonet/pkg/utils/collect"
	"sonet/pkg/utils/state"
	"sonet/pkg/utils/strs"
)

func SliceInt8To32(tiles []int8) (res []int32) {
	for _, tile := range tiles {
		res = append(res, int32(tile))
	}
	return
}

func SliceInt32To8(tiles []int32) (res []int8) {
	for _, tile := range tiles {
		res = append(res, int8(tile))
	}
	return
}

func MjTable2ProtoTable(table *game.MjTable, curPlayerId string) *mahjong.MjTable {
	return mjTable2ProtoTable0(table, curPlayerId)
}

func mjTable2ProtoTable0(table *game.MjTable, curPlayerId string) *mahjong.MjTable {
	t := &mahjong.MjTable{
		TableId:     table.TableId,
		MasterId:    table.MasterId,
		Stage:       int32(table.Stage),
		GameTimes:   table.GameTimes,
		HitPlayerId: table.HitPlayerId,
		Hits:        SliceInt8To32(table.Hits),
	}
	for _, direct := range table.PlayerDirects {
		t.PlayerDirects = append(t.PlayerDirects, int32(direct))
	}
	if table.MjWall != nil {
		restNum := int16(table.MjWall.RestNum())
		t.RestTiles = int32(restNum)
	}
	t.Players = make([]*mahjong.MjPlayer, 4)
	for i, p := range table.Players {
		if p != nil {
			if table.Stage == 4 {
				curPlayerId = ""
			}
			t.Players[i] = mjPlayer2TfPlayer0(p, curPlayerId)
		}
	}
	return t
}

func MjPlayer2TfPlayer(player *game.MjPlayer) *mahjong.MjPlayer {
	return mjPlayer2TfPlayer0(player, "")
}

func mjPlayer2TfPlayer0(player *game.MjPlayer, curPlayerId string) *mahjong.MjPlayer {
	p := &mahjong.MjPlayer{
		PlayerId:  player.PlayerId,
		Username:  player.Username,
		Avatar:    player.Avatar,
		Status:    int32(player.Status),
		TileLack:  int32(player.TileLack),
		Coin:      player.Coin,
		Opts:      SliceInt8To32(player.Opts),
		GangTiles: SliceInt8To32(player.GangTiles),
	}
	if player.MjTable != nil {
		p.TableId = player.MjTable.TableId
	}
	if curPlayerId == "" || player.PlayerId == curPlayerId {
		p.MjHand = SliceInt8To32(player.MjHand) // 手牌
		p.MjDraw = int32(player.MjDraw)         // 摸牌
	} else {
		// 其他玩家手牌置空
		p.MjHand = SliceInt8To32(game.BlankHandTilesI8)
	}
	// 碰杠
	for _, peng := range player.MjPeng {
		p.MjPeng = append(p.MjPeng, &mahjong.MjPlayer_Peng{Tiles: SliceInt8To32(peng[:])})
	}
	for _, gang := range player.MjGang {
		p.MjGang = append(p.MjGang, &mahjong.MjPlayer_Gang{Tiles: SliceInt8To32(gang[:])})
	}
	if player.WinSettle != nil {
		p.WinSettle = &mahjong.WinSettle{
			Weight:      player.WinSettle.Weight,
			WinTypeName: player.WinSettle.WinType.String(),
			WeightNames: collect.Mapping(player.WinSettle.Weights, func(w game.MjWeight) string {
				return w.String()
			}),
		}
	}
	return p
}

func SetState2MjSetState(setState state.SetState) (s *mahjong.SetState, err error) {
	s = &mahjong.SetState{}
	if len(setState.States) > 0 {
		states := state.S{}
		for k, v := range setState.States {
			k = strs.LowerInitialLetter(k)
			states[k] = v // 首字母小写
		}
		s.States, err = sonic.MarshalString(states)
		if err != nil {
			err = fmt.Errorf("marshal states error: %s", err.Error())
			return
		}
	}
	for _, setter := range setState.Setters {
		set := &mahjong.StateSetter{
			K:     strs.LowerInitialLetter(setter.K),
			T:     int32(setter.T),
			Index: int32(setter.Index),
			K2:    strs.LowerInitialLetter(setter.K2),
		}
		if setter.V == nil {
			set.V = nil
		} else {
			str, e := sonic.MarshalString(setter.V)
			if e != nil {
				err = fmt.Errorf("marshal state setter %s=%s error: %v", setter.K, setter.V, e.Error())
				return
			}
			set.V = &str
		}
		s.Setters = append(s.Setters, set)
	}
	return
}