《游戏服务端编程实践》10.1.1 私聊 / 公聊 / 频道模型

// file: ch10/chat/channel.go
// tier: L1
// verify: go test ./ch10/chat/

package chat

import (
	"errors"
	"fmt"
	"strings"
	"sync"
	"unicode/utf8"
)

var (
	ErrEmptyChannel    = errors.New("chat: empty channel id")
	ErrChannelNotFound = errors.New("chat: channel not found")
	ErrAlreadyJoined   = errors.New("chat: already joined")
	ErrNotMember       = errors.New("chat: not a member")
	ErrMuted           = errors.New("chat: member muted")
	ErrNoPermission    = errors.New("chat: no permission")
	ErrEmptyMessage    = errors.New("chat: empty message")
	ErrMessageTooLong  = errors.New("chat: message too long")
)

// ChannelKind 决定投递范围与发言权限，私聊、房间、世界和系统公告不能共用一套规则。
type ChannelKind string

const (
	KindPrivate ChannelKind = "private"
	KindRoom    ChannelKind = "room"
	KindWorld   ChannelKind = "world"
	KindSystem  ChannelKind = "system"
)

type Role int

const (
	RoleMember Role = iota
	RoleAdmin
)

// MaxMessageRunes 是单条消息的字符上限，按 rune 而不是字节计算。
const MaxMessageRunes = 200

type member struct {
	role  Role
	muted bool
}

type Channel struct {
	ID      string
	Kind    ChannelKind
	members map[uint64]*member
}

// Message 是校验通过、等待路由的消息，不包含连接信息。
type Message struct {
	ChannelID string
	Kind      ChannelKind
	From      uint64
	Text      string
}

// Channels 管理所有频道的成员关系，并发读写由一把读写锁保护。
type Channels struct {
	mu       sync.RWMutex
	channels map[string]*Channel
}

func NewChannels() *Channels {
	return &Channels{channels: make(map[string]*Channel)}
}

func (c *Channels) Create(id string, kind ChannelKind) error {
	if strings.TrimSpace(id) == "" {
		return ErrEmptyChannel
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	if _, ok := c.channels[id]; ok {
		return nil
	}
	c.channels[id] = &Channel{ID: id, Kind: kind, members: make(map[uint64]*member)}
	return nil
}

// PrivateID 把两个玩家 ID 排序后拼成稳定的频道键，双方各自打开都得到同一个频道。
func PrivateID(a, b uint64) string {
	if a > b {
		a, b = b, a
	}
	return fmt.Sprintf("private:%d:%d", a, b)
}

// OpenPrivate 按需创建私聊频道并让双方加入；重复调用不会重复加入。
func (c *Channels) OpenPrivate(a, b uint64) (string, error) {
	id := PrivateID(a, b)
	if err := c.Create(id, KindPrivate); err != nil {
		return "", err
	}
	for _, playerID := range []uint64{a, b} {
		if err := c.Join(id, playerID, RoleMember); err != nil && !errors.Is(err, ErrAlreadyJoined) {
			return "", err
		}
	}
	return id, nil
}

func (c *Channels) Join(channelID string, playerID uint64, role Role) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return ErrChannelNotFound
	}
	if _, exists := ch.members[playerID]; exists {
		return ErrAlreadyJoined
	}
	ch.members[playerID] = &member{role: role}
	return nil
}

func (c *Channels) Leave(channelID string, playerID uint64) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return ErrChannelNotFound
	}
	if _, exists := ch.members[playerID]; !exists {
		return ErrNotMember
	}
	delete(ch.members, playerID)
	return nil
}

// SetMute 只允许频道管理员操作，被禁言者仍然留在频道里，只是不能发言。
func (c *Channels) SetMute(channelID string, actorID, targetID uint64, muted bool) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return ErrChannelNotFound
	}
	actor, ok := ch.members[actorID]
	if !ok {
		return ErrNotMember
	}
	if actor.role != RoleAdmin {
		return ErrNoPermission
	}
	target, ok := ch.members[targetID]
	if !ok {
		return ErrNotMember
	}
	target.muted = muted
	return nil
}

// Speak 依次检查频道存在、成员身份、禁言、系统频道权限和消息长度。
func (c *Channels) Speak(channelID string, playerID uint64, text string) (Message, error) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return Message{}, ErrChannelNotFound
	}
	m, ok := ch.members[playerID]
	if !ok {
		return Message{}, ErrNotMember
	}
	if m.muted {
		return Message{}, ErrMuted
	}
	if ch.Kind == KindSystem && m.role != RoleAdmin {
		return Message{}, ErrNoPermission
	}
	if strings.TrimSpace(text) == "" {
		return Message{}, ErrEmptyMessage
	}
	if utf8.RuneCountInString(text) > MaxMessageRunes {
		return Message{}, ErrMessageTooLong
	}
	return Message{ChannelID: ch.ID, Kind: ch.Kind, From: playerID, Text: text}, nil
}

func (c *Channels) IsMember(channelID string, playerID uint64) bool {
	c.mu.RLock()
	defer c.mu.RUnlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return false
	}
	_, exists := ch.members[playerID]
	return exists
}

func (c *Channels) IsMuted(channelID string, playerID uint64) bool {
	c.mu.RLock()
	defer c.mu.RUnlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return false
	}
	m, exists := ch.members[playerID]
	return exists && m.muted
}

// Members 返回成员快照，调用方无法通过返回值改动频道内部状态。
func (c *Channels) Members(channelID string) []uint64 {
	c.mu.RLock()
	defer c.mu.RUnlock()
	ch, ok := c.channels[channelID]
	if !ok {
		return nil
	}
	ids := make([]uint64, 0, len(ch.members))
	for id := range ch.members {
		ids = append(ids, id)
	}
	return ids
}

cd .local/checks/gs-practice-lab && gofmt -l ch10/chat && go vet ./ch10/chat/ && go test ./ch10/chat/ -count=1

ok  	gspractice/ch10/chat	0.233s