up3

server/world/handler.go

@@ -0,0 +1,96 @@
+package world
+
+import (
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/df-mc/dragonfly/server/event"
+	"github.com/go-gl/mathgl/mgl64"
+)
+
+type Context = event.Context[*Tx]
+
+// Handler handles events that are called by a world. Implementations of
+// Handler may be used to listen to specific events such as when an Entity is
+// added to the world.
+type Handler interface {
+	// HandleLiquidFlow handles the flowing of a liquid from one block position
+	// from into another block position into. The liquid that will replace the
+	// block is also passed. This replaced block might also be a Liquid. The
+	// Liquid's depth and falling state can be checked to see if the resulting
+	// liquid is a new source block (in the case of water).
+	HandleLiquidFlow(ctx *Context, from, into cube.Pos, liquid Liquid, replaced Block)
+	// HandleLiquidDecay handles the decaying of a Liquid block at a position.
+	// Liquid decaying happens when there is no Liquid that can serve as the
+	// source block neighbouring it. The state of the Liquid before and after
+	// the decaying is passed. The Liquid after is nil if the liquid is
+	// completely removed as a result of the decay.
+	HandleLiquidDecay(ctx *Context, pos cube.Pos, before, after Liquid)
+	// HandleLiquidHarden handles the hardening of a liquid at hardenedPos. The
+	// liquid that was hardened, liquidHardened, and the liquid that caused it
+	// to harden, otherLiquid, are passed. The block created as a result is also
+	// passed.
+	HandleLiquidHarden(ctx *Context, hardenedPos cube.Pos, liquidHardened, otherLiquid, newBlock Block)
+	// HandleSound handles a Sound being played in the World at a specific
+	// position. ctx.Cancel() may be called to stop the Sound from playing to
+	// viewers of the position.
+	HandleSound(ctx *Context, s Sound, pos mgl64.Vec3)
+	// HandleFireSpread handles when a fire block spreads from one block to
+	// another block. When this event handler gets called, both the position of
+	// the original fire will be passed, and the position where it will spread
+	// to after the event. The age of the fire may also be altered by changing
+	// the underlying value of the newFireAge pointer, which decides how long
+	// the fire will stay before burning out.
+	HandleFireSpread(ctx *Context, from, to cube.Pos)
+	// HandleBlockBurn handles a block at a cube.Pos being burnt by fire. This
+	// event may be called for blocks such as wood, that can be broken by fire.
+	// HandleBlockBurn is often succeeded by HandleFireSpread, when fire spreads
+	// to the position of the original block and the Context is not cancelled in
+	// HandleBlockBurn.
+	HandleBlockBurn(ctx *Context, pos cube.Pos)
+	// HandleCropTrample handles an Entity trampling a crop.
+	HandleCropTrample(ctx *Context, pos cube.Pos)
+	// HandleLeavesDecay handles the decaying of a Leaves block at a position.
+	// Leaves decaying happens when there is no wood block neighbouring it.
+	// ctx.Cancel() may be called to prevent leaves from decaying.
+	HandleLeavesDecay(ctx *Context, pos cube.Pos)
+	// HandleEntitySpawn handles an Entity being spawned into a World through a
+	// call to Tx.AddEntity.
+	HandleEntitySpawn(tx *Tx, e Entity)
+	// HandleEntityDespawn handles an Entity being despawned from a World
+	// through a call to Tx.RemoveEntity.
+	HandleEntityDespawn(tx *Tx, e Entity)
+	// HandleExplosion handles an explosion in the world. ctx.Cancel() may be called
+	// to cancel the explosion.
+	// The affected entities, affected blocks, item drop chance, and whether the
+	// explosion spawns fire may be altered.
+	HandleExplosion(ctx *Context, position mgl64.Vec3, entities *[]Entity, blocks *[]cube.Pos, itemDropChance *float64, spawnFire *bool)
+	// HandleRedstoneUpdate handles a redstone update at a position. ctx.Cancel() may be called
+	// to cancel the redstone update.
+	HandleRedstoneUpdate(ctx *Context, pos cube.Pos)
+	// HandleClose handles the World being closed. HandleClose may be used as a
+	// moment to finish code running on other goroutines that operates on the
+	// World specifically. HandleClose is called directly before the World stops
+	// ticking and before any chunks are saved to disk.
+	HandleClose(tx *Tx)
+}
+
+// Compile time check to make sure NopHandler implements Handler.
+var _ Handler = (*NopHandler)(nil)
+
+// NopHandler implements the Handler interface but does not execute any code
+// when an event is called. The default Handler of worlds is set to NopHandler.
+// Users may embed NopHandler to avoid having to implement each method.
+type NopHandler struct{}
+
+func (NopHandler) HandleLiquidFlow(*Context, cube.Pos, cube.Pos, Liquid, Block)                  {}
+func (NopHandler) HandleLiquidDecay(*Context, cube.Pos, Liquid, Liquid)                          {}
+func (NopHandler) HandleLiquidHarden(*Context, cube.Pos, Block, Block, Block)                    {}
+func (NopHandler) HandleSound(*Context, Sound, mgl64.Vec3)                                       {}
+func (NopHandler) HandleFireSpread(*Context, cube.Pos, cube.Pos)                                 {}
+func (NopHandler) HandleBlockBurn(*Context, cube.Pos)                                            {}
+func (NopHandler) HandleCropTrample(*Context, cube.Pos)                                          {}
+func (NopHandler) HandleLeavesDecay(*Context, cube.Pos)                                          {}
+func (NopHandler) HandleEntitySpawn(*Tx, Entity)                                                 {}
+func (NopHandler) HandleEntityDespawn(*Tx, Entity)                                               {}
+func (NopHandler) HandleExplosion(*Context, mgl64.Vec3, *[]Entity, *[]cube.Pos, *float64, *bool) {}
+func (NopHandler) HandleRedstoneUpdate(*Context, cube.Pos)                                       {}
+func (NopHandler) HandleClose(*Tx)                                                               {}