Updated all documentation to reflect changes in v0.10.

Sandertv · Sandertv · commit 037ac4bedcca · 2024-11-23T15:36:35.000+01:00
diff --git a/dev/Commands.md b/dev/Commands.md
@@ -22,6 +22,7 @@ package commands
 
 import (
 	"github.com/df-mc/dragonfly/server/cmd"
+	"github.com/df-mc/dragonfly/server/world"
 )
 
 // ExampleCommand contains our command parameters.
@@ -36,7 +37,7 @@ type ExampleCommand struct {
 }
 
 // Run will be called when the player runs the command. In this case, we will print the number back to the player
-func (c ExampleCommand) Run(source cmd.Source, output *cmd.Output) {
+func (c ExampleCommand) Run(source cmd.Source, output *cmd.Output, tx *world.Tx) {
 	msg, ok := c.OptionalMessage.Load()
 	output.Printf("%d %s (optional arg set? %v)", c.Number, msg, ok)
 }
@@ -66,17 +67,20 @@ commands:
 ```go
 package pet
 
-import "github.com/df-mc/dragonfly/server/cmd"
+import (
+	"github.com/df-mc/dragonfly/server/cmd"
+	"github.com/df-mc/dragonfly/server/world"
+)
 
 type CreateCommand struct {
 	Name cmd.Varargs `cmd:"name"`
 }
 
-func (CreateCommand) Run(source cmd.Source, output *cmd.Output) {}
+func (CreateCommand) Run(source cmd.Source, output *cmd.Output, tx *world.Tx) {}
 
 type DeleteCommand struct {}
 
-func (DeleteCommand) Run(source cmd.Source, output *cmd.Output) {}
+func (DeleteCommand) Run(source cmd.Source, output *cmd.Output, tx *world.Tx) {}
 ```
 
 Now that we have both of these `cmd.Runnable` implementations, we will add a field at the start of these
@@ -86,22 +90,25 @@ added here to make the parser use a different sub command name.
 ```go
 package pet
 
-import "github.com/df-mc/dragonfly/server/cmd"
+import (
+	"github.com/df-mc/dragonfly/server/cmd"
+	"github.com/df-mc/dragonfly/server/world"
+)
 
 type CreateCommand struct {
 	// This sub command will be accessible as /pet create <name>.
 	Create cmd.SubCommand `cmd:"create"`
 	Name cmd.Varargs `cmd:"name"`
 }
 
-func (CreateCommand) Run(source cmd.Source, output *cmd.Output) {}
+func (CreateCommand) Run(source cmd.Source, output *cmd.Output, tx *world.Tx) {}
 
 type DeleteCommand struct {
 	// This subcommand will be accessible as /pet Delete.
 	Delete cmd.SubCommand
 }
 
-func (DeleteCommand) Run(source cmd.Source, output *cmd.Output) {}
+func (DeleteCommand) Run(source cmd.Source, output *cmd.Output, tx *world.Tx) {}
 ```
 
 Having created complete `cmd.Runnable` implementations for both of our subcommands, we can now run `cmd.New` and register the command:
diff --git a/dev/Event-Handlers.md b/dev/Event-Handlers.md
@@ -23,17 +23,14 @@ The first step is to create a new struct type, which we will initially
 put at the bottom of `main.go`:
 ```go
 type MyHandler struct {
-	p *player.Player
+	// Any additional data.
 }
 ```
-`MyHandler` has a `p` field. This will later hold the player that this
-handler will listen to. You can also add other fields that you want to
-use for the duration of a player's session. It is generally recommended 
-to have a `New...` function for your handler to initialise it, so we will 
-create that:
+It is generally recommended to have a `New...` function for your handler to 
+initialise it, so we will create that:
 ```go
-func NewMyHandler(p *player.Player) *MyHandler {
-	return &MyHandler{p: p}
+func NewMyHandler() *MyHandler {
+	return &MyHandler{}
 }
 ```
 As you can see, we return a `*MyHandler` (pointer) as opposed to `MyHandler`.
@@ -45,7 +42,7 @@ will embed the `player.NopHandler` type:
 ```go
 type MyHandler struct {
 	player.NopHandler
-	p *player.Player
+	// Any additional data.
 }
 ```
 `player.NopHandler` is the default `player.Handler` assigned to a player.
@@ -55,9 +52,10 @@ methods if we do not want to. We can now look at [`player.Handler`'s methods]((h
 and see which event we want to handle in `MyHandler`. For this example, we
 will cancel a player sending a chat message and print it to the terminal:
 ```go
-func (m *MyHandler) HandleChat(ctx *event.Context, message *string) {
+func (m *MyHandler) HandleChat(ctx *player.Context, message *string) {
+	p := ctx.Val()
 	ctx.Cancel()
-	fmt.Println("Player", m.p.Name(), "tried to send:", *message)
+	fmt.Println("Player", p.Name(), "tried to send:", *message)
 }
 ```
 The `*event.Context` may be cancelled using `ctx.Cancel()`. This will stop
@@ -69,31 +67,31 @@ Combining this code:
 ```go
 type MyHandler struct {
 	player.NopHandler
-	p *player.Player
 }
 
-func NewMyHandler(p *player.Player) *MyHandler {
-    return &MyHandler{p: p}
+func NewMyHandler() *MyHandler {
+    return &MyHandler{}
 }
 
-func (m *MyHandler) HandleChat(ctx *event.Context, message *string) {
+func (m *MyHandler) HandleChat(ctx *player.Context, message *string) {
+    p := ctx.Val()
     ctx.Cancel()
-	fmt.Println("Player", m.p.Name(), "tried to send:", *message)
+    fmt.Println("Player", p.Name(), "tried to send:", *message)
 }
 ```
 
 Now that our `player.Handler` implementation is ready, we will want to
 attach it to the player when it joins. Moving back to the `main` function,
 we change:
 ```go
-for srv.Accept(nil) {
+for p := range srv.Accept() {
+	_ = p
 }
 ```
 to:
 ```go
-for srv.Accept(func(p *player.Player) {
-	p.Handle(NewMyHandler(p))
-}) {
+for p := range srv.Accept() {
+	p.Handle(NewMyHandler())
 }
 ```
 Players joining the server will now immediately get `MyHandler` assigned as
@@ -131,14 +129,13 @@ to the handler, like so:
 ```go
 type MyHandler struct {
 	player.NopHandler
-	p *player.Player
 	
 	deaths int
 	kills int
 }
 ```
-By implementing the `HandleDeath(damage.Source)` method, you can detect
-when the player quits and, for example, store the data to disk. The
+By implementing the `HandleDeath(*player.Player, damage.Source)` method, you can detect
+when the player dies and, for example, store the data to disk. The
 handler of a player can be retrieved by calling `p.Handler()`, and asserting
 it to the correct type like this:
 ```go
diff --git a/dev/Getting-Started.md b/dev/Getting-Started.md
@@ -22,15 +22,11 @@ go run main.go
 
 Dragonfly should now start and display log messages that look like this:
 ```
-INFO[0000] Loading server...                            
-DEBU[0000] Loading world...                              dimension=overworld
-INFO[0000] Loaded world "World".                         dimension=overworld
-DEBU[0000] Loading world...                              dimension=nether
-INFO[0000] Loaded world "World".                         dimension=nether
-DEBU[0000] Loading world...                              dimension=end
-INFO[0000] Loaded world "World".                         dimension=end
-INFO[0000] Starting Dragonfly for Minecraft v1.19.10... 
-INFO[0000] Server running on [::]:19132.
+2024/11/23 12:57:23 INFO Opened dimension. dimension=overworld name=World
+2024/11/23 12:57:23 INFO Opened dimension. dimension=nether name=World
+2024/11/23 12:57:23 INFO Opened dimension. dimension=end name=World
+2024/11/23 12:57:23 INFO Starting Dragonfly server... mc-version=1.21.40 go-version="go1.23.3" commit=2242b772bcc4f65d4f8e12cfab8cf70c2d78cb1a
+2024/11/23 12:57:23 INFO Server running. addr=[::]:19132
 ```
 
 Your server is now running. By default, Dragonfly will run on port 19132.
@@ -66,31 +62,24 @@ are unique to files that have `package main`. This function is called when
 the compiled executable is run.
 ```go
 func main() {
-	log := logrus.New()
-	log.Formatter = &logrus.TextFormatter{ForceColors: true}
-	log.Level = logrus.DebugLevel
+    chat.Global.Subscribe(chat.StdoutSubscriber{})
 ```
-The first thing done here is the creation of a logger using the `sirupsen/logrus`
-library, with colours enabled and the log level set to debug. Removal of
-the `log.Level = logrus.DebugLevel` line will hide debug messages from the
-log. For production servers, this is recommended to reduce log noise.
-
-In the line after that, a `chat.StdoutSubscriber{}` is created.
-```go
-chat.Global.Subscribe(chat.StdoutSubscriber{})
-```
-This is a standard implementation of the `chat.Subscriber` interface that
-prints chat messages to the console when subscribed to a chat.
+The first thing done here is the creation of a 
+`chat.StdoutSubscriber{}`. This is a standard implementation of the 
+`chat.Subscriber` interface that prints chat messages to the console when 
+subscribed to a chat.
 
 After that, the `config.toml` file is read. This calls the `readConfig`
 function declared further down in the `main.go` file, which uses the 
 `pelletier/go-toml` library to read a `server.Config`:
 ```go
-config, err := readConfig()
+config, err := readConfig(slog.Default())
 if err != nil {
     log.Fatalln(err)
 }
 ```
+Additionally, a logger is passed that will be used by the server to log
+information.
 
 The `server.Config` read from the `config.toml` and logger are then used 
 to create a new server:
@@ -105,19 +94,14 @@ The last lines of this `main` function are used to start listening and accept
 players joining the server:
 ```go
 srv.Listen()
-for srv.Accept(nil) {
+for p := range srv.Accept() {
+	_ = p
 }
 ```
 This snippet is generally the first place you will want to edit when you
-start working on your own server. `srv.Accept()` takes a function that
-is called when a player joins. 
-Passing a non-nil function:
-```go
-for srv.Accept(func(p *player.Player) {
-	// Do stuff with p, like attaching a handler.
-}) {
-}
-```
+start working on your own server. `srv.Accept()` returns players
+as soon as they join the server.
+
 You are now able to listen for a player joining and run code when they
 do. Further developer resources will go into depth on how to attach a
 handler to a `*player.Player` to listen for events.
diff --git a/dev/World-Transactions.md b/dev/World-Transactions.md
