falloutBot/go-mc
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

go fmt

Browse Source
This commit is contained in:
Tnze
2024-06-13 22:29:05 +08:00
parent 73df16e856
commit 51ba4c2fdd
5 changed files with 445 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
examples/playerdataconvert/advancements.go
View File

@ -1,58 +1,58 @@
package main package main
import ( import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"github.com/google/uuid" "github.com/google/uuid"
) )
func readAdvancements(dir string, m map[uuid.UUID]UserCache) { func readAdvancements(dir string, m map[uuid.UUID]UserCache) {
entries, err := os.ReadDir(dir) entries, err := os.ReadDir(dir)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to open playerdata folder: %v", err) fmt.Fprintf(os.Stderr, "Failed to open playerdata folder: %v", err)
return return
} }
for _, files := range entries { for _, files := range entries {
filename := files.Name() filename := files.Name()
if ext := filepath.Ext(filename); ext != ".json" { if ext := filepath.Ext(filename); ext != ".json" {
fmt.Fprintf(os.Stderr, "Unkown file type: %s\n", ext) fmt.Fprintf(os.Stderr, "Unkown file type: %s\n", ext)
continue continue
} }
// Parse old UUID from filename // Parse old UUID from filename
oldID, err := uuid.Parse(strings.TrimSuffix(filename, ".json")) oldID, err := uuid.Parse(strings.TrimSuffix(filename, ".json"))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Unable to parse filename as uuid: %v\n", err) fmt.Fprintf(os.Stderr, "Unable to parse filename as uuid: %v\n", err)
continue continue
} }
if ver := oldID.Version(); ver != 3 { // v3 is for offline players if ver := oldID.Version(); ver != 3 { // v3 is for offline players
fmt.Printf("Ignoring UUID: %v version: %d\n", oldID, ver) fmt.Printf("Ignoring UUID: %v version: %d\n", oldID, ver)
continue continue
} }
newUser, ok := m[oldID] newUser, ok := m[oldID]
if !ok { if !ok {
fmt.Printf("Skip user: %v\n", oldID) fmt.Printf("Skip user: %v\n", oldID)
continue continue
} }
content, err := os.ReadFile(filepath.Join(dir, filename)) content, err := os.ReadFile(filepath.Join(dir, filename))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to read json file: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to read json file: %v\n", err)
continue continue
} }
newFile := newUser.UUID.String() + ".json" newFile := newUser.UUID.String() + ".json"
err = os.WriteFile(filepath.Join(dir, newFile), content, 0o666) err = os.WriteFile(filepath.Join(dir, newFile), content, 0o666)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to write json file: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to write json file: %v\n", err)
continue continue
} }
fmt.Printf("Converted advancement file: %s\n", newFile) fmt.Printf("Converted advancement file: %s\n", newFile)
} }
} }

180
examples/playerdataconvert/main.go
View File

