Components now knows why client exist

examples/frameworkServer/main.go

@@ -22,21 +22,20 @@ var addr = flag.String("Address", "127.0.0.1:25565", "Listening address")
 var iconPath = flag.String("ServerIcon", "./server-icon.png", "The path to server icon")
 var maxPlayer = flag.Int("MaxPlayer", 16384, "The maximum number of players")
 var regionPath = flag.String("Regions", "./save/testdata/region/", "The region files")
+var playerdataPath = flag.String("PlayerData", "./save/testdata/playerdata", "The player data files")
 
 func main() {
 	flag.Parse()
+	logger := Logger{log.Default()}
 	playerList := server.NewPlayerList(*maxPlayer)
 	serverInfo, err := server.NewPingInfo(playerList, server.ProtocolName, server.ProtocolVersion, motd, readIcon())
 	if err != nil {
-		log.Fatalf("Set server info error: %v", err)
+		logger.Fatalf("Set server info error: %v", err)
 	}
-
 	keepAlive := server.NewKeepAlive()
-	//playerInfo := player.NewPlayerInfo(keepAlive)
-
 	commands := command.NewGraph()
 	handleFunc := func(ctx context.Context, args []command.ParsedData) error {
-		log.Printf("Command: args: %v", args)
+		logger.Printf("Command: args: %v", args)
 		return nil
 	}
 	commands.AppendLiteral(commands.Literal("me").
@@ -53,8 +52,8 @@ func main() {
 		HandleFunc(handleFunc),
 	)
 	game := server.NewGame(
+		logger,
 		playerList,
-		//playerInfo,
 		keepAlive,
 		commands,
 	)
@@ -63,7 +62,7 @@ func main() {
 	dimList.Add(game.CreateEntity(world.NewDimension(
 		"minecraft:overworld", *regionPath,
 	)), "minecraft:overworld")
-	player.SpawnSystem(game, "./save/testdata/playerdata")
+	player.SpawnSystem(game, *playerdataPath)
 	player.PosAndRotSystem(game)
 	go game.Run(context.Background())
 
@@ -97,3 +96,21 @@ func readIcon() image.Image {
 	}
 	return icon
 }
+
+type Logger struct{ *log.Logger }
+
+func (l Logger) Init(g *server.Game) {
+	l.Print("Server init")
+}
+
+func (l Logger) Run(ctx context.Context) {
+	l.Print("Server is running")
+}
+
+func (l Logger) ClientJoin(c *server.Client, p *server.Player) {
+	l.Printf("Player join [%s]%v from %v", p.Name, p.UUID, c.Socket.RemoteAddr())
+}
+
+func (l Logger) ClientLeft(c *server.Client, p *server.Player, reason error) {
+	l.Printf("Player left [%s]%v reason: %v", p.Name, p.UUID, reason)
+}

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) Run(ctx context.Context)                                               {}
-func (c *ClientInformation) ClientJoin(p *server.Client) {}
+func (c *ClientInformation) ClientJoin(client *server.Client, player *server.Player)               {}
-func (c *ClientInformation) ClientLeft(p *server.Client) {}
+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)
+							arg := storages[i].MethodByName("GetValue").Call([]reflect.Value{reflect.ValueOf(eid)})[0]
-							if arg == nil {
+							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)