Unify all components

examples/frameworkServer/main.go

@@ -29,8 +29,13 @@ func main() {
 	chunk00 := level.ChunkFromSave(readChunk00(), 256)
 	defaultDimension.LoadChunk(level.ChunkPos{X: 0, Z: 0}, chunk00)
 
-	game := server.NewGame(defaultDimension, playerList)
+	game := server.NewGame(
-	game.Run(context.Background())
+		defaultDimension,
+		playerList,
+		server.NewKeepAlive(),
+		server.NewGlobalChat(),
+	)
+	go game.Run(context.Background())
 
 	s := server.Server{
 		ListPingHandler: serverInfo,

server/chat.go

@@ -23,8 +23,8 @@ type chatItem struct {
 	text string
 }
 
-func NewGlobalChat() GlobalChat {
+func NewGlobalChat() *GlobalChat {
-	return GlobalChat{
+	return &GlobalChat{
 		msg:     make(chan chatItem),
 		join:    make(chan *Player),
 		quit:    make(chan *Player),
@@ -34,7 +34,7 @@ func NewGlobalChat() GlobalChat {
 
 func (g *GlobalChat) AddPlayer(p *Player) {
 	g.join <- p
-	p.Add(PacketHandler{
+	p.AddHandler(PacketHandler{
 		ID: packetid.ServerboundChat,
 		F: func(packet Packet757) error {
 			var msg pk.String
@@ -52,7 +52,7 @@ func (g *GlobalChat) RemovePlayer(p *Player) {
 	g.quit <- p
 }
 
-func (c chatItem) ToMessage() chat.Message {
+func (c chatItem) toMessage() chat.Message {
 	return chat.TranslateMsg(
 		"chat.type.text",
 		chat.Message{
@@ -95,7 +95,7 @@ func (g *GlobalChat) Run(ctx context.Context) {
 		case item := <-g.msg:
 			packet := Packet757(pk.Marshal(
 				packetid.ClientboundChat,
-				item.ToMessage(),
+				item.toMessage(),
 				pk.Byte(0),
 				pk.UUID(item.p.UUID),
 			))

server/gameplay.go

@@ -3,11 +3,11 @@ package server
 import (
 	"context"
 	_ "embed"
+	"sync"
 	"sync/atomic"
 
 	"github.com/google/uuid"
 
-	"github.com/Tnze/go-mc/chat"
 	"github.com/Tnze/go-mc/data/packetid"
 	"github.com/Tnze/go-mc/nbt"
 	"github.com/Tnze/go-mc/net"
@@ -23,11 +23,16 @@ type GamePlay interface {
 }
 
 type Game struct {
+	Dim        Level
+	components []Component
+
 	eid int32
-	Dim Level
+}
-	*PlayerList
+
-	KeepAlive  KeepAlive
+type Component interface {
-	GlobalChat GlobalChat
+	Run(ctx context.Context)
+	AddPlayer(p *Player)
+	RemovePlayer(p *Player)
 }
 
 //go:embed DimensionCodec.snbt
@@ -36,30 +41,26 @@ var dimensionCodecSNBT string
 //go:embed Dimension.snbt
 var dimensionSNBT string
 
-func NewGame(dim Level, playerList *PlayerList) *Game {
+func NewGame(dim Level, components ...Component) *Game {
 	return &Game{
 		Dim:        dim,
-		PlayerList: playerList,
+		components: components,
-		KeepAlive:  NewKeepAlive(),
-		GlobalChat: NewGlobalChat(),
 	}
 }
 
 func (g *Game) Run(ctx context.Context) {
-	go g.KeepAlive.Run(ctx)
+	var wg sync.WaitGroup
-	go g.GlobalChat.Run(ctx)
+	wg.Add(len(g.components))
+	for _, c := range g.components {
+		go func(c Component) {
+			defer wg.Done()
+			c.Run(ctx)
+		}(c)
+	}
+	wg.Wait()
 }
 
 func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net.Conn) {
-	remove := g.PlayerList.TryInsert(PlayerSample{Name: name, ID: id})
-	if remove == nil {
-		_ = conn.WritePacket(pk.Marshal(
-			packetid.ClientboundDisconnect,
-			chat.TranslateMsg("multiplayer.disconnect.server_full"),
-		))
-		return
-	}
-	defer remove()
 	p := &Player{
 		Conn:     conn,
 		Name:     name,
@@ -67,6 +68,7 @@ func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net
 		EntityID: g.newEID(),
 		Gamemode: 1,
 		handlers: make(map[int32][]packetHandlerFunc),
+		errChan:  make(chan error, 1),
 	}
 	dimInfo := g.Dim.Info()
 	err := p.WritePacket(Packet757(pk.Marshal(
@@ -94,11 +96,14 @@ func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net
 	g.Dim.PlayerJoin(p)
 	defer g.Dim.PlayerQuit(p)
 
-	g.KeepAlive.AddPlayer(p)
+	for _, c := range g.components {
-	defer g.KeepAlive.RemovePlayer(p)
+		c.AddPlayer(p)
-
+		if err := p.GetErr(); err != nil {
-	g.GlobalChat.AddPlayer(p)
+			return
-	defer g.GlobalChat.RemovePlayer(p)
+		}
+		//goland:noinspection GoDeferInLoop
+		defer c.RemovePlayer(p)
+	}
 
 	var packet pk.Packet
 	for {
@@ -108,9 +113,9 @@ func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net
 		}
 		for _, ph := range p.handlers[packet.ID] {
 			err = ph(Packet757(packet))
-		}
+			if err != nil {
-		if err != nil {
+				return
-			return
+			}
 		}
 	}
 }

server/keepalive.go

@@ -35,21 +35,23 @@ type KeepAlive struct {
 	//updatePlayerDelay func(p *Player, delay time.Duration)
 }
 
-func NewKeepAlive() (k KeepAlive) {
+func NewKeepAlive() (k *KeepAlive) {
-	k.join = make(chan *Player)
+	return &KeepAlive{
-	k.quit = make(chan *Player)
+		join:        make(chan *Player),
-	k.tick = make(chan *Player)
+		quit:        make(chan *Player),
-	k.pingList = list.New()
+		tick:        make(chan *Player),
-	k.waitList = list.New()
+		pingList:    list.New(),
-	k.listIndex = make(map[uuid.UUID]*list.Element)
+		waitList:    list.New(),
-	k.listTimer = time.NewTimer(keepAliveInterval)
+		listIndex:   make(map[uuid.UUID]*list.Element),
-	k.waitTimer = time.NewTimer(keepAliveWaitInterval)
+		listTimer:   time.NewTimer(keepAliveInterval),
-	return
+		waitTimer:   time.NewTimer(keepAliveWaitInterval),
+		keepAliveID: 0,
+	}
 }
 
 func (k *KeepAlive) AddPlayer(p *Player) {
 	k.join <- p
-	p.Add(PacketHandler{
+	p.AddHandler(PacketHandler{
 		ID: packetid.ServerboundKeepAlive,
 		F: func(packet Packet757) error {
 			var KeepAliveID pk.Long
@@ -91,7 +93,6 @@ func (k KeepAlive) pushPlayer(p *Player) {
 	)
 }
 
-//goland:noinspection GoDeferInLoop
 func (k *KeepAlive) removePlayer(p *Player) {
 	elem := k.listIndex[p.UUID]
 	delete(k.listIndex, p.UUID)

server/player.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"strconv"
 	"sync"
 
 	"github.com/google/uuid"
@@ -18,6 +19,8 @@ type Player struct {
 	EntityID int32
 	Gamemode byte
 	handlers map[int32][]packetHandlerFunc
+
+	errChan chan error
 }
 
 // Packet757 is a packet in protocol 757.
@@ -28,7 +31,24 @@ type Packet757 pk.Packet
 func (p *Player) WritePacket(packet Packet757) error {
 	p.writeLock.Lock()
 	defer p.writeLock.Unlock()
-	return p.Conn.WritePacket(pk.Packet(packet))
+	err := p.Conn.WritePacket(pk.Packet(packet))
+	if err != nil {
+		return WritePacketError{Err: err, ID: packet.ID}
+	}
+	return nil
+}
+
+type WritePacketError struct {
+	Err error
+	ID  int32
+}
+
+func (s WritePacketError) Error() string {
+	return "server: send packet " + strconv.FormatInt(int64(s.ID), 16) + " error: " + s.Err.Error()
+}
+
+func (s WritePacketError) Unwrap() error {
+	return s.Err
 }
 
 type PacketHandler struct {
@@ -38,8 +58,7 @@ type PacketHandler struct {
 
 type packetHandlerFunc func(packet Packet757) error
 
-func (p *Player) Add(ph PacketHandler) {
+func (p *Player) AddHandler(ph PacketHandler) {
-
 	if p.handlers == nil {
 		p.handlers = make(map[int32][]packetHandlerFunc)
 	}
@@ -47,5 +66,18 @@ func (p *Player) Add(ph PacketHandler) {
 }
 
 func (p *Player) PutErr(err error) {
-	// TODO: handle errors
+	select {
+	case p.errChan <- err:
+	default:
+		// previous error exist, ignore this.
+	}
+}
+
+func (p *Player) GetErr() error {
+	select {
+	case err := <-p.errChan:
+		return err
+	default:
+		return nil
+	}
 }

server/playerlist.go

@@ -1,15 +1,22 @@
 package server
 
 import (
-	"container/list"
+	"context"
+	"errors"
 	"sync"
+
+	"github.com/google/uuid"
+
+	"github.com/Tnze/go-mc/chat"
+	"github.com/Tnze/go-mc/data/packetid"
+	pk "github.com/Tnze/go-mc/net/packet"
 )
 
 // PlayerList is a player list based on linked-list.
 // This struct should not be copied after used.
 type PlayerList struct {
 	maxPlayer int
-	players   *list.List
+	players   map[uuid.UUID]*Player
 	// Only the linked-list is protected by this Mutex.
 	// Because others field never change after created.
 	playersLock sync.Mutex
@@ -19,27 +26,36 @@ type PlayerList struct {
 func NewPlayerList(maxPlayers int) *PlayerList {
 	return &PlayerList{
 		maxPlayer: maxPlayers,
-		players:   list.New(),
+		players:   make(map[uuid.UUID]*Player),
 	}
 }
 
-// TryInsert trying to insert player into PlayerList.
+func (p *PlayerList) Run(context.Context) {}
-// Return nil if the server is full (length of list larger than maxPlayers),
+
-// otherwise return a function which is used to remove the player from PlayerList
+func (p *PlayerList) AddPlayer(player *Player) {
-func (p *PlayerList) TryInsert(player PlayerSample) (remove func()) {
 	p.playersLock.Lock()
 	defer p.playersLock.Unlock()
 
-	if p.players.Len() >= p.maxPlayer {
+	if len(p.players) >= p.maxPlayer {
-		return nil
+		err := player.WritePacket(Packet757(pk.Marshal(
+			packetid.ClientboundDisconnect,
+			chat.TranslateMsg("multiplayer.disconnect.server_full"),
+		)))
+		if err != nil {
+			player.PutErr(err)
+		} else {
+			player.PutErr(errors.New("playerlist: server full"))
+		}
+		return
 	}
 
-	elem := p.players.PushBack(player)
+	p.players[player.UUID] = player
-	return func() {
+}
-		p.playersLock.Lock()
+
-		p.players.Remove(elem)
+func (p *PlayerList) RemovePlayer(player *Player) {
-		p.playersLock.Unlock()
+	p.playersLock.Lock()
-	}
+	defer p.playersLock.Unlock()
+	delete(p.players, player.UUID)
 }
 
 func (p *PlayerList) MaxPlayer() int {
@@ -49,22 +65,24 @@ func (p *PlayerList) MaxPlayer() int {
 func (p *PlayerList) OnlinePlayer() int {
 	p.playersLock.Lock()
 	defer p.playersLock.Unlock()
-	return p.players.Len()
+	return len(p.players)
 }
 
 func (p *PlayerList) PlayerSamples() (sample []PlayerSample) {
 	p.playersLock.Lock()
 	defer p.playersLock.Unlock()
 	// Up to 10 players can be returned
-	length := p.players.Len()
+	sample = make([]PlayerSample, len(p.players))
-	if length > 10 {
+	var i int
-		length = 10
+	for _, v := range p.players {
-	}
+		sample[i] = PlayerSample{
-	sample = make([]PlayerSample, length)
+			Name: v.Name,
-	v := p.players.Front()
+			ID:   v.UUID,
-	for i := 0; i < length; i++ {
+		}
-		sample[i] = v.Value.(PlayerSample)
+		i++
-		v = v.Next()
+		if i >= len(p.players) {
+			break
+		}
 	}
 	return
 }