Commands

Author: oq-x

commands/debug.go

@@ -1,12 +1,11 @@
 package commands
 
 import (
+	"github.com/zeppelinmc/zeppelin/server/player"
 	"math"
 
 	"github.com/zeppelinmc/zeppelin/protocol/text"
-	"github.com/zeppelinmc/zeppelin/server"
 	"github.com/zeppelinmc/zeppelin/server/command"
-	"github.com/zeppelinmc/zeppelin/server/player/state"
 
 	//"github.com/zeppelinmc/zeppelin/server/session"
 	"github.com/zeppelinmc/zeppelin/util"
@@ -17,30 +16,22 @@ var debug = command.Command{
 	Aliases:   []string{"f3"},
 	Namespace: "zeppelin",
 	Callback: func(ccc command.CommandCallContext) {
-		s, ok := ccc.Executor.(interface{ Player() *state.PlayerEntity })
+		player, ok := ccc.Executor.(*player.Player)
 		if !ok {
 			ccc.Executor.SystemMessage(text.TextComponent{
 				Text:  "This command should be used by a player.",
 				Color: "red",
 			})
 			return
 		}
-		player := s.Player()
-		if player == nil {
-			ccc.Executor.SystemMessage(text.TextComponent{
-				Text:  "This command should be used by a player.",
-				Color: "red",
-			})
-			return
-		}
 		x, y, z := player.Position()
 		chunkX, chunkY, chunkZ := int32(x)>>4, int32(y)>>4, int32(z)>>4
 		xb, yb, zb := int32(math.Floor(x)), int32(math.Floor(y)), int32(math.Floor(z))
 		rx, rz := chunkX>>5, chunkZ>>5
 
 		yaw, pitch := player.Rotation()
 
-		dimension := ccc.Server.(*server.Server).World.Dimension(player.Dimension())
+		dimension := player.Dimension()
 
 		c, err := dimension.GetChunk(chunkX, chunkZ)
 		if err != nil {

properties/properties.go

@@ -64,7 +64,7 @@ type ServerProperties struct {
 	ServerIp              string `properties:"server-ip"`
 	ServerPort            uint16 `properties:"server-port"`
 
-	SimulationDistance int `properties:"simulation-distance"`
+	SimulationDistance int32 `properties:"simulation-distance"`
 
 	SpawnMonsters   bool `properties:"spawn-monsters"`
 	SpawnProtection int  `properties:"spawn-protection"`

server/entity/entity.go

@@ -32,7 +32,7 @@ func NewLiving(e *Entity) LivingEntity {
 	return LivingEntity{Entity: *e}
 }
 
-// base state
+// Entity is the base state for entities
 type Entity struct {
 	uuid uuid.UUID
 	typ  int32
@@ -48,7 +48,7 @@ type Entity struct {
 	attr_mu    sync.RWMutex
 	attributes []Attribute
 
-	dimension a.AtomicValue[string]
+	dimensionName a.AtomicValue[string]
 }
 
 func (p *Entity) Attribute(id string) *Attribute {
@@ -71,7 +71,7 @@ func (p *Entity) Attribute(id string) *Attribute {
 	return attr
 }
 
-// returns a clone of the attributes of this state
+// Attributes returns a clone of the attributes of this state
 func (p *Entity) Attributes() []Attribute {
 	p.attr_mu.RLock()
 	defer p.attr_mu.RUnlock()
@@ -88,11 +88,11 @@ func (p *Entity) SetAttribute(id string, base float64) {
 	p.attributes[i].Base = base
 }
 
-// returns a clone of the metadata of this state
-func (e *Entity) Metadata() metadata.Metadata {
-	e.md_mu.RLock()
-	defer e.md_mu.RUnlock()
-	return maps.Clone(e.metadata)
+// Metadata returns a clone of the metadata of this state
+func (p *Entity) Metadata() metadata.Metadata {
+	p.md_mu.RLock()
+	defer p.md_mu.RUnlock()
+	return maps.Clone(p.metadata)
 }
 
 func (p *Entity) SetMetadata(md metadata.Metadata) {
@@ -121,57 +121,57 @@ func (p *Entity) SetMetadataIndexes(md metadata.Metadata) {
 	}
 }
 
-func (e *Entity) Dimension() string {
-	return e.dimension.Get()
+func (p *Entity) DimensionName() string {
+	return p.dimensionName.Get()
 }
 
-func (e *Entity) SetDimension(v string) {
-	e.dimension.Set(v)
+func (p *Entity) SetDimensionName(v string) {
+	p.dimensionName.Set(v)
 }
 
-func (e *Entity) SetMotion(x, y, z float64) {
-	e.vx.Store(math.Float64bits(x))
-	e.vy.Store(math.Float64bits(y))
-	e.vz.Store(math.Float64bits(z))
+func (p *Entity) SetMotion(x, y, z float64) {
+	p.vx.Store(math.Float64bits(x))
+	p.vy.Store(math.Float64bits(y))
+	p.vz.Store(math.Float64bits(z))
 }
 
-func (e *Entity) SetPosition(x, y, z float64) {
-	e.x.Store(math.Float64bits(x))
-	e.y.Store(math.Float64bits(y))
-	e.z.Store(math.Float64bits(z))
+func (p *Entity) SetPosition(x, y, z float64) {
+	p.x.Store(math.Float64bits(x))
+	p.y.Store(math.Float64bits(y))
+	p.z.Store(math.Float64bits(z))
 }
 
-func (e *Entity) SetRotation(yaw, pitch float32) {
-	e.yaw.Store(math.Float32bits(yaw))
-	e.pitch.Store(math.Float32bits(pitch))
+func (p *Entity) SetRotation(yaw, pitch float32) {
+	p.yaw.Store(math.Float32bits(yaw))
+	p.pitch.Store(math.Float32bits(pitch))
 }
 
-func (e *Entity) SetOnGround(v bool) {
-	e.onGround.Store(v)
+func (p *Entity) SetOnGround(v bool) {
+	p.onGround.Store(v)
 }
 
-func (e *Entity) Position() (x, y, z float64) {
-	return math.Float64frombits(e.x.Load()), math.Float64frombits(e.y.Load()), math.Float64frombits(e.z.Load())
+func (p *Entity) Position() (x, y, z float64) {
+	return math.Float64frombits(p.x.Load()), math.Float64frombits(p.y.Load()), math.Float64frombits(p.z.Load())
 }
 
-func (e *Entity) Motion() (vx, vy, vz float64) {
-	return math.Float64frombits(e.vx.Load()), math.Float64frombits(e.vy.Load()), math.Float64frombits(e.vz.Load())
+func (p *Entity) Motion() (vx, vy, vz float64) {
+	return math.Float64frombits(p.vx.Load()), math.Float64frombits(p.vy.Load()), math.Float64frombits(p.vz.Load())
 }
 
-func (e *Entity) Rotation() (yaw, pitch float32) {
-	return math.Float32frombits(e.yaw.Load()), math.Float32frombits(e.pitch.Load())
+func (p *Entity) Rotation() (yaw, pitch float32) {
+	return math.Float32frombits(p.yaw.Load()), math.Float32frombits(p.pitch.Load())
 }
 
-func (e *Entity) OnGround() bool {
-	return e.onGround.Load()
+func (p *Entity) OnGround() bool {
+	return p.onGround.Load()
 }
 
-func (e *Entity) UUID() uuid.UUID {
-	return e.uuid
+func (p *Entity) UUID() uuid.UUID {
+	return p.uuid
 }
 
-func (e *Entity) Type() int32 {
-	return e.typ
+func (p *Entity) Type() int32 {
+	return p.typ
 }
 
 type LivingEntity struct {

server/player/chunks.go

@@ -9,13 +9,13 @@ import (
 
 // Dimension returns the dimension struct this player is in
 func (p *Player) Dimension() *dimension.Dimension {
-	return p.dimensionManager.Dimension(p.state.Dimension())
+	return p.dimensionManager.Dimension(p.DimensionName())
 }
 
 func (p *Player) sendSpawnChunks() error {
 	viewDistance := p.ViewDistance()
 
-	x, _, z := p.state.Position()
+	x, _, z := p.Position()
 	chunkX, chunkZ := int32(x)>>4, int32(z)>>4
 
 	if err := p.WritePacket(&play.SetCenterChunk{ChunkX: chunkX, ChunkZ: chunkZ}); err != nil {

server/player/conn.go

@@ -9,8 +9,14 @@ import (
 	"unsafe"
 )
 
-// RegisteredHandlers maps all handler functions by their state[0] and id[1]
-var RegisteredHandlers = make(map[[2]int32]func(packet packet.Decodeable) error)
+// registeredHandlers maps all handler functions by their state[0] and id[1]
+var registeredHandlers = make(map[[2]int32]func(*Player, packet.Decodeable) error)
+
+func RegisterHandler(state, id int32, handler func(*Player, packet.Decodeable) error) struct{} {
+	registeredHandlers[[2]int32{state, id}] = handler
+
+	return struct{}{}
+}
 
 // awaitPacket waits for the packet with the id to be received
 func (p *Player) awaitPacket(id int32) (packet.Decodeable, error) {
@@ -84,7 +90,7 @@ func (p *Player) listenPackets() {
 				p.packetAwaited.Store(-1)
 			}
 
-			handler, ok := RegisteredHandlers[[2]int32{state, id}]
+			handler, ok := registeredHandlers[[2]int32{state, id}]
 			if !ok {
 				switch pk := pk.(type) {
 				case *configuration.ClientInformation, *play.ClientInformation:
@@ -93,7 +99,7 @@ func (p *Player) listenPackets() {
 				continue
 			}
 
-			if err := handler(pk); err != nil {
+			if err := handler(p, pk); err != nil {
 				p.killConnection(false, "packet handling error: "+err.Error())
 				return
 			}

server/player/handler_chat_command.go

@@ -0,0 +1,17 @@
+package player
+
+import (
+	"github.com/zeppelinmc/zeppelin/protocol/net"
+	"github.com/zeppelinmc/zeppelin/protocol/net/packet"
+	"github.com/zeppelinmc/zeppelin/protocol/net/packet/play"
+	"github.com/zeppelinmc/zeppelin/util/log"
+)
+
+var _ = RegisterHandler(net.PlayState, play.PacketIdChatCommand, func(p *Player, packet packet.Decodeable) error {
+	pk := packet.(*play.ChatCommand)
+
+	log.Infolnf("%sPlayer %s (%s) issued server command: /%s", log.FormatAddr(p.serverProperties.LogIPs, p.RemoteAddr()), p.Username(), p.UUID(), pk.Command)
+	p.commandManager.Call(pk.Command, p)
+
+	return nil
+})

server/player/player.go

@@ -1,12 +1,15 @@
 package player
 
 import (
+	"github.com/zeppelinmc/zeppelin/properties"
 	"github.com/zeppelinmc/zeppelin/protocol/net"
 	"github.com/zeppelinmc/zeppelin/protocol/net/io/encoding"
 	"github.com/zeppelinmc/zeppelin/protocol/net/packet"
 	"github.com/zeppelinmc/zeppelin/protocol/net/packet/configuration"
 	"github.com/zeppelinmc/zeppelin/protocol/net/packet/play"
 	"github.com/zeppelinmc/zeppelin/protocol/net/tags"
+	"github.com/zeppelinmc/zeppelin/protocol/text"
+	"github.com/zeppelinmc/zeppelin/server/command"
 	"github.com/zeppelinmc/zeppelin/server/entity"
 	"github.com/zeppelinmc/zeppelin/server/player/state"
 	"github.com/zeppelinmc/zeppelin/server/world/dimension"
@@ -18,18 +21,22 @@ import (
 
 type Player struct {
 	*net.Conn
+	*state.PlayerEntity
 
 	playerList *PlayerList
-	// the player entity
-	state *state.PlayerEntity
 	// the entity id for this player
 	entityId int32
 
+	Unlisted bool
+
 	ClientInformation atomic.Pointer[configuration.ClientInformation]
 
 	dimensionManager *dimension.DimensionManager
 	worldLevel       *level.Level
 
+	serverProperties *properties.ServerProperties
+	commandManager   *command.Manager
+
 	// the time in milliseconds that the keep alive packet was sent to the server from the client
 	sbLastKeepalive atomic.Int64
 	// the time in milliseconds that the keep alive packet was sent to the client from the server
@@ -47,14 +54,17 @@ func int32toAtomic(i int32) atomic.Int32 {
 	return *(*atomic.Int32)(unsafe.Pointer(&i))
 }
 
-func (list *PlayerList) New(conn *net.Conn, en *state.PlayerEntity, dimensionManager *dimension.DimensionManager, worldLevel *level.Level) *Player {
+func (list *PlayerList) New(conn *net.Conn, en *state.PlayerEntity, dimensionManager *dimension.DimensionManager, worldLevel *level.Level, serverProperties *properties.ServerProperties, commandManager *command.Manager) *Player {
 	p := &Player{
-		entityId: entity.NewEntityId(),
-		state:    en,
+		entityId:     entity.NewEntityId(),
+		PlayerEntity: en,
 
 		dimensionManager: dimensionManager,
 		worldLevel:       worldLevel,
 
+		serverProperties: serverProperties,
+		commandManager:   commandManager,
+
 		registryIndexes: make(map[string][]string),
 
 		packetAwaited: int32toAtomic(-1),
@@ -122,11 +132,19 @@ func (p *Player) finishConfiguration() error {
 
 // startGame finishes the initialization for the player and logs it into the world
 func (p *Player) startGame() error {
+	if err := p.sendCommandGraph(); err != nil {
+		return err
+	}
+
 	if err := p.WritePacket(&play.Login{
-		EntityID:      p.entityId,
-		DimensionName: p.state.Dimension(),
-		GameMode:      1,
-		DimensionType: int32(slices.Index(p.registryIndexes["minecraft:dimension_type"], p.state.Dimension())),
+		EntityID:           p.entityId,
+		DimensionName:      p.DimensionName(),
+		GameMode:           byte(p.GameMode()),
+		DimensionType:      int32(slices.Index(p.registryIndexes["minecraft:dimension_type"], p.DimensionName())),
+		ViewDistance:       p.serverProperties.ViewDistance,
+		SimulationDistance: p.serverProperties.SimulationDistance,
+		HashedSeed:         p.worldLevel.Data.WorldGenSettings.Seed.Hash(),
+		EnforcesSecureChat: p.serverProperties.EnforceSecureProfile,
 	}); err != nil {
 		return err
 	}
@@ -141,8 +159,8 @@ func (p *Player) startGame() error {
 		return err
 	}
 
-	x, y, z := p.state.Position()
-	yaw, pitch := p.state.Rotation()
+	x, y, z := p.Position()
+	yaw, pitch := p.Rotation()
 
 	if err := p.SynchronizePosition(x, y, z, yaw, pitch); err != nil {
 		return err
@@ -166,8 +184,8 @@ func (p *Player) startGame() error {
 
 // SynchronizePosition teleports the player to the specified coordinates
 func (p *Player) SynchronizePosition(x, y, z float64, yaw, pitch float32) error {
-	p.state.SetPosition(x, y, z)
-	p.state.SetRotation(yaw, pitch)
+	p.SetPosition(x, y, z)
+	p.SetRotation(yaw, pitch)
 
 	if err := p.WritePacket(&play.SynchronizePlayerPosition{X: x, Y: y, Z: z, Yaw: yaw, Pitch: pitch}); err != nil {
 		return err
@@ -184,3 +202,13 @@ func (p *Player) Login() error {
 	}
 	return p.startGame()
 }
+
+// SystemMessage sends a system message (unsigned) to the player
+func (p *Player) SystemMessage(msg text.TextComponent) error {
+	return p.WritePacket(&play.SystemChatMessage{Content: msg})
+}
+
+// sendCommandGraph sends the command graph to the player
+func (p *Player) sendCommandGraph() error {
+	return p.WritePacket(p.commandManager.Encode())
+}

server/player/playerlist.go

@@ -49,7 +49,7 @@ func (list *PlayerList) AddPlayer(player *Player) {
 
 		update.Players[player.UUID()] = play.PlayerAction{
 			Name:       player.Username(),
-			Listed:     true,
+			Listed:     !player.Unlisted,
 			Properties: player.Properties(),
 		}
 	}