@ -1,90 +1,90 @@
// playerdataconvert is a program to convert player data form offline server to online server. // playerdataconvert is a program to convert player data form offline server to online server.
// //
// When a player with official account login connect to a offline-mode server, // When a player with official account login connect to a offline-mode server,
// the server store the player data with their "offline UUID". While you open // the server store the player data with their "offline UUID". While you open
// the online-mode switch, the player data loose. // the online-mode switch, the player data loose.
// //
// By using this tool, you can convert the offline data into online data. // By using this tool, you can convert the offline data into online data.
// The players will keep everything they got, yay! // The players will keep everything they got, yay!
package main package main
import ( import (
"encoding/json" "encoding/json"
"flag" "flag"
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"github.com/google/uuid" "github.com/google/uuid"
) )
var ( var (
savePath = flag.String("save", ".", "The save folder with \"usercache.json\" file inside") savePath = flag.String("save", ".", "The save folder with \"usercache.json\" file inside")
convertPlayerData = flag.Bool("cplayerdata", true, "Whether convert files at /world/playerdata/*.dat") convertPlayerData = flag.Bool("cplayerdata", true, "Whether convert files at /world/playerdata/*.dat")
convertEntities = flag.Bool("centities", true, "Whether convert pets' Owner at /world/entities/*") convertEntities = flag.Bool("centities", true, "Whether convert pets' Owner at /world/entities/*")
convertAdvancements = flag.Bool("cadvancements", true, "Whether convert advancements at /world/advancements/*") convertAdvancements = flag.Bool("cadvancements", true, "Whether convert advancements at /world/advancements/*")
) )
func main() { func main() {
flag.Parse() flag.Parse()
usercaches, err := readUsercache(filepath.Join(*savePath, "usercache.json")) usercaches, err := readUsercache(filepath.Join(*savePath, "usercache.json"))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to parse usercache file: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to parse usercache file: %v\n", err)
return return
} }
fmt.Printf("Successfully reading usercache\n") fmt.Printf("Successfully reading usercache\n")
m := mappingUsers(usercaches) m := mappingUsers(usercaches)
if *convertPlayerData { if *convertPlayerData {
readPlayerdata(filepath.Join(*savePath, "world", "playerdata"), m) readPlayerdata(filepath.Join(*savePath, "world", "playerdata"), m)
} }
if *convertEntities { if *convertEntities {
readEntities(filepath.Join(*savePath, "world", "entities"), m) readEntities(filepath.Join(*savePath, "world", "entities"), m)
} }
if *convertAdvancements { if *convertAdvancements {
readAdvancements(filepath.Join(*savePath, "world", "advancements"), m) readAdvancements(filepath.Join(*savePath, "world", "advancements"), m)
} }
} }
type UserCache struct { type UserCache struct {
Name string `json:"name"` Name string `json:"name"`
UUID uuid.UUID `json:"uuid"` UUID uuid.UUID `json:"uuid"`
} }
func readUsercache(path string) ([]UserCache, error) { func readUsercache(path string) ([]UserCache, error) {
data, err := os.ReadFile(path) data, err := os.ReadFile(path)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var usercache []UserCache var usercache []UserCache
err = json.Unmarshal(data, &usercache) err = json.Unmarshal(data, &usercache)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return usercache, nil return usercache, nil
} }
func mappingUsers(users []UserCache) map[uuid.UUID]UserCache { func mappingUsers(users []UserCache) map[uuid.UUID]UserCache {
m := make(map[uuid.UUID]UserCache) m := make(map[uuid.UUID]UserCache)
for _, user := range users { for _, user := range users {
name := user.Name name := user.Name
// // You can add your maps here // // You can add your maps here
// if v, ok := offlineOnlineMaps[name]; ok { // if v, ok := offlineOnlineMaps[name]; ok {
// name = v // name = v
// } // }
name, id, err := usernameToUUID(name) name, id, err := usernameToUUID(name)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Unable to fetch username for %s from Mojang server: %v\n", name, err) fmt.Fprintf(os.Stderr, "Unable to fetch username for %s from Mojang server: %v\n", name, err)
continue continue
} }
fmt.Printf("[%s] %v -> %v\n", name, user.UUID, id) fmt.Printf("[%s] %v -> %v\n", name, user.UUID, id)
m[user.UUID] = UserCache{name, id} m[user.UUID] = UserCache{name, id}
} }
return m return m
} }

258
examples/playerdataconvert/pets.go
View File

