player and dimension loader with ecs system

server/keepalive.go

@@ -4,11 +4,11 @@ import (
 	"container/list"
 	"context"
 	"errors"
-	"github.com/google/uuid"
 	"time"
 
 	"github.com/Tnze/go-mc/data/packetid"
 	pk "github.com/Tnze/go-mc/net/packet"
+	"github.com/Tnze/go-mc/server/ecs"
 )
 
 // keepAliveInterval represents the interval when the server sends keep alive
@@ -17,54 +17,60 @@ const keepAliveInterval = time.Second * 15
 // keepAliveWaitInterval represents how long does the player expired
 const keepAliveWaitInterval = time.Second * 30
 
+type ClientDelay struct {
+	Delay time.Duration
+}
+
 type KeepAlive struct {
-	join chan *Player
-	quit chan *Player
-	tick chan *Player
+	join chan *Client
+	quit chan *Client
+	tick chan *Client
 
 	pingList  *list.List
 	waitList  *list.List
-	listIndex map[uuid.UUID]*list.Element
+	listIndex map[*Client]*list.Element
 	listTimer *time.Timer
 	waitTimer *time.Timer
 	// The Notchian server uses a system-dependent time in milliseconds to generate the keep alive ID value.
 	// We don't do that here for security reason.
 	keepAliveID int64
 
-	updatePlayerDelay func(p *Player, delay time.Duration)
+	updatePlayerDelay []func(p *Client, delay time.Duration)
 }
 
 func NewKeepAlive() (k *KeepAlive) {
 	return &KeepAlive{
-		join:        make(chan *Player),
-		quit:        make(chan *Player),
-		tick:        make(chan *Player),
+		join:        make(chan *Client),
+		quit:        make(chan *Client),
+		tick:        make(chan *Client),
 		pingList:    list.New(),
 		waitList:    list.New(),
-		listIndex:   make(map[uuid.UUID]*list.Element),
+		listIndex:   make(map[*Client]*list.Element),
 		listTimer:   time.NewTimer(keepAliveInterval),
 		waitTimer:   time.NewTimer(keepAliveWaitInterval),
 		keepAliveID: 0,
 	}
 }
 
-func (k *KeepAlive) AddPlayerDelayUpdateHandler(f func(p *Player, delay time.Duration)) {
-	if k.updatePlayerDelay != nil {
-		panic("add player update handler twice")
-	}
-	k.updatePlayerDelay = f
+func (k *KeepAlive) AddPlayerDelayUpdateHandler(f func(p *Client, delay time.Duration)) {
+	k.updatePlayerDelay = append(k.updatePlayerDelay, f)
 }
 
 // Init implement Component for KeepAlive
 func (k *KeepAlive) Init(g *Game) {
+	ecs.Register[ClientDelay, *ecs.HashMapStorage[ClientDelay]](g.World)
+	k.AddPlayerDelayUpdateHandler(func(p *Client, delay time.Duration) {
+		c := ClientDelay{Delay: delay}
+		ecs.GetComponent[ClientDelay](g.World).SetValue(p.Index, c)
+	})
 	g.AddHandler(&PacketHandler{
 		ID: packetid.ServerboundKeepAlive,
-		F: func(player *Player, packet Packet758) error {
+		F: func(client *Client, player *Player, packet Packet758) error {
 			var KeepAliveID pk.Long
 			if err := pk.Packet(packet).Scan(&KeepAliveID); err != nil {
 				return err
 			}
-			k.tick <- player
+			k.tick <- client
 			return nil
 		},
 	})
@@ -90,21 +96,21 @@ func (k *KeepAlive) Run(ctx context.Context) {
 	}
 }
 
-// AddPlayer implement Component for KeepAlive
-func (k *KeepAlive) AddPlayer(player *Player) { k.join <- player }
+// ClientJoin implement Component for KeepAlive
+func (k *KeepAlive) ClientJoin(client *Client, _ *Player) { k.join <- client }
 
-// RemovePlayer implement Component for KeepAlive
-func (k *KeepAlive) RemovePlayer(p *Player) { k.quit <- p }
+// ClientLeft implement Component for KeepAlive
+func (k *KeepAlive) ClientLeft(client *Client, _ *Player) { k.quit <- client }
 
-func (k KeepAlive) pushPlayer(p *Player) {
-	k.listIndex[p.UUID] = k.pingList.PushBack(
+func (k KeepAlive) pushPlayer(p *Client) {
+	k.listIndex[p] = k.pingList.PushBack(
 		keepAliveItem{player: p, t: time.Now()},
 	)
 }
 
-func (k *KeepAlive) removePlayer(p *Player) {
-	elem := k.listIndex[p.UUID]
-	delete(k.listIndex, p.UUID)
+func (k *KeepAlive) removePlayer(p *Client) {
+	elem := k.listIndex[p]
+	delete(k.listIndex, p)
 	if elem.Prev() == nil {
 		// At present, it is difficult to distinguish
 		// which linked list the player is in,
@@ -126,7 +132,7 @@ func (k *KeepAlive) pingPlayer(now time.Time) {
 		)))
 		k.keepAliveID++
 		// Clientbound KeepAlive packet is sent, move the player to waiting list.
-		k.listIndex[p.UUID] = k.waitList.PushBack(
+		k.listIndex[p] = k.waitList.PushBack(
 			keepAliveItem{player: p, t: now},
 		)
 	}
@@ -134,10 +140,10 @@ func (k *KeepAlive) pingPlayer(now time.Time) {
 	keepAliveSetTimer(k.pingList, k.listTimer, keepAliveInterval)
 }
 
-func (k *KeepAlive) tickPlayer(p *Player) {
-	elem, ok := k.listIndex[p.UUID]
+func (k *KeepAlive) tickPlayer(p *Client) {
+	elem, ok := k.listIndex[p]
 	if !ok {
-		p.PutErr(errors.New("keepalive: fail to tick player: " + p.UUID.String() + " not found"))
+		p.PutErr(errors.New("keepalive: fail to tick player: client not found"))
 		return
 	}
 	if elem.Prev() == nil {
@@ -147,13 +153,13 @@ func (k *KeepAlive) tickPlayer(p *Player) {
 		defer keepAliveSetTimer(k.waitList, k.waitTimer, keepAliveWaitInterval)
 	}
 	// update delay of player
-	t := k.waitList.Remove(elem).(keepAliveItem).t
 	now := time.Now()
-	if k.updatePlayerDelay != nil {
-		k.updatePlayerDelay(p, now.Sub(t))
+	delay := now.Sub(k.waitList.Remove(elem).(keepAliveItem).t)
+	for _, f := range k.updatePlayerDelay {
+		f(p, delay)
 	}
 	// move the player to ping list
-	k.listIndex[p.UUID] = k.pingList.PushBack(
+	k.listIndex[p] = k.pingList.PushBack(
 		keepAliveItem{player: p, t: now},
 	)
 }
@@ -180,6 +186,6 @@ func keepAliveSetTimer(l *list.List, timer *time.Timer, interval time.Duration)
 }
 
 type keepAliveItem struct {
-	player *Player
+	player *Client
 	t      time.Time
 }