Added 1.19 Support # Bot Package (missing-sig)

bot/basic/events.go

@@ -2,6 +2,7 @@ package basic
 
 import (
 	"github.com/google/uuid"
+	"time"
 
 	"github.com/Tnze/go-mc/bot"
 	"github.com/Tnze/go-mc/chat"
@@ -11,7 +12,8 @@ import (
 
 type EventsListener struct {
 	GameStart    func() error
-	ChatMsg      func(c chat.Message, pos byte, uuid uuid.UUID) error
+	ChatMsg      func(c *PlayerMessage, pos byte, uuid uuid.UUID) error
+	SystemMsg    func(c chat.Message, pos byte) error
 	Disconnect   func(reason chat.Message) error
 	HealthChange func(health float32) error
 	Death        func() error
@@ -20,7 +22,8 @@ type EventsListener struct {
 func (e EventsListener) Attach(c *bot.Client) {
 	c.Events.AddListener(
 		bot.PacketHandler{Priority: 64, ID: packetid.ClientboundLogin, F: e.onJoinGame},
-		//bot.PacketHandler{Priority: 64, ID: packetid.ClientboundChat, F: e.onChatMsg},
+		bot.PacketHandler{Priority: 64, ID: packetid.ClientboundSystemChat, F: e.onSystemMsg},
+		bot.PacketHandler{Priority: 64, ID: packetid.ClientboundPlayerChat, F: e.onPlayerMsg},
 		bot.PacketHandler{Priority: 64, ID: packetid.ClientboundDisconnect, F: e.onDisconnect},
 		bot.PacketHandler{Priority: 64, ID: packetid.ClientboundSetHealth, F: e.onUpdateHealth},
 	)
@@ -44,17 +47,78 @@ func (e *EventsListener) onDisconnect(p pk.Packet) error {
 	return nil
 }
 
-func (e *EventsListener) onChatMsg(p pk.Packet) error {
+type PlayerMessage struct {
-	if e.ChatMsg != nil {
+	SignedMessage     chat.Message
-		var msg chat.Message
+	Unsigned          bool
-		var pos pk.Byte
+	UnsignedMessage   chat.Message
-		var sender pk.UUID
+	Position          int32
-
+	Sender            uuid.UUID
-		if err := p.Scan(&msg, &pos, &sender); err != nil {
+	SenderDisplayName chat.Message
-			return Error{err}
+	HasSenderTeam     bool
+	SenderTeamName    chat.Message
+	TimeStamp         time.Time
 }
 
-		return e.ChatMsg(msg, byte(pos), uuid.UUID(sender))
+func (e *EventsListener) onPlayerMsg(p pk.Packet) error {
+	if e.ChatMsg != nil {
+		var message PlayerMessage
+		//var (
+		//	signedChat chat.Message
+		//	unsigned pk.Boolean
+		//	unsignedChat chat.Message
+		//	pos pk.VarInt
+		//	sender uuid.UUID
+		//	senderDisplayName pk.String
+		//	hasSenderTeam pk.Boolean
+		//	senderTeam pk.String
+		//	timeStamp pk.Long
+		//	salt pk.Long
+		//
+		//)
+		var senderDisplayName pk.String
+		var senderTeamName pk.String
+		var timeStamp pk.Long
+		//var sig pk.VarInt
+		var salt pk.Long
+		var signature pk.ByteArray
+		if err := p.Scan(&message.SignedMessage,
+			(*pk.Boolean)(&message.Unsigned),
+			pk.Opt{
+				Has:   &message.Unsigned,
+				Field: &message.UnsignedMessage,
+			},
+			(*pk.VarInt)(&message.Position),
+			(*pk.UUID)(&message.Sender),
+			&senderDisplayName,
+			(*pk.Boolean)(&message.HasSenderTeam),
+			pk.Opt{
+				Has:   &message.HasSenderTeam,
+				Field: &senderTeamName,
+			},
+			&timeStamp,
+			&salt,
+			&signature); err != nil {
+			return Error{err}
+		}
+		if err := message.SenderDisplayName.UnmarshalJSON([]byte(senderDisplayName)); err != nil {
+			return Error{err}
+		}
+		if err := message.SenderTeamName.UnmarshalJSON([]byte(senderDisplayName)); err != nil {
+			return Error{err}
+		}
+		return e.ChatMsg(&message, byte(message.Position), message.Sender)
+	}
+	return nil
+}
+func (e *EventsListener) onSystemMsg(p pk.Packet) error {
+	if e.SystemMsg != nil {
+		var msg chat.Message
+		var pos pk.VarInt
+
+		if err := p.Scan(&msg, &pos); err != nil {
+			return Error{err}
+		}
+		return e.SystemMsg(msg, byte(pos))
 	}
 	return nil
 }

bot/basic/info.go

@@ -11,7 +11,7 @@ import (
 // WorldInfo content player info in server.
 type WorldInfo struct {
 	DimensionCodec      nbt.StringifiedMessage
-	Dimension           Dimension
+	Dimension           string
 	WorldNames          []string // Identifiers for all worlds on the server.
 	WorldName           string   // Name of the world being spawned into.
 	HashedSeed          int64    // First 8 bytes of the SHA-256 hash of the world's seed. Used client side for biome noise
@@ -64,7 +64,7 @@ func (p *Player) handleLoginPacket(packet pk.Packet) error {
 		(*pk.Byte)(&p.PrevGamemode),
 		pk.Array(&WorldNames),
 		pk.NBT(&p.WorldInfo.DimensionCodec),
-		pk.NBT(&p.WorldInfo.Dimension),
+		(*pk.Identifier)(&p.Dimension),
 		(*pk.Identifier)(&p.WorldName),
 		(*pk.Long)(&p.HashedSeed),
 		(*pk.VarInt)(&p.MaxPlayers),
@@ -78,7 +78,6 @@ func (p *Player) handleLoginPacket(packet pk.Packet) error {
 	if err != nil {
 		return Error{err}
 	}
-
 	// This line should work "like" the following code but without copy things
 	//	p.WorldNames = make([]string, len(WorldNames))
 	//	for i, v := range WorldNames {
@@ -114,7 +113,8 @@ func (p *Player) handleLoginPacket(packet pk.Packet) error {
 func (p *Player) handleRespawnPacket(packet pk.Packet) error {
 	var copyMeta bool
 	err := packet.Scan(
-		pk.NBT(&p.WorldInfo.Dimension),
+		//pk.NBT(&p.WorldInfo.Dimension),
+		(*pk.Identifier)(&p.Dimension),
 		(*pk.Identifier)(&p.WorldName),
 		(*pk.Long)(&p.HashedSeed),
 		(*pk.UnsignedByte)(&p.Gamemode),

bot/client.go

@@ -10,7 +10,7 @@ import (
 type Client struct {
 	Conn    *net.Conn
 	Auth    Auth
-	KeyPair userApi.KeyPairResp
+	KeyPair *userApi.KeyPairResp
 
 	Name string
 	UUID uuid.UUID

bot/login.go

@@ -178,7 +178,7 @@ func newSymmetricEncryption() (key []byte, encoStream, decoStream cipher.Stream)
 	return
 }
 
-func genEncryptionKeyResponse(shareSecret, publicKey, verifyToken []byte, keyPair userApi.KeyPairResp) (erp pk.Packet, err error) {
+func genEncryptionKeyResponse(shareSecret, publicKey, verifyToken []byte, keyPair *userApi.KeyPairResp) (erp pk.Packet, err error) {
 	iPK, err := x509.ParsePKIXPublicKey(publicKey) // Decode Public Key
 	if err != nil {
 		err = fmt.Errorf("decode public key fail: %v", err)

bot/mcbot.go

@@ -84,26 +84,26 @@ func (c *Client) join(ctx context.Context, d *mcnet.Dialer, addr string) error {
 			return LoginErr{"login start (without sig)", err}
 		}
 	} else {
-		// Login Start (Currently not support sig)
+		// Login Start (With Signature) (Currently not supported)
 		err = c.Conn.WritePacket(pk.Marshal(
 			packetid.LoginStart,
 			pk.String(c.Auth.Name),
 			pk.Boolean(false),
 		))
-		//block, _ := pem.Decode([]byte(pair.KeyPair.PublicKey))
+		/*		block, _ := pem.Decode([]byte(pair.KeyPair.PublicKey))
-		//sig, _ := base64.StdEncoding.DecodeString(pair.PublicKeySignature)
+				sig, _ := base64.StdEncoding.DecodeString(pair.PublicKeySignature)
-		//err = c.Conn.WritePacket(pk.Marshal(
+				err = c.Conn.WritePacket(pk.Marshal(
-		//	packetid.LoginStart,
+					packetid.LoginStart,
-		//	pk.String(c.Auth.Name),
+					pk.String(c.Auth.Name),
-		//	pk.Boolean(true),
+					pk.Boolean(true),
-		//	pk.Long(pair.ExpiresAt.UnixMilli()),
+					pk.Long(pair.ExpiresAt.UnixMilli()),
-		//	pk.ByteArray(block.Bytes),
+					pk.ByteArray(block.Bytes),
-		//	pk.ByteArray(sig),
+					pk.ByteArray(sig),
-		//))
+				))*/
 		if err != nil {
 			return LoginErr{"login start (with sig)", err}
 		}
-		c.KeyPair = pair
+		c.KeyPair = &pair
 	}
 	for {
 		//Receive Packet