@ -1,129 +1,129 @@
package main package main
import ( import (
"bytes" "bytes"
"compress/gzip" "compress/gzip"
"compress/zlib" "compress/zlib"
"errors" "errors"
"fmt" "fmt"
"io" "io"
"os" "os"
"path/filepath" "path/filepath"
"github.com/Tnze/go-mc/nbt" "github.com/Tnze/go-mc/nbt"
"github.com/Tnze/go-mc/nbt/dynbt" "github.com/Tnze/go-mc/nbt/dynbt"
"github.com/Tnze/go-mc/save/region" "github.com/Tnze/go-mc/save/region"
"github.com/google/uuid" "github.com/google/uuid"
) )
func readEntities(dir string, m map[uuid.UUID]UserCache) { func readEntities(dir string, m map[uuid.UUID]UserCache) {
entries, err := os.ReadDir(dir) entries, err := os.ReadDir(dir)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to read entities dir: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to read entities dir: %v\n", err)
return return
} }
for i := range entries { for i := range entries {
readEntityMcaFile(filepath.Join(dir, entries[i].Name()), m) readEntityMcaFile(filepath.Join(dir, entries[i].Name()), m)
} }
} }
func readEntityMcaFile(path string, m map[uuid.UUID]UserCache) { func readEntityMcaFile(path string, m map[uuid.UUID]UserCache) {
r, err := region.Open(path) r, err := region.Open(path)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to open entities region file %s: %v\n", path, err) fmt.Fprintf(os.Stderr, "Failed to open entities region file %s: %v\n", path, err)
return return
} }
defer r.Close() defer r.Close()
for i := 0; i < 32; i++ { for i := 0; i < 32; i++ {
for j := 0; j < 32; j++ { for j := 0; j < 32; j++ {
if !r.ExistSector(i, j) { if !r.ExistSector(i, j) {
continue continue
} }
data, err := r.ReadSector(i, j) data, err := r.ReadSector(i, j)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to read entities region sector: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to read entities region sector: %v\n", err)
continue continue
} }
newdata, err := readEntityMcaSector(data, m) newdata, err := readEntityMcaSector(data, m)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to parse entities region sector: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to parse entities region sector: %v\n", err)
continue continue
} }
if newdata != nil { if newdata != nil {
err = r.WriteSector(i, j, newdata) err = r.WriteSector(i, j, newdata)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to update region sector data: %v\n", err) fmt.Fprintf(os.Stderr, "Failed to update region sector data: %v\n", err)
continue continue
} }
} }
} }
} }
} }
func readEntityMcaSector(data []byte, m map[uuid.UUID]UserCache) ([]byte, error) { func readEntityMcaSector(data []byte, m map[uuid.UUID]UserCache) ([]byte, error) {
var r io.Reader = bytes.NewReader(data[1:]) var r io.Reader = bytes.NewReader(data[1:])
var err error var err error
switch data[0] { switch data[0] {
default: default:
return nil, errors.New("unknown compression") return nil, errors.New("unknown compression")
case 1: case 1:
r, err = gzip.NewReader(r) r, err = gzip.NewReader(r)
case 2: case 2:
r, err = zlib.NewReader(r) r, err = zlib.NewReader(r)
case 3: case 3:
} }
if err != nil { if err != nil {
return nil, err return nil, err
} }
var nbtdata dynbt.Value var nbtdata dynbt.Value
_, err = nbt.NewDecoder(r).Decode(&nbtdata) _, err = nbt.NewDecoder(r).Decode(&nbtdata)
if err != nil { if err != nil {
return nil, err return nil, err
} }
updated := false updated := false
entities := nbtdata.Get("Entities") entities := nbtdata.Get("Entities")
if entities == nil { if entities == nil {
return nil, fmt.Errorf("no Entities field in nbt, what happen?") return nil, fmt.Errorf("no Entities field in nbt, what happen?")
} }
entities2 := entities.List() entities2 := entities.List()
for _, entity := range entities2 { for _, entity := range entities2 {
id := entity.Get("id").String() id := entity.Get("id").String()
if owner := entity.Get("Owner"); owner != nil { if owner := entity.Get("Owner"); owner != nil {
owner, _ := intArrayToUUID(owner.IntArray()) owner, _ := intArrayToUUID(owner.IntArray())
fmt.Printf("Found %s: owner=%s\n", id, owner) fmt.Printf("Found %s: owner=%s\n", id, owner)
if owner.Version() != 3 { if owner.Version() != 3 {
continue continue
} }
if newOwner, ok := m[owner]; ok { if newOwner, ok := m[owner]; ok {
ownerInts := uuidToIntArray(newOwner.UUID) ownerInts := uuidToIntArray(newOwner.UUID)
entity.Set("Owner", dynbt.NewIntArray(ownerInts[:])) entity.Set("Owner", dynbt.NewIntArray(ownerInts[:]))
updated = true updated = true
} }
} }
} }
if updated { if updated {
var w bytes.Buffer var w bytes.Buffer
w.WriteByte(1) w.WriteByte(1)
gw := gzip.NewWriter(&w) gw := gzip.NewWriter(&w)
err := nbt.NewEncoder(gw).Encode(&nbtdata, "") err := nbt.NewEncoder(gw).Encode(&nbtdata, "")
if err != nil { if err != nil {
gw.Close() gw.Close()
return nil, err return nil, err
} }
err = gw.Close() err = gw.Close()
return w.Bytes(), err return w.Bytes(), err
} }
return nil, nil return nil, nil
} }

