feat: 房间管理器实现

game/room/errors.go

@@ -0,0 +1,12 @@
+package room
+
+import "errors"
+
+var (
+	// ErrRoomNotExist 房间不存在
+	ErrRoomNotExist = errors.New("room not exist")
+	// ErrRoomPlayerFull 房间人数已满
+	ErrRoomPlayerFull = errors.New("room player full")
+	// ErrPlayerNotExist 玩家不存在
+	ErrPlayerNotExist = errors.New("player not exist")
+)

game/room/events.go

@@ -0,0 +1,95 @@
+package room
+
+import "github.com/kercylan98/minotaur/game"
+
+type (
+	// PlayerJoinRoomEventHandle 玩家加入房间事件处理函数
+	PlayerJoinRoomEventHandle[PID comparable, P game.Player[PID], R Room[PID, P]] func(room R, player P)
+	// PlayerLeaveRoomEventHandle 玩家离开房间事件处理函数
+	PlayerLeaveRoomEventHandle[PID comparable, P game.Player[PID], R Room[PID, P]] func(room R, player P)
+	// PlayerKickedOutEventHandle 玩家被踢出房间事件处理函数
+	PlayerKickedOutEventHandle[PID comparable, P game.Player[PID], R Room[PID, P]] func(room R, executor, kicked PID, reason string)
+)
+
+func newEvent[PID comparable, P game.Player[PID], R Room[PID, P]]() *event[PID, P, R] {
+	return &event[PID, P, R]{
+		playerJoinRoomEventRoomHandles:  make(map[int64][]PlayerJoinRoomEventHandle[PID, P, R]),
+		playerLeaveRoomEventRoomHandles: make(map[int64][]PlayerLeaveRoomEventHandle[PID, P, R]),
+		playerKickedOutEventRoomHandles: make(map[int64][]PlayerKickedOutEventHandle[PID, P, R]),
+	}
+}
+
+type event[PID comparable, P game.Player[PID], R Room[PID, P]] struct {
+	playerJoinRoomEventHandles      []PlayerJoinRoomEventHandle[PID, P, R]
+	playerJoinRoomEventRoomHandles  map[int64][]PlayerJoinRoomEventHandle[PID, P, R]
+	playerLeaveRoomEventHandles     []PlayerLeaveRoomEventHandle[PID, P, R]
+	playerLeaveRoomEventRoomHandles map[int64][]PlayerLeaveRoomEventHandle[PID, P, R]
+	playerKickedOutEventHandles     []PlayerKickedOutEventHandle[PID, P, R]
+	playerKickedOutEventRoomHandles map[int64][]PlayerKickedOutEventHandle[PID, P, R]
+}
+
+func (slf *event[PID, P, R]) unReg(guid int64) {
+	delete(slf.playerJoinRoomEventRoomHandles, guid)
+	delete(slf.playerLeaveRoomEventRoomHandles, guid)
+	delete(slf.playerKickedOutEventRoomHandles, guid)
+}
+
+// RegPlayerJoinRoomEvent 玩家进入房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerJoinRoomEvent(handle PlayerJoinRoomEventHandle[PID, P, R]) {
+	slf.playerJoinRoomEventHandles = append(slf.playerJoinRoomEventHandles, handle)
+}
+
+// OnPlayerJoinRoomEvent 玩家进入房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) OnPlayerJoinRoomEvent(room R, player P) {
+	for _, handle := range slf.playerJoinRoomEventHandles {
+		handle(room, player)
+	}
+	for _, handle := range slf.playerJoinRoomEventRoomHandles[room.GetGuid()] {
+		handle(room, player)
+	}
+}
+
+// RegPlayerJoinRoomEventWithRoom 玩家进入房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerJoinRoomEventWithRoom(room R, handle PlayerJoinRoomEventHandle[PID, P, R]) {
+	slf.playerJoinRoomEventRoomHandles[room.GetGuid()] = append(slf.playerJoinRoomEventRoomHandles[room.GetGuid()], handle)
+}
+
+// RegPlayerLeaveRoomEvent 玩家离开房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerLeaveRoomEvent(handle PlayerLeaveRoomEventHandle[PID, P, R]) {
+	slf.playerLeaveRoomEventHandles = append(slf.playerLeaveRoomEventHandles, handle)
+}
+
+// RegPlayerLeaveRoomEventWithRoom 玩家离开房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerLeaveRoomEventWithRoom(room R, handle PlayerLeaveRoomEventHandle[PID, P, R]) {
+	slf.playerLeaveRoomEventRoomHandles[room.GetGuid()] = append(slf.playerLeaveRoomEventRoomHandles[room.GetGuid()], handle)
+}
+
+// OnPlayerLeaveRoomEvent 玩家离开房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) OnPlayerLeaveRoomEvent(room R, player P) {
+	for _, handle := range slf.playerLeaveRoomEventHandles {
+		handle(room, player)
+	}
+	for _, handle := range slf.playerLeaveRoomEventRoomHandles[room.GetGuid()] {
+		handle(room, player)
+	}
+}
+
+// RegPlayerKickedOutEvent 玩家被踢出房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerKickedOutEvent(handle PlayerKickedOutEventHandle[PID, P, R]) {
+	slf.playerKickedOutEventHandles = append(slf.playerKickedOutEventHandles, handle)
+}
+
+// RegPlayerKickedOutEventWithRoom 玩家被踢出房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) RegPlayerKickedOutEventWithRoom(room R, handle PlayerKickedOutEventHandle[PID, P, R]) {
+	slf.playerKickedOutEventRoomHandles[room.GetGuid()] = append(slf.playerKickedOutEventRoomHandles[room.GetGuid()], handle)
+}
+
+// OnPlayerKickedOutEvent 玩家被踢出房间时将立即执行被注册的事件处理函数
+func (slf *event[PID, P, R]) OnPlayerKickedOutEvent(room R, executor, kicked PID, reason string) {
+	for _, handle := range slf.playerKickedOutEventHandles {
+		handle(room, executor, kicked, reason)
+	}
+	for _, handle := range slf.playerKickedOutEventRoomHandles[room.GetGuid()] {
+		handle(room, executor, kicked, reason)
+	}
+}

