Components now knows why client exist

server/clientinfo/clientinfo.go

@@ -84,6 +84,6 @@ func (c *ClientInformation) Init(g *server.Game) {
 	})
 }
 
-func (c *ClientInformation) Run(ctx context.Context)     {}
-func (c *ClientInformation) ClientJoin(p *server.Client) {}
-func (c *ClientInformation) ClientLeft(p *server.Client) {}
+func (c *ClientInformation) Run(ctx context.Context)                                               {}
+func (c *ClientInformation) ClientJoin(client *server.Client, player *server.Player)               {}
+func (c *ClientInformation) ClientLeft(client *server.Client, player *server.Player, reason error) {}

server/command/component.go

@@ -41,4 +41,4 @@ func (g *Graph) ClientJoin(client *server.Client, _ *server.Player) {
 }
 
 // ClientLeft implement server.Component for Graph
-func (g *Graph) ClientLeft(_ *server.Client, _ *server.Player) {}
+func (g *Graph) ClientLeft(_ *server.Client, _ *server.Player, _ error) {}

server/ecs/system.go

@@ -32,27 +32,27 @@ func FuncSystem(F any) System {
 	}
 	return &funcsystem{
 		update: func(w *World) {
-			storages := make([]Storage, in)
+			storages := make([]reflect.Value, in)
 			for i := 0; i < in; i++ {
-				storages[i] = w.GetResourceRaw(argTypes[i]).(Storage)
+				storages[i] = reflect.ValueOf(w.GetResourceRaw(argTypes[i]))
 			}
 			args := make([]reflect.Value, len(storages))
 			if len(storages) > 0 {
-				set := reflect.ValueOf(storages[0]).FieldByName("BitSet").Addr()
+				set := reflect.Indirect(storages[0]).FieldByName("BitSet").Addr()
 				for _, v := range storages[1:] {
-					p := reflect.ValueOf(v).FieldByName("BitSet").Addr()
+					p := reflect.Indirect(v).FieldByName("BitSet").Addr()
 					set = set.MethodByName("And").Call([]reflect.Value{p})[0]
 				}
 				set.MethodByName("Range").Call([]reflect.Value{
 					reflect.ValueOf(func(eid Index) {
 						for i := range args {
-							arg := storages[i].GetValueAny(eid)
-							if arg == nil {
+							arg := storages[i].MethodByName("GetValue").Call([]reflect.Value{reflect.ValueOf(eid)})[0]
+							if arg.IsNil() {
 								args[i] = reflect.Zero(argTypes[i])
 							} else if needCopy[i] {
-								args[i] = reflect.ValueOf(arg).Elem()
+								args[i] = arg.Elem()
 							} else {
-								args[i] = reflect.ValueOf(arg)
+								args[i] = arg
 							}
 						}
 						f.Call(args)

server/gameplay.go

@@ -40,7 +40,7 @@ type Component interface {
 	Init(g *Game)
 	Run(ctx context.Context)
 	ClientJoin(c *Client, p *Player)
-	ClientLeft(c *Client, p *Player)
+	ClientLeft(c *Client, p *Player, reason error)
 }
 
 func NewGame(components ...Component) *Game {
@@ -112,21 +112,22 @@ func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net
 		}
 	}()
 
+	var err error
 	for _, component := range g.components {
 		component.ClientJoin(c, p)
-		defer component.ClientLeft(c, p)
+		defer func(cmp Component) { cmp.ClientLeft(c, p, err) }(component)
 	}
 
 	var packet pk.Packet
 	for {
-		if err := c.ReadPacket(&packet); err != nil {
+		if err = c.ReadPacket(&packet); err != nil {
 			return
 		}
 		for _, ph := range g.handlers[packet.ID] {
-			if err := ph.F(c, p, Packet758(packet)); err != nil {
+			if err = ph.F(c, p, Packet758(packet)); err != nil {
 				return
 			}
-			if err := c.GetErr(); err != nil {
+			if err = c.GetErr(); err != nil {
 				return
 			}
 		}

server/keepalive.go

@@ -100,7 +100,7 @@ func (k *KeepAlive) Run(ctx context.Context) {
 func (k *KeepAlive) ClientJoin(client *Client, _ *Player) { k.join <- client }
 
 // ClientLeft implement Component for KeepAlive
-func (k *KeepAlive) ClientLeft(client *Client, _ *Player) { k.quit <- client }
+func (k *KeepAlive) ClientLeft(client *Client, _ *Player, _ error) { k.quit <- client }
 
 func (k KeepAlive) pushPlayer(p *Client) {
 	k.listIndex[p] = k.pingList.PushBack(

server/playerlist.go

@@ -54,7 +54,7 @@ func (p *PlayerList) ClientJoin(client *Client, player *Player) {
 }
 
 // ClientLeft implement Component for PlayerList
-func (p *PlayerList) ClientLeft(_ *Client, player *Player) {
+func (p *PlayerList) ClientLeft(_ *Client, player *Player, _ error) {
 	p.playersLock.Lock()
 	defer p.playersLock.Unlock()
 	delete(p.clients, player.UUID)