240
examples/playerdataconvert/playerdata.go
View File

@ -1,120 +1,120 @@
package main package main
import ( import (
"compress/gzip" "compress/gzip"
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"github.com/Tnze/go-mc/nbt" "github.com/Tnze/go-mc/nbt"
"github.com/Tnze/go-mc/nbt/dynbt" "github.com/Tnze/go-mc/nbt/dynbt"
"github.com/google/uuid" "github.com/google/uuid"
) )
func readPlayerdata(dir string, m map[uuid.UUID]UserCache) { func readPlayerdata(dir string, m map[uuid.UUID]UserCache) {
entries, err := os.ReadDir(dir) entries, err := os.ReadDir(dir)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to open playerdata folder: %v", err) fmt.Fprintf(os.Stderr, "Failed to open playerdata folder: %v", err)
return return
} }
for _, files := range entries { for _, files := range entries {
filename := files.Name() filename := files.Name()
if ext := filepath.Ext(filename); ext != ".dat" { if ext := filepath.Ext(filename); ext != ".dat" {
fmt.Fprintf(os.Stderr, "Unkown file type: %s\n", ext) fmt.Fprintf(os.Stderr, "Unkown file type: %s\n", ext)
continue continue
} }
// Parse old UUID from filename // Parse old UUID from filename
oldID, err := uuid.Parse(strings.TrimSuffix(filename, ".dat")) oldID, err := uuid.Parse(strings.TrimSuffix(filename, ".dat"))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Unable to parse filename as uuid: %v\n", err) fmt.Fprintf(os.Stderr, "Unable to parse filename as uuid: %v\n", err)
continue continue
} }
nbtdata, err := readNbtData(filepath.Join(dir, filename)) nbtdata, err := readNbtData(filepath.Join(dir, filename))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to read %s nbt data\n", filename) fmt.Fprintf(os.Stderr, "Failed to read %s nbt data\n", filename)
continue continue
} }
// Read old UUID from nbt // Read old UUID from nbt
uuidInts := nbtdata.Get("UUID").IntArray() uuidInts := nbtdata.Get("UUID").IntArray()
uuidBytes, err := intArrayToUUID(uuidInts) uuidBytes, err := intArrayToUUID(uuidInts)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Failed to read %s UUID\n", filename) fmt.Fprintf(os.Stderr, "Failed to read %s UUID\n", filename)
continue continue
} }
// Does they matche? // Does they matche?
if oldID != uuidBytes { if oldID != uuidBytes {
fmt.Fprintf(os.Stderr, "UUID in filename and nbt data don't match, what happend?\n") fmt.Fprintf(os.Stderr, "UUID in filename and nbt data don't match, what happend?\n")
} }
if ver := uuidBytes.Version(); ver != 3 { // v3 is for offline players if ver := uuidBytes.Version(); ver != 3 { // v3 is for offline players
fmt.Printf("Ignoring UUID: %v version: %d\n", uuidBytes, ver) fmt.Printf("Ignoring UUID: %v version: %d\n", uuidBytes, ver)
continue continue
} }
newUser, ok := m[oldID] newUser, ok := m[oldID]
if !ok { if !ok {
fmt.Printf("Skip user: %v\n", oldID) fmt.Printf("Skip user: %v\n", oldID)
continue continue
} }
// Update UUID // Update UUID
ints := uuidToIntArray(newUser.UUID) ints := uuidToIntArray(newUser.UUID)
nbtdata.Set("UUID", dynbt.NewIntArray(ints[:])) nbtdata.Set("UUID", dynbt.NewIntArray(ints[:]))
// Create new .dat file // Create new .dat file
err = writeNbtData(dir, newUser.UUID.String(), &nbtdata) err = writeNbtData(dir, newUser.UUID.String(), &nbtdata)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "Unable to write %s's .dat file: %v\n", newUser.Name, err) fmt.Fprintf(os.Stderr, "Unable to write %s's .dat file: %v\n", newUser.Name, err)
continue continue
} }
} }
} }
func readNbtData(filepath string) (nbtdata dynbt.Value, err error) { func readNbtData(filepath string) (nbtdata dynbt.Value, err error) {
file, err := os.Open(filepath) file, err := os.Open(filepath)
if err != nil { if err != nil {
return nbtdata, fmt.Errorf("failed to open userdata: %w", err) return nbtdata, fmt.Errorf("failed to open userdata: %w", err)
} }
defer file.Close() defer file.Close()
r, err := gzip.NewReader(file) r, err := gzip.NewReader(file)
if err != nil { if err != nil {
return nbtdata, fmt.Errorf("failed to decompress userdata: %w", err) return nbtdata, fmt.Errorf("failed to decompress userdata: %w", err)
} }
_, err = nbt.NewDecoder(r).Decode(&nbtdata) _, err = nbt.NewDecoder(r).Decode(&nbtdata)
if err != nil { if err != nil {
return nbtdata, fmt.Errorf("failed to parse userdata: %w", err) return nbtdata, fmt.Errorf("failed to parse userdata: %w", err)
} }
return nbtdata, nil return nbtdata, nil
} }
func writeNbtData(dir string, id string, nbtdata *dynbt.Value) error { func writeNbtData(dir string, id string, nbtdata *dynbt.Value) error {
newDatFilePath := filepath.Join(dir, id+".dat") newDatFilePath := filepath.Join(dir, id+".dat")
file, err := os.Create(newDatFilePath) file, err := os.Create(newDatFilePath)
if err != nil { if err != nil {
return err return err
} }
w := gzip.NewWriter(file) w := gzip.NewWriter(file)
err = nbt.NewEncoder(w).Encode(&nbtdata, "") err = nbt.NewEncoder(w).Encode(&nbtdata, "")
if err != nil { if err != nil {
return err return err
} }
err = w.Close() err = w.Close()
if err != nil { if err != nil {
return err return err
} }
err = file.Close() err = file.Close()
if err != nil { if err != nil {
return err return err
} }
return nil return nil
} }

