《游戏服务端编程实践》10.2.2 公会 / 联盟模块

// file: ch10/social/guild.go
// tier: L1
// verify: go test ./ch10/social/

package social

import (
	"errors"
	"sync"
)

// GuildRole 的数值越大权限越高。
type GuildRole int

const (
	GuildMember GuildRole = iota
	GuildManager
	GuildLeader
)

type GuildState int

const (
	GuildActive GuildState = iota
	GuildClosed
)

var (
	ErrGuildDisbanded   = errors.New("social: guild disbanded")
	ErrGuildFull        = errors.New("social: guild is full")
	ErrAlreadyMember    = errors.New("social: already a guild member")
	ErrNotMember        = errors.New("social: not a guild member")
	ErrPermissionDenied = errors.New("social: guild permission denied")
	ErrGuildApplyMiss   = errors.New("social: guild apply not found")
	ErrInvalidRole      = errors.New("social: invalid guild role change")
)

// GuildEvent 是不可变的公会日志记录。
type GuildEvent struct {
	Seq    uint64
	Kind   string
	Actor  uint64
	Target uint64
}

// Guild 的成员、申请、资产和日志都受同一把锁保护。
type Guild struct {
	mu       sync.Mutex
	id       uint64
	name     string
	capacity int
	state    GuildState
	members  map[uint64]GuildRole
	applies  map[uint64]struct{}
	events   []GuildEvent
	seq      uint64
}

func NewGuild(id uint64, name string, leaderID uint64, capacity int) *Guild {
	if capacity <= 0 {
		capacity = 1
	}
	g := &Guild{
		id: id, name: name, capacity: capacity, state: GuildActive,
		members: map[uint64]GuildRole{leaderID: GuildLeader},
		applies: make(map[uint64]struct{}),
	}
	g.recordLocked("create", leaderID, 0)
	return g
}

// Apply 只登记申请，容量在同意时还会再校验一次。
func (g *Guild) Apply(playerID uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if g.state != GuildActive {
		return ErrGuildDisbanded
	}
	if _, ok := g.members[playerID]; ok {
		return ErrAlreadyMember
	}
	if len(g.members) >= g.capacity {
		return ErrGuildFull
	}
	g.applies[playerID] = struct{}{}
	return nil
}

func (g *Guild) Approve(actor, playerID uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if err := g.requireLocked(actor, GuildManager); err != nil {
		return err
	}
	if _, ok := g.applies[playerID]; !ok {
		return ErrGuildApplyMiss
	}
	if len(g.members) >= g.capacity {
		return ErrGuildFull
	}
	delete(g.applies, playerID)
	g.members[playerID] = GuildMember
	g.recordLocked("join", actor, playerID)
	return nil
}

// Kick 不允许踢会长，也不允许同级踢同级。
func (g *Guild) Kick(actor, target uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if err := g.requireLocked(actor, GuildManager); err != nil {
		return err
	}
	role, ok := g.members[target]
	if !ok {
		return ErrNotMember
	}
	if role >= g.members[actor] {
		return ErrPermissionDenied
	}
	delete(g.members, target)
	g.recordLocked("kick", actor, target)
	return nil
}

// Leave 在会长离开时把职位交给权限最高、ID 最小的成员。
func (g *Guild) Leave(playerID uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if g.state != GuildActive {
		return ErrGuildDisbanded
	}
	role, ok := g.members[playerID]
	if !ok {
		return ErrNotMember
	}
	if role == GuildLeader {
		if len(g.members) == 1 {
			g.disbandLocked(playerID)
			return nil
		}
		successor := g.successorLocked(playerID)
		g.members[successor] = GuildLeader
		g.recordLocked("transfer", playerID, successor)
	}
	delete(g.members, playerID)
	g.recordLocked("leave", playerID, 0)
	return nil
}

// Transfer 显式转让会长，原会长降为普通成员。
func (g *Guild) Transfer(actor, target uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if err := g.requireLocked(actor, GuildLeader); err != nil {
		return err
	}
	if _, ok := g.members[target]; !ok {
		return ErrNotMember
	}
	g.members[actor] = GuildMember
	g.members[target] = GuildLeader
	g.recordLocked("transfer", actor, target)
	return nil
}

// Promote 只有会长可以调用，避免管理员互相提权。
func (g *Guild) Promote(actor, target uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if err := g.requireLocked(actor, GuildLeader); err != nil {
		return err
	}
	role, ok := g.members[target]
	if !ok {
		return ErrNotMember
	}
	if role != GuildMember {
		return ErrInvalidRole
	}
	g.members[target] = GuildManager
	g.recordLocked("promote", actor, target)
	return nil
}

// Disband 只允许会长执行，成员和申请一次性清空。
func (g *Guild) Disband(actor uint64) error {
	g.mu.Lock()
	defer g.mu.Unlock()
	if err := g.requireLocked(actor, GuildLeader); err != nil {
		return err
	}
	g.disbandLocked(actor)
	return nil
}

func (g *Guild) MemberCount() int {
	g.mu.Lock()
	defer g.mu.Unlock()
	return len(g.members)
}

func (g *Guild) RoleOf(playerID uint64) (GuildRole, bool) {
	g.mu.Lock()
	defer g.mu.Unlock()
	role, ok := g.members[playerID]
	return role, ok
}

func (g *Guild) State() GuildState {
	g.mu.Lock()
	defer g.mu.Unlock()
	return g.state
}

func (g *Guild) LastEvent() GuildEvent {
	g.mu.Lock()
	defer g.mu.Unlock()
	if len(g.events) == 0 {
		return GuildEvent{}
	}
	return g.events[len(g.events)-1]
}

func (g *Guild) requireLocked(playerID uint64, min GuildRole) error {
	if g.state != GuildActive {
		return ErrGuildDisbanded
	}
	role, ok := g.members[playerID]
	if !ok {
		return ErrNotMember
	}
	if role < min {
		return ErrPermissionDenied
	}
	return nil
}

func (g *Guild) successorLocked(exclude uint64) uint64 {
	var best uint64
	var bestRole GuildRole = -1
	for id, role := range g.members {
		if id == exclude {
			continue
		}
		if role > bestRole || (role == bestRole && id < best) {
			best, bestRole = id, role
		}
	}
	return best
}

func (g *Guild) disbandLocked(actor uint64) {
	g.state = GuildClosed
	g.members = make(map[uint64]GuildRole)
	g.applies = make(map[uint64]struct{})
	g.recordLocked("disband", actor, 0)
}

func (g *Guild) recordLocked(kind string, actor, target uint64) {
	g.seq++
	g.events = append(g.events, GuildEvent{g.seq, kind, actor, target})
}

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

ok  	gspractice/ch10/social	0.293s