389 lines
9.3 KiB
Go
389 lines
9.3 KiB
Go
package worlds
|
|
|
|
import (
|
|
"github.com/bedrock-tool/bedrocktool/locale"
|
|
"github.com/bedrock-tool/bedrocktool/utils/nbtconv"
|
|
"github.com/df-mc/dragonfly/server/block"
|
|
"github.com/df-mc/dragonfly/server/item"
|
|
"github.com/df-mc/dragonfly/server/item/inventory"
|
|
"github.com/df-mc/dragonfly/server/world"
|
|
"github.com/sandertv/gophertunnel/minecraft/protocol"
|
|
"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type itemContainer struct {
|
|
OpenPacket *packet.ContainerOpen
|
|
Content *packet.InventoryContent
|
|
}
|
|
|
|
func (w *worldsHandler) processItemPacketsServer(pk packet.Packet) packet.Packet {
|
|
if !w.settings.SaveInventories {
|
|
return pk
|
|
}
|
|
|
|
switch pk := pk.(type) {
|
|
case *packet.ContainerOpen:
|
|
// add to open containers
|
|
existing, ok := w.worldState.openItemContainers[pk.WindowID]
|
|
if !ok {
|
|
existing = &itemContainer{}
|
|
}
|
|
w.worldState.openItemContainers[pk.WindowID] = &itemContainer{
|
|
OpenPacket: pk,
|
|
Content: existing.Content,
|
|
}
|
|
|
|
case *packet.InventoryContent:
|
|
if pk.WindowID == 0x0 { // inventory
|
|
w.serverState.playerInventory = pk.Content
|
|
} else {
|
|
// save content
|
|
existing, ok := w.worldState.openItemContainers[byte(pk.WindowID)]
|
|
if ok {
|
|
existing.Content = pk
|
|
}
|
|
}
|
|
|
|
case *packet.InventorySlot:
|
|
if pk.WindowID == 0x0 {
|
|
if w.serverState.playerInventory == nil {
|
|
w.serverState.playerInventory = make([]protocol.ItemInstance, 36)
|
|
}
|
|
w.serverState.playerInventory[pk.Slot] = pk.NewItem
|
|
} else {
|
|
// save content
|
|
existing, ok := w.worldState.openItemContainers[byte(pk.WindowID)]
|
|
if ok {
|
|
existing.Content.Content[pk.Slot] = pk.NewItem
|
|
}
|
|
}
|
|
|
|
case *packet.ItemStackResponse:
|
|
|
|
case *packet.ContainerClose:
|
|
// find container info
|
|
existing, ok := w.worldState.openItemContainers[byte(pk.WindowID)]
|
|
|
|
switch pk.WindowID {
|
|
case protocol.WindowIDArmour: // todo handle
|
|
case protocol.WindowIDOffHand: // todo handle
|
|
case protocol.WindowIDUI:
|
|
case protocol.WindowIDInventory: // todo handle
|
|
if !ok {
|
|
break
|
|
}
|
|
|
|
default:
|
|
if !ok {
|
|
logrus.Warn(locale.Loc("warn_window_closed_not_open", nil))
|
|
break
|
|
}
|
|
|
|
if existing.Content == nil {
|
|
break
|
|
}
|
|
|
|
pos := existing.OpenPacket.ContainerPosition
|
|
cp := protocol.SubChunkPos{pos.X() << 4, pos.Z() << 4}
|
|
|
|
// create inventory
|
|
inv := inventory.New(len(existing.Content.Content), nil)
|
|
for i, c := range existing.Content.Content {
|
|
item := stackToItem(c.Stack)
|
|
inv.SetItem(i, item)
|
|
}
|
|
|
|
// put into subchunk
|
|
nbts := w.worldState.blockNBT[cp]
|
|
for i, v := range nbts {
|
|
NBTPos := protocol.BlockPos{v["x"].(int32), v["y"].(int32), v["z"].(int32)}
|
|
if NBTPos == pos {
|
|
w.worldState.blockNBT[cp][i]["Items"] = nbtconv.InvToNBT(inv)
|
|
break
|
|
}
|
|
}
|
|
|
|
w.proxy.SendMessage(locale.Loc("saved_block_inv", nil))
|
|
|
|
// remove it again
|
|
delete(w.worldState.openItemContainers, byte(pk.WindowID))
|
|
}
|
|
|
|
case *packet.ItemComponent:
|
|
w.bp.ApplyComponentEntries(pk.Items)
|
|
case *packet.MobArmourEquipment:
|
|
if pk.EntityRuntimeID == w.proxy.Server.GameData().EntityRuntimeID {
|
|
|
|
}
|
|
}
|
|
return pk
|
|
}
|
|
|
|
func (w *worldsHandler) processItemPacketsClient(pk packet.Packet, forward *bool) packet.Packet {
|
|
switch pk := pk.(type) {
|
|
case *packet.ItemStackRequest:
|
|
var requests []protocol.ItemStackRequest
|
|
for _, isr := range pk.Requests {
|
|
for _, sra := range isr.Actions {
|
|
if sra, ok := sra.(*protocol.TakeStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
if sra, ok := sra.(*protocol.DropStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
if sra, ok := sra.(*protocol.DestroyStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
if sra, ok := sra.(*protocol.PlaceInContainerStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
if sra, ok := sra.(*protocol.TakeOutContainerStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
if sra, ok := sra.(*protocol.DestroyStackRequestAction); ok {
|
|
if sra.Source.StackNetworkID == MapItemPacket.Content[0].StackNetworkID {
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
requests = append(requests, isr)
|
|
}
|
|
pk.Requests = requests
|
|
case *packet.MobEquipment:
|
|
if pk.NewItem.Stack.NBTData["map_uuid"] == int64(ViewMapID) {
|
|
*forward = false
|
|
}
|
|
}
|
|
return pk
|
|
}
|
|
|
|
// stackToItem converts a network ItemStack representation back to an item.Stack.
|
|
func stackToItem(it protocol.ItemStack) item.Stack {
|
|
t, ok := world.ItemByRuntimeID(it.NetworkID, int16(it.MetadataValue))
|
|
if !ok {
|
|
t = block.Air{}
|
|
}
|
|
if it.BlockRuntimeID > 0 {
|
|
// It shouldn't matter if it (for whatever reason) wasn't able to get the block runtime ID,
|
|
// since on the next line, we assert that the block is an item. If it didn't succeed, it'll
|
|
// return air anyway.
|
|
b, _ := world.BlockByRuntimeID(uint32(it.BlockRuntimeID))
|
|
if t, ok = b.(world.Item); !ok {
|
|
t = block.Air{}
|
|
}
|
|
}
|
|
//noinspection SpellCheckingInspection
|
|
if nbter, ok := t.(world.NBTer); ok && len(it.NBTData) != 0 {
|
|
t = nbter.DecodeNBT(it.NBTData).(world.Item)
|
|
}
|
|
s := item.NewStack(t, int(it.Count))
|
|
return nbtconv.Item(it.NBTData, &s)
|
|
}
|
|
|
|
func (w *worldsHandler) playerData() (ret map[string]any) {
|
|
ret = map[string]any{
|
|
"format_version": "1.12.0",
|
|
"identifier": "minecraft:player",
|
|
}
|
|
|
|
if len(w.serverState.playerInventory) > 0 {
|
|
inv := inventory.New(len(w.serverState.playerInventory), nil)
|
|
for i, ii := range w.serverState.playerInventory {
|
|
inv.SetItem(i, stackToItem(ii.Stack))
|
|
}
|
|
ret["Inventory"] = nbtconv.InvToNBT(inv)
|
|
}
|
|
|
|
ret["abilities"] = map[string]any{
|
|
"doorsandswitches": true,
|
|
"op": true,
|
|
"opencontainers": true,
|
|
"teleport": true,
|
|
"attackmobs": true,
|
|
"instabuild": true,
|
|
"permissionsLevel": int32(3),
|
|
"flying": false,
|
|
"lightning": false,
|
|
"playerPermissionsLevel": int32(2),
|
|
"attackplayers": true,
|
|
"build": true,
|
|
"flySpeed": float32(0.05),
|
|
"invulnerable": true,
|
|
"mayfly": true,
|
|
"mine": true,
|
|
"walkSpeed": float32(0.1),
|
|
}
|
|
|
|
type attribute struct {
|
|
Name string
|
|
Base float32
|
|
Current float32
|
|
DefaultMax float32
|
|
DefaultMin float32
|
|
Max float32
|
|
Min float32
|
|
}
|
|
|
|
ret["Attributes"] = []attribute{
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 1024,
|
|
DefaultMin: -1024,
|
|
Max: 1024,
|
|
Min: -1024,
|
|
Name: "minecraft:luck",
|
|
},
|
|
{
|
|
Base: 20,
|
|
Current: 20,
|
|
DefaultMax: 20,
|
|
DefaultMin: 0,
|
|
Max: 20,
|
|
Min: 0,
|
|
Name: "minecraft:health",
|
|
},
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 16,
|
|
DefaultMin: 0,
|
|
Max: 16,
|
|
Min: 0,
|
|
Name: "minecraft:absorption",
|
|
},
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 1,
|
|
DefaultMin: 0,
|
|
Max: 1,
|
|
Min: 0,
|
|
Name: "minecraft:knockback_resistance",
|
|
},
|
|
{
|
|
Base: 0.1,
|
|
Current: 0.1,
|
|
DefaultMax: 3.4028235e+38,
|
|
DefaultMin: 0,
|
|
Max: 3.4028235e+38,
|
|
Min: 0,
|
|
Name: "minecraft:movement",
|
|
},
|
|
{
|
|
Base: 0.02,
|
|
Current: 0.02,
|
|
DefaultMax: 3.4028235e+38,
|
|
DefaultMin: 0,
|
|
Max: 3.4028235e+38,
|
|
Min: 0,
|
|
Name: "minecraft:underwater_movement",
|
|
},
|
|
{
|
|
Base: 0.02,
|
|
Current: 0.02,
|
|
DefaultMax: 3.4028235e+38,
|
|
DefaultMin: 0,
|
|
Max: 3.4028235e+38,
|
|
Min: 0,
|
|
Name: "minecraft:lava_movement",
|
|
},
|
|
{
|
|
Base: 16,
|
|
Current: 16,
|
|
DefaultMax: 2048,
|
|
DefaultMin: 0,
|
|
Max: 2048,
|
|
Min: 0,
|
|
Name: "minecraft:follow_range",
|
|
},
|
|
{
|
|
Base: 1,
|
|
Current: 1,
|
|
DefaultMax: 1,
|
|
DefaultMin: 1,
|
|
Max: 1,
|
|
Min: 1,
|
|
Name: "minecraft:attack_damage",
|
|
},
|
|
{
|
|
Base: 20,
|
|
Current: 20,
|
|
DefaultMax: 20,
|
|
DefaultMin: 0,
|
|
Max: 20,
|
|
Min: 0,
|
|
Name: "minecraft:player.hunger",
|
|
},
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 20,
|
|
DefaultMin: 0,
|
|
Max: 20,
|
|
Min: 0,
|
|
Name: "minecraft:player.exhaustion",
|
|
},
|
|
{
|
|
Base: 5,
|
|
Current: 5,
|
|
DefaultMax: 20,
|
|
DefaultMin: 0,
|
|
Max: 20,
|
|
Min: 0,
|
|
Name: "minecraft:player.saturation",
|
|
},
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 24791,
|
|
DefaultMin: 0,
|
|
Max: 24791,
|
|
Min: 0,
|
|
Name: "minecraft:player.level",
|
|
},
|
|
{
|
|
Base: 0,
|
|
Current: 0,
|
|
DefaultMax: 1,
|
|
DefaultMin: 0,
|
|
Max: 1,
|
|
Min: 0,
|
|
Name: "minecraft:player.experience",
|
|
},
|
|
}
|
|
|
|
ret["Tags"] = []string{}
|
|
ret["OnGround"] = true
|
|
|
|
spawn := w.proxy.Server.GameData().PlayerPosition
|
|
|
|
ret["SpawnX"] = int32(spawn.X())
|
|
ret["SpawnY"] = int32(spawn.Y())
|
|
ret["SpawnZ"] = int32(spawn.Z())
|
|
|
|
ret["Pos"] = []float32{
|
|
float32(spawn.X()),
|
|
float32(spawn.Y()),
|
|
float32(spawn.Z()),
|
|
}
|
|
|
|
ret["Rotation"] = []float32{
|
|
w.serverState.PlayerPos.Pitch,
|
|
w.serverState.PlayerPos.Yaw,
|
|
}
|
|
|
|
return
|
|
}
|