96
examples/playerdataconvert/utils.go
View File

@ -1,48 +1,48 @@
package main package main
import ( import (
"encoding/binary" "encoding/binary"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net/http" "net/http"
"github.com/google/uuid" "github.com/google/uuid"
) )
func usernameToUUID(name string) (string, uuid.UUID, error) { func usernameToUUID(name string) (string, uuid.UUID, error) {
var id uuid.UUID var id uuid.UUID
resp, err := http.Get("https://api.mojang.com/users/profiles/minecraft/" + name) resp, err := http.Get("https://api.mojang.com/users/profiles/minecraft/" + name)
if err != nil { if err != nil {
return "", id, err return "", id, err
} }
var body struct { var body struct {
Name string `json:"name"` Name string `json:"name"`
ID string `json:"id"` ID string `json:"id"`
} }
err = json.NewDecoder(resp.Body).Decode(&body) err = json.NewDecoder(resp.Body).Decode(&body)
if err != nil { if err != nil {
return "", id, err return "", id, err
} }
id, err = uuid.Parse(body.ID) id, err = uuid.Parse(body.ID)
return body.Name, id, err return body.Name, id, err
} }
func intArrayToUUID(uuidInts []int32) (id uuid.UUID, err error) { func intArrayToUUID(uuidInts []int32) (id uuid.UUID, err error) {
if uuidLen := len(uuidInts); uuidLen != 4 { if uuidLen := len(uuidInts); uuidLen != 4 {
err = fmt.Errorf("invalid UUID len: %d * int32", uuidLen) err = fmt.Errorf("invalid UUID len: %d * int32", uuidLen)
return return
} }
for i, v := range uuidInts { for i, v := range uuidInts {
binary.BigEndian.PutUint32(id[i*4:], uint32(v)) binary.BigEndian.PutUint32(id[i*4:], uint32(v))
} }
return return
} }
func uuidToIntArray(id uuid.UUID) (ints [4]int32) { func uuidToIntArray(id uuid.UUID) (ints [4]int32) {
for i := range ints { for i := range ints {
ints[i] = int32(binary.BigEndian.Uint32(id[i*4:])) ints[i] = int32(binary.BigEndian.Uint32(id[i*4:]))
} }
return return
} }