[Feat Request] : LAN support for client bots

[Poko-Cmnt]

First of all thanks for all hard work there. Is it possible that in future we get a feature that enables us to spawn bots in our local game worlds that are exposed to LAN network ? Afaik it's releted to NetherNet protocol. Here's some releted links:

https://github.com/lactyy/nethernet-spec/tree/1.21.20
PrismarineJS/bedrock-protocol#533
https://github.com/LucienHH/node-nethernet/tree/protocol

[AnyBananaGAME]

Yeah sure, will take a look later. Can't promise but I will try to get that to work with clients.

[Poko-Cmnt]

Thanks. To be honest, it’s not a very important feature, so I won’t mind if it ends up not being implemented.

That said, here’s a Go script reference I used on my Android device that can detect an exposed game world in the current game version (v1.21.93) on the same device where the game is running.

SCRIPT MADE BY AI [CLICK]

// Setup:
// 1. mkdir discover && cd discover
// 2. go mod init discover
// 3. go get github.com/andreburgaud/crypt2go
// 4. Save as main.go, then: go run main.go

package main

import (
    "bytes"
    "crypto/aes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/binary"
    "encoding/hex"
    "fmt"
    "math/rand"
    "net"
    "time"

    "github.com/andreburgaud/crypt2go/ecb"
    "github.com/andreburgaud/crypt2go/padding"
)

const (
    broadcastAddrAndPort = "255.255.255.255:7551"
    DiscoveryRequestPacket  = 0x00
    DiscoveryResponsePacket = 0x01
)

var key = sha256.Sum256(binary.LittleEndian.AppendUint64(nil, 0xdeadbeef))

type Packet interface {
    ID() uint16
    Write(*bytes.Buffer) error
}

type DiscoveryRequest struct{}

func (p DiscoveryRequest) ID() uint16 { return DiscoveryRequestPacket }
func (p DiscoveryRequest) Write(buf *bytes.Buffer) error { return nil }

type DiscoveryResponse struct {
    Version        uint8
    ServerName     string
    LevelName      string
    GameType       uint8
    PlayerCount    int32
    MaxPlayerCount int32
    EditorWorld    bool
    Hardcore       bool
    TransportLayer uint16
}

func (p DiscoveryResponse) ID() uint16 { return DiscoveryResponsePacket }

func ParseDiscoveryResponse(data []byte) (DiscoveryResponse, error) {
    if len(data) < 4 {
        return DiscoveryResponse{}, fmt.Errorf("packet too short")
    }
    hexLen := int(binary.LittleEndian.Uint32(data[:4]))
    if len(data) < 4+hexLen {
        return DiscoveryResponse{}, fmt.Errorf("length mismatch")
    }
    fmt.Printf("HexText: %s\n", string(data[4 : 4+hexLen]))
    decoded, _ := hex.DecodeString(string(data[4 : 4+hexLen]))

    buf := bytes.NewReader(decoded)
    var resp DiscoveryResponse
    binary.Read(buf, binary.LittleEndian, &resp.Version)
    serverNameLen, _ := buf.ReadByte()
    serverName := make([]byte, serverNameLen)
    buf.Read(serverName)
    resp.ServerName = string(serverName)
    levelNameLen, _ := buf.ReadByte()
    levelName := make([]byte, levelNameLen)
    buf.Read(levelName)
    resp.LevelName = string(levelName)
    binary.Read(buf, binary.LittleEndian, &resp.GameType)
    binary.Read(buf, binary.LittleEndian, &resp.PlayerCount)
    binary.Read(buf, binary.LittleEndian, &resp.MaxPlayerCount)
    var editorWorld, hardcore uint8
    binary.Read(buf, binary.LittleEndian, &editorWorld)
    resp.EditorWorld = editorWorld != 0
    binary.Read(buf, binary.LittleEndian, &hardcore)
    resp.Hardcore = hardcore != 0
    binary.Read(buf, binary.LittleEndian, &resp.TransportLayer)
    return resp, nil
}