game/room/info.go

@@ -0,0 +1,8 @@
+package room
+
+import "github.com/kercylan98/minotaur/game"
+
+type info[PlayerID comparable, P game.Player[PlayerID], R Room[PlayerID, P]] struct {
+	room        R
+	playerLimit int // 玩家人数上限, <= 0 表示无限制
+}

game/room/manager.go

@@ -0,0 +1,259 @@
+package room
+
+import (
+	"github.com/kercylan98/minotaur/game"
+	"github.com/kercylan98/minotaur/utils/concurrent"
+)
+
+// NewManager 创建房间管理器
+func NewManager[PID comparable, P game.Player[PID], R Room[PID, P]]() *Manager[PID, P, R] {
+	manager := &Manager[PID, P, R]{
+		event:   newEvent[PID, P, R](),
+		rooms:   concurrent.NewBalanceMap[int64, *info[PID, P, R]](),
+		players: concurrent.NewBalanceMap[PID, P](),
+		pr:      concurrent.NewBalanceMap[PID, map[int64]struct{}](),
+	}
+
+	return manager
+}
+
+// Manager 房间管理器
+type Manager[PID comparable, P game.Player[PID], R Room[PID, P]] struct {
+	*event[PID, P, R]
+	rooms   *concurrent.BalanceMap[int64, *info[PID, P, R]] // 所有房间
+	players *concurrent.BalanceMap[PID, P]                  // 所有加入房间的玩家
+	pr      *concurrent.BalanceMap[PID, map[int64]struct{}] // 玩家所在房间
+	rp      *concurrent.BalanceMap[int64, map[PID]struct{}] // 房间中的玩家
+
+}
+
+// CreateRoom 创建房间
+func (slf *Manager[PID, P, R]) CreateRoom(room R) {
+	roomInfo := &info[PID, P, R]{room: room}
+	slf.rooms.Set(room.GetGuid(), roomInfo)
+}
+
+// ReleaseRoom 释放房间
+func (slf *Manager[PID, P, R]) ReleaseRoom(guid int64) {
+	slf.unReg(guid)
+	slf.rooms.Delete(guid)
+}
+
+// GetRoom 获取房间
+func (slf *Manager[PID, P, R]) GetRoom(guid int64) R {
+	return slf.rooms.Get(guid).room
+}
+
+// Exist 检查房间是否存在
+func (slf *Manager[PID, P, R]) Exist(guid int64) bool {
+	return slf.rooms.Exist(guid)
+}
+
+// GetRooms 获取所有房间
+func (slf *Manager[PID, P, R]) GetRooms() map[int64]R {
+	var rooms = make(map[int64]R)
+	slf.rooms.Atom(func(m map[int64]*info[PID, P, R]) {
+		for id, info := range m {
+			rooms[id] = info.room
+		}
+	})
+	return rooms
+}
+
+// GetRoomCount 获取房间数量
+func (slf *Manager[PID, P, R]) GetRoomCount() int {
+	return slf.rooms.Size()
+}
+
+// GetRoomPlayerCount 获取房间中玩家数量
+func (slf *Manager[PID, P, R]) GetRoomPlayerCount(guid int64) int {
+	var count int
+	slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+		count = len(m[guid])
+	})
+	return count
+}
+
+// ExistPlayer 检查玩家是否在任一房间内
+func (slf *Manager[PID, P, R]) ExistPlayer(id PID) bool {
+	return slf.players.Exist(id)
+}
+
+// InRoom 检查玩家是否在指定房间内
+func (slf *Manager[PID, P, R]) InRoom(id PID, guid int64) bool {
+	var in bool
+	slf.pr.Atom(func(m map[PID]map[int64]struct{}) {
+		rooms, exist := m[id]
+		if !exist {
+			return
+		}
+		_, in = rooms[guid]
+	})
+	return in
+}
+
+// GetPlayer 获取玩家
+func (slf *Manager[PID, P, R]) GetPlayer(id PID) P {
+	return slf.players.Get(id)
+}
+
+// GetPlayers 获取所有玩家
+func (slf *Manager[PID, P, R]) GetPlayers() *concurrent.BalanceMap[PID, P] {
+	return slf.players
+}
+
+// GetPlayerCount 获取玩家数量
+func (slf *Manager[PID, P, R]) GetPlayerCount() int {
+	return slf.players.Size()
+}
+
+// GetPlayerRoom 获取玩家所在房间
+func (slf *Manager[PID, P, R]) GetPlayerRoom(id PID) []R {
+	var result = make([]R, 0)
+	slf.pr.Atom(func(m map[PID]map[int64]struct{}) {
+		rooms, exist := m[id]
+		if !exist {
+			return
+		}
+		for id := range rooms {
+			result = append(result, slf.rooms.Get(id).room)
+		}
+	})
+	return result
+}
+
+// GetPlayerRoomCount 获取玩家所在房间数量
+func (slf *Manager[PID, P, R]) GetPlayerRoomCount(id PID) int {
+	var count int
+	slf.pr.Atom(func(m map[PID]map[int64]struct{}) {
+		count = len(m[id])
+	})
+	return count
+}
+
+// GetRoomPlayer 获取房间中的玩家
+func (slf *Manager[PID, P, R]) GetRoomPlayer(roomId int64, playerId PID) P {
+	var player P
+	slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+		players, exist := m[roomId]
+		if !exist {
+			return
+		}
+		_, exist = players[playerId]
+		if !exist {
+			return
+		}
+		player = slf.players.Get(playerId)
+	})
+	return player
+}
+
+// GetRoomPlayers 获取房间中的玩家
+func (slf *Manager[PID, P, R]) GetRoomPlayers(guid int64) map[PID]P {
+	var result = make(map[PID]P)
+	slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+		players, exist := m[guid]
+		if !exist {
+			return
+		}
+		for id := range players {
+			result[id] = slf.players.Get(id)
+		}
+	})
+	return result
+}
+
+// GetRoomPlayerLimit 获取房间中的玩家数量上限
+func (slf *Manager[PID, P, R]) GetRoomPlayerLimit(guid int64) int {
+	return slf.rooms.Get(guid).playerLimit
+}
+
+// Leave 使玩家离开房间
+func (slf *Manager[PID, P, R]) Leave(roomId int64, player P) {
+	slf.rooms.Atom(func(m map[int64]*info[PID, P, R]) {
+		room, exist := m[roomId]
+		if !exist {
+			return
+		}
+		slf.OnPlayerLeaveRoomEvent(room.room, player)
+		slf.pr.Atom(func(m map[PID]map[int64]struct{}) {
+			rooms, exist := m[player.GetID()]
+			if !exist {
+				return
+			}
+			delete(rooms, roomId)
+		})
+		slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+			players, exist := m[roomId]
+			if !exist {
+				return
+			}
+			delete(players, player.GetID())
+		})
+	})
+}
+
+// Join 使玩家加入房间
+func (slf *Manager[PID, P, R]) Join(player P, roomId int64) error {
+	var err error
+	slf.rooms.Atom(func(m map[int64]*info[PID, P, R]) {
+		room, exist := m[roomId]
+		if !exist {
+			err = ErrRoomNotExist
+			return
+		}
+		if room.playerLimit > 0 && room.playerLimit <= slf.GetRoomPlayerCount(roomId) {
+			err = ErrRoomPlayerFull
+			return
+		}
+		slf.pr.Atom(func(m map[PID]map[int64]struct{}) {
+			rooms, exist := m[player.GetID()]
+			if !exist {
+				rooms = make(map[int64]struct{})
+				m[player.GetID()] = rooms
+			}
+			rooms[roomId] = struct{}{}
+		})
+		slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+			players, exist := m[roomId]
+			if !exist {
+				players = make(map[PID]struct{})
+				m[roomId] = players
+			}
+			players[player.GetID()] = struct{}{}
+		})
+		slf.players.Set(player.GetID(), player)
+		slf.OnPlayerJoinRoomEvent(room.room, player)
+	})
+	return err
+}
+
+// KickOut 以某种原因踢出特定玩家
+//   - 该函数不会校验任何权限相关的内容，调用后将直接踢出玩家
+func (slf *Manager[PID, P, R]) KickOut(roomId int64, executor, kicked PID, reason string) error {
+	var err error
+	var room R
+	slf.rp.Atom(func(m map[int64]map[PID]struct{}) {
+		players, exist := m[roomId]
+		if !exist {
+			err = ErrPlayerNotExist
+			return
+		}
+		_, exist = players[executor]
+		if !exist {
+			err = ErrPlayerNotExist
+			return
+		}
+		_, exist = players[kicked]
+		if !exist {
+			return
+		}
+		room = slf.rooms.Get(roomId).room
+	})
+	if err == nil {
+		return err
+	}
+	slf.OnPlayerKickedOutEvent(room, executor, kicked, reason)
+	slf.Leave(roomId, slf.players.Get(kicked))
+	return nil
+}

game/room/room.go

@@ -0,0 +1,30 @@
+package room
+
+import "github.com/kercylan98/minotaur/game"
+
+// Room 房间类似于简版的游戏世界(World)，不过没有游戏实体
+type Room[PlayerID comparable, P game.Player[PlayerID]] interface {
+	// GetGuid 获取房间的唯一标识符
+	GetGuid() int64
+	// GetPlayerLimit 获取玩家人数上限
+	GetPlayerLimit() int
+	// GetPlayer 根据玩家id获取玩家
+	GetPlayer(id PlayerID) P
+	// GetPlayers 获取房间中的所有玩家
+	GetPlayers() map[PlayerID]P
+	// GetPlayerCount 获取玩家数量
+	GetPlayerCount() int
+	// IsExistPlayer 检查房间中是否存在特定玩家
+	IsExistPlayer(id PlayerID) bool
+	// IsOwner 检查玩家是否是房主
+	IsOwner(id PlayerID) bool
+	// ChangeOwner 设置玩家为房主
+	ChangeOwner(id PlayerID)
+
+	// Join 使特定玩家加入房间
+	Join(player P) error
+	// Leave 使特定玩家离开房间
+	Leave(id PlayerID)
+	// KickOut 将特定玩家踢出房间
+	KickOut(id, target PlayerID, reason string) error
+}

utils/concurrent/balance_map.go

@@ -21,150 +21,183 @@ func NewBalanceMap[Key comparable, value any](options ...BalanceMapOption[Key, v
 type BalanceMap[Key comparable, Value any] struct {
 	lock sync.RWMutex
 	data map[Key]Value
+	atom bool
 }
 
 // Set 设置一个值
 func (slf *BalanceMap[Key, Value]) Set(key Key, value Value) {
-	slf.lock.Lock()
+	if !slf.atom {
-	defer slf.lock.Unlock()
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	slf.data[key] = value
 }
 
 // Get 获取一个值
 func (slf *BalanceMap[Key, Value]) Get(key Key) Value {
-	slf.lock.RLock()
+	if !slf.atom {
-	defer slf.lock.RUnlock()
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	return slf.data[key]
 }
 
 // Atom 原子操作
 func (slf *BalanceMap[Key, Value]) Atom(handle func(m map[Key]Value)) {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	handle(slf.data)
-	slf.lock.Unlock()
 }
 
 // Exist 判断是否存在
 func (slf *BalanceMap[Key, Value]) Exist(key Key) bool {
-	slf.lock.RLock()
+	if !slf.atom {
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	_, exist := slf.data[key]
-	slf.lock.RUnlock()
 	return exist
 }
 
 // GetExist 获取一个值并判断是否存在
 func (slf *BalanceMap[Key, Value]) GetExist(key Key) (Value, bool) {
-	slf.lock.RLock()
+	if !slf.atom {
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	value, exist := slf.data[key]
-	slf.lock.RUnlock()
 	return value, exist
 }
 
 // Delete 删除一个值
 func (slf *BalanceMap[Key, Value]) Delete(key Key) {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	delete(slf.data, key)
-	defer slf.lock.Unlock()
 }
 
 // DeleteGet 删除一个值并返回
 func (slf *BalanceMap[Key, Value]) DeleteGet(key Key) Value {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	v := slf.data[key]
 	delete(slf.data, key)
-	slf.lock.Unlock()
 	return v
 }
 
 // DeleteGetExist 删除一个值并返回是否存在
 func (slf *BalanceMap[Key, Value]) DeleteGetExist(key Key) (Value, bool) {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	v, exist := slf.data[key]
 	delete(slf.data, key)
-	defer slf.lock.Unlock()
 	return v, exist
 }
 
 // DeleteExist 删除一个值并返回是否存在
 func (slf *BalanceMap[Key, Value]) DeleteExist(key Key) bool {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	if _, exist := slf.data[key]; !exist {
 		slf.lock.Unlock()
 		return exist
 	}
 	delete(slf.data, key)
-	slf.lock.Unlock()
 	return true
 }
 
 // Clear 清空
 func (slf *BalanceMap[Key, Value]) Clear() {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	for k := range slf.data {
 		delete(slf.data, k)
 	}
-	slf.lock.Unlock()
 }
 
 // ClearHandle 清空并处理
 func (slf *BalanceMap[Key, Value]) ClearHandle(handle func(key Key, value Value)) {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	for k, v := range slf.data {
 		handle(k, v)
 		delete(slf.data, k)
 	}
-	slf.lock.Unlock()
 }
 
 // Range 遍历所有值，如果 handle 返回 true 则停止遍历
 func (slf *BalanceMap[Key, Value]) Range(handle func(key Key, value Value) bool) {
-	slf.lock.Lock()
+	if !slf.atom {
+		slf.lock.Lock()
+		defer slf.lock.Unlock()
+	}
 	for k, v := range slf.data {
 		key, value := k, v
 		if handle(key, value) {
 			break
 		}
 	}
-	slf.lock.Unlock()
 }
 
 // Keys 获取所有的键
 func (slf *BalanceMap[Key, Value]) Keys() []Key {
-	slf.lock.RLock()
+	if !slf.atom {
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	var s = make([]Key, 0, len(slf.data))
 	for k := range slf.data {
 		s = append(s, k)
 	}
-	slf.lock.RUnlock()
 	return s
 }
 
 // Slice 获取所有的值
 func (slf *BalanceMap[Key, Value]) Slice() []Value {
-	slf.lock.RLock()
+	if !slf.atom {
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	var s = make([]Value, 0, len(slf.data))
 	for _, v := range slf.data {
 		s = append(s, v)
 	}
-	slf.lock.RUnlock()
 	return s
 }
 
 // Map 转换为普通 map
 func (slf *BalanceMap[Key, Value]) Map() map[Key]Value {
-	slf.lock.RLock()
+	if !slf.atom {
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	var m = make(map[Key]Value)
 	for k, v := range slf.data {
 		m[k] = v
 	}
-	slf.lock.RUnlock()
 	return m
 }
 
 // Size 获取数量
 func (slf *BalanceMap[Key, Value]) Size() int {
-	slf.lock.RLock()
+	if !slf.atom {
-	defer slf.lock.RUnlock()
+		slf.lock.RLock()
+		defer slf.lock.RUnlock()
+	}
 	return len(slf.data)
 }
 
@@ -175,11 +208,13 @@ func (slf *BalanceMap[Key, Value]) MarshalJSON() ([]byte, error) {
 
 func (slf *BalanceMap[Key, Value]) UnmarshalJSON(bytes []byte) error {
 	var m = make(map[Key]Value)
+	if !slf.atom {
+		slf.lock.Lock()
+		slf.lock.Unlock()
+	}
 	if err := json.Unmarshal(bytes, &m); err != nil {
 		return err
 	}
-	slf.lock.Lock()
 	slf.data = m
-	slf.lock.Unlock()
 	return nil
 }