func encrypt(src []byte) []byte {
    block, _ := aes.NewCipher(key[:])
    mode := ecb.NewECBEncrypter(block)
    pkcs7 := padding.NewPkcs7Padding(block.BlockSize())
    src, _ = pkcs7.Pad(src)
    dst := make([]byte, len(src))
    mode.CryptBlocks(dst, src)
    return dst
}

func decrypt(src []byte) []byte {
    block, _ := aes.NewCipher(key[:])
    mode := ecb.NewECBDecrypter(block)
    dst := make([]byte, len(src))
    mode.CryptBlocks(dst, src)
    pkcs7 := padding.NewPkcs7Padding(block.BlockSize())
    dst, _ = pkcs7.Unpad(dst)
    return dst
}

func encodeDiscoveryPacket(senderID uint64, pk Packet) []byte {
    buf := new(bytes.Buffer)
    binary.Write(buf, binary.LittleEndian, pk.ID())
    binary.Write(buf, binary.LittleEndian, senderID)
    binary.Write(buf, binary.LittleEndian, make([]byte, 8))
    pk.Write(buf)
    payload := buf.Bytes()
    payload = append([]byte{byte(len(payload)), byte(len(payload) >> 8)}, payload...)
    data := encrypt(payload)
    hm := hmac.New(sha256.New, key[:])
    hm.Write(payload)
    return append(hm.Sum(nil), data...)
}

func decodeDiscoveryPacket(data []byte) (uint16, uint64, []byte, error) {
    if len(data) < 32 {
        return 0, 0, nil, fmt.Errorf("packet too short")
    }
    plaintext := decrypt(data[32:])
    hm := hmac.New(sha256.New, key[:])
    hm.Write(plaintext)
    if !hmac.Equal(data[:32], hm.Sum(nil)) {
        return 0, 0, nil, fmt.Errorf("invalid HMAC")
    }
    buf := bytes.NewReader(plaintext)
    var length, packetType uint16
    var senderID uint64
    binary.Read(buf, binary.LittleEndian, &length)
    binary.Read(buf, binary.LittleEndian, &packetType)
    binary.Read(buf, binary.LittleEndian, &senderID)
    buf.Read(make([]byte, 8))
    packetData := make([]byte, buf.Len())
    buf.Read(packetData)
    return packetType, senderID, packetData, nil
}

func main() {
    conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
    if err != nil {
        fmt.Println("Error creating UDP socket:", err)
        return
    }
    defer conn.Close()

    conn.SetWriteBuffer(2048)
    conn.SetReadBuffer(2048)

    rand.Seed(time.Now().UnixNano())
    data := encodeDiscoveryPacket(rand.Uint64(), DiscoveryRequest{})
    addr, _ := net.ResolveUDPAddr("udp", broadcastAddrAndPort)
    conn.WriteToUDP(data, addr)
    fmt.Println("Sent DiscoveryRequestPacket")

    buffer := make([]byte, 1500)
    conn.SetReadDeadline(time.Now().Add(5 * time.Second))
    for {
        n, addr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Println("Timeout reached, done listening")
                break
            }
            fmt.Println("Error reading:", err)
            continue
        }
        packetType, senderID, packetData, err := decodeDiscoveryPacket(buffer[:n])
        if err != nil {
            fmt.Println("Error decoding packet from", addr, ":", err)
            continue
        }
        if packetType == DiscoveryResponsePacket {
            resp, err := ParseDiscoveryResponse(packetData)
            if err != nil {
                fmt.Println("Error parsing response from", addr, ":", err)
                continue
            }
            fmt.Printf("---- DiscoveryResponsePacket ----\nFrom: %s\nSenderID: %d\nVersion: %d\nServerName: %s\nLevelName: %s\nGameType: %d\nPlayerCount: %d\nMaxPlayerCount: %d\nEditorWorld: %v\nHardcore: %v\nTransportLayer: %d\n---------------------------------\n",
                addr, senderID, resp.Version, resp.ServerName, resp.LevelName, resp.GameType, resp.PlayerCount, resp.MaxPlayerCount, resp.EditorWorld, resp.Hardcore, resp.TransportLayer)
        }
    }
}

The rest is just negotiating a webRTC connection to establish data channels for communication, and i assume then we can share packets in same way we do in Raknet (specification mentioned it).