double chest

server/block/chest.go

@@ -29,6 +29,10 @@ type Chest struct {
 	// include colour codes.
 	CustomName string
 
+	paired       bool
+	pairX, pairZ int
+	pairInv      *inventory.Inventory
+
 	inventory *inventory.Inventory
 	viewerMu  *sync.RWMutex
 	viewers   map[ContainerViewer]struct{}
@@ -38,22 +42,28 @@ type Chest struct {
 func NewChest() Chest {
 	m := new(sync.RWMutex)
 	v := make(map[ContainerViewer]struct{}, 1)
-	return Chest{
-		inventory: inventory.New(27, func(slot int, _, item item.Stack) {
-			m.RLock()
-			defer m.RUnlock()
-			for viewer := range v {
-				viewer.ViewSlotChange(slot, item)
-			}
-		}),
+
+	c := Chest{
 		viewerMu: m,
 		viewers:  v,
 	}
+
+	c.inventory = inventory.New(27, func(slot int, _, item item.Stack) {
+		c.viewerMu.RLock()
+		defer c.viewerMu.RUnlock()
+		for viewer := range c.viewers {
+			viewer.ViewSlotChange(slot, item)
+		}
+	})
+	return c
 }
 
 // Inventory returns the inventory of the chest. The size of the inventory will be 27 or 54, depending on
 // whether the chest is single or double.
 func (c Chest) Inventory() *inventory.Inventory {
+	if c.paired {
+		return c.pairInv
+	}
 	return c.inventory
 }
 
@@ -71,6 +81,9 @@ func (Chest) SideClosed(cube.Pos, cube.Pos, *world.World) bool {
 // open opens the chest, displaying the animation and playing a sound.
 func (c Chest) open(w *world.World, pos cube.Pos) {
 	for _, v := range w.Viewers(pos.Vec3()) {
+		if c.paired {
+			v.ViewBlockAction(c.PairPos(pos), OpenAction{})
+		}
 		v.ViewBlockAction(pos, OpenAction{})
 	}
 	w.PlaySound(pos.Vec3Centre(), sound.ChestOpen{})
@@ -79,6 +92,9 @@ func (c Chest) open(w *world.World, pos cube.Pos) {
 // close closes the chest, displaying the animation and playing a sound.
 func (c Chest) close(w *world.World, pos cube.Pos) {
 	for _, v := range w.Viewers(pos.Vec3()) {
+		if c.paired {
+			v.ViewBlockAction(c.PairPos(pos), CloseAction{})
+		}
 		v.ViewBlockAction(pos, CloseAction{})
 	}
 	w.PlaySound(pos.Vec3Centre(), sound.ChestClose{})
@@ -111,6 +127,12 @@ func (c Chest) RemoveViewer(v ContainerViewer, w *world.World, pos cube.Pos) {
 // Activate ...
 func (c Chest) Activate(pos cube.Pos, _ cube.Face, w *world.World, u item.User, _ *item.UseContext) bool {
 	if opener, ok := u.(ContainerOpener); ok {
+		if c.paired && c.pairInv == nil {
+			if ch, pair, ok := c.pair(w, pos, c.PairPos(pos)); ok {
+				w.SetBlock(pos, ch, nil)
+				w.SetBlock(c.PairPos(pos), pair, nil)
+			}
+		}
 		if d, ok := w.Block(pos.Side(cube.FaceUp)).(LightDiffuser); ok && d.LightDiffusionLevel() <= 2 {
 			opener.OpenBlockContainer(pos)
 		}
@@ -129,13 +151,29 @@ func (c Chest) UseOnBlock(pos cube.Pos, face cube.Face, _ mgl64.Vec3, w *world.W
 	c = NewChest()
 	c.Facing = user.Rotation().Direction().Opposite()
 
+	for _, dir := range []cube.Direction{c.Facing.RotateLeft(), c.Facing.RotateRight()} {
+		sidePos := pos.Side(dir.Face())
+		if ch, pair, ok := c.pair(w, pos, sidePos); ok {
+			place(w, pos, ch, user, ctx)
+			w.SetBlock(ch.PairPos(pos), pair, nil)
+			return placed(ctx)
+		}
+	}
+
 	place(w, pos, c, user, ctx)
 	return placed(ctx)
 }
 
 // BreakInfo ...
 func (c Chest) BreakInfo() BreakInfo {
-	return newBreakInfo(2.5, alwaysHarvestable, axeEffective, oneOf(c))
+	return newBreakInfo(2.5, alwaysHarvestable, axeEffective, oneOf(c)).withBreakHandler(func(pos cube.Pos, w *world.World, u item.User) {
+		if c.paired {
+			pairPos := c.PairPos(pos)
+			if _, pair, ok := c.unpair(w, pos); ok {
+				w.SetBlock(pairPos, pair, nil)
+			}
+		}
+	})
 }
 
 // FuelInfo ...
@@ -155,6 +193,24 @@ func (c Chest) DecodeNBT(data map[string]any) any {
 	c = NewChest()
 	c.Facing = facing
 	c.CustomName = nbtconv.String(data, "CustomName")
+
+	pairX, ok := data["pairx"]
+	pairZ, ok2 := data["pairz"]
+	if ok && ok2 {
+		c.paired = true
+		// TODO: type assertion checks
+		c.pairX, c.pairZ = int(pairX.(int32)), int(pairZ.(int32))
+		c.pairInv = inventory.New(54, func(slot int, _, item item.Stack) {
+			c.viewerMu.RLock()
+			defer c.viewerMu.RUnlock()
+			for viewer := range c.viewers {
+				viewer.ViewSlotChange(slot, item)
+			}
+		})
+
+		nbtconv.InvFromNBT(c.pairInv, nbtconv.Slice(data, "Items"))
+	}
+
 	nbtconv.InvFromNBT(c.inventory, nbtconv.Slice(data, "Items"))
 	return c
 }
@@ -174,9 +230,79 @@ func (c Chest) EncodeNBT() map[string]any {
 	if c.CustomName != "" {
 		m["CustomName"] = c.CustomName
 	}
+
+	if c.paired {
+		m["pairx"] = int32(c.pairX)
+		m["pairz"] = int32(c.pairZ)
+	}
 	return m
 }
 
+// pair pairs this chest with the given chest position.
+func (c Chest) pair(w *world.World, pos, pairPos cube.Pos) (ch, pair Chest, ok bool) {
+	pair, ok = w.Block(pairPos).(Chest)
+	if !ok || c.Facing != pair.Facing || pair.paired && (pair.pairX != pos[0] || pair.pairZ != pos[2]) {
+		return c, pair, false
+	}
+	m := new(sync.RWMutex)
+	v := make(map[ContainerViewer]struct{})
+	left, right := c.inventory, pair.inventory
+	if pos.Side(c.Facing.RotateRight().Face()) == pairPos {
+		left, right = right, left
+	}
+	double := left.Merge(right, func(slot int, _, item item.Stack) {
+		if slot < 27 {
+			_ = left.SetItem(slot, item)
+		} else {
+			_ = right.SetItem(slot-27, item)
+		}
+		m.RLock()
+		defer m.RUnlock()
+		for viewer := range v {
+			viewer.ViewSlotChange(slot, item)
+		}
+	})
+
+	c.pairX, c.pairZ, c.paired = pairPos[0], pairPos[2], true
+	pair.pairX, pair.pairZ, pair.paired = pos[0], pos[2], true
+	c.viewerMu, pair.viewerMu = m, m
+	c.viewers, pair.viewers = v, v
+	c.pairInv, pair.pairInv = double, double
+	return c, pair, true
+}
+
+// unpair ...
+func (c Chest) unpair(w *world.World, pos cube.Pos) (ch, pair Chest, ok bool) {
+	if !c.paired {
+		return c, Chest{}, false
+	}
+
+	pair, ok = w.Block(c.PairPos(pos)).(Chest)
+	if !ok || c.Facing != pair.Facing || pair.paired && (pair.pairX != pos[0] || pair.pairZ != pos[2]) {
+		return c, pair, false
+	}
+
+	if len(c.viewers) != 0 {
+		c.close(w, pos)
+	}
+
+	c.paired, pair.paired = false, false
+	c.viewerMu, pair.viewerMu = new(sync.RWMutex), new(sync.RWMutex)
+	c.viewers, pair.viewers = make(map[ContainerViewer]struct{}, 1), make(map[ContainerViewer]struct{}, 1)
+	c.pairInv, pair.pairInv = nil, nil
+	return c, pair, true
+}
+
+// PairPos ...
+func (c Chest) PairPos(pos cube.Pos) cube.Pos {
+	return cube.Pos{c.pairX, pos[1], c.pairZ}
+}
+
+// Paired returns whether
+func (c Chest) Paired() bool {
+	return c.paired
+}
+
 // EncodeItem ...
 func (Chest) EncodeItem() (name string, meta int16) {
 	return "minecraft:chest", 0

server/item/inventory/inventory.go

@@ -257,6 +257,19 @@ func (inv *Inventory) ContainsItemFunc(n int, comparable func(stack item.Stack)
 	return n <= 0
 }
 
+// Merge merges two inventorys
+func (inv *Inventory) Merge(inv2 *Inventory, f func(int, item.Stack, item.Stack)) *Inventory {
+	// note, this is most likely a temporary method
+	inv.mu.RLock()
+	defer inv.mu.RUnlock()
+	inv2.mu.RLock()
+	defer inv2.mu.RUnlock()
+
+	n := New(len(inv.slots)+len(inv2.slots), f)
+	n.slots = append(inv.slots, inv2.slots...)
+	return n
+}
+
 // Empty checks if the inventory is fully empty: It iterates over the inventory and makes sure every stack in
 // it is empty.
 func (inv *Inventory) Empty() bool {

server/player/player.go

@@ -1791,7 +1791,7 @@ func (p *Player) BreakBlock(pos cube.Pos) {
 		return
 	}
 	held, _ := p.HeldItems()
-	drops := p.drops(held, b)
+	drops := p.drops(held, b, pos)
 
 	xp := 0
 	if breakable, ok := b.(block.Breakable); ok && !p.GameMode().CreativeInventory() {
@@ -1835,22 +1835,42 @@ func (p *Player) BreakBlock(pos cube.Pos) {
 }
 
 // drops returns the drops that the player can get from the block passed using the item held.
-func (p *Player) drops(held item.Stack, b world.Block) []item.Stack {
+func (p *Player) drops(held item.Stack, b world.Block, pos cube.Pos) []item.Stack {
 	t, ok := held.Item().(item.Tool)
 	if !ok {
 		t = item.ToolNone{}
 	}
 	var drops []item.Stack
 	if container, ok := b.(block.Container); ok {
-		// If the block is a container, it should drop its inventory contents regardless whether the
-		// player is in creative mode or not.
-		drops = container.Inventory().Items()
+		if c, ok := b.(block.Chest); ok && c.Paired() {
+			pairPos := c.PairPos(pos)
+			left, right := pos, pairPos
+			if pos.Side(c.Facing.RotateRight().Face()) == pairPos {
+				left, right = right, left
+			}
+
+			for slot, i := range c.Inventory().Slots() {
+				if i.Empty() {
+					continue
+				}
+
+				if slot < 27 && pos == left {
+					drops = append(drops, i)
+				} else if slot > 26 && pos == right {
+					drops = append(drops, i)
+				}
+			}
+		} else {
+			// If the block is a container, it should drop its inventory contents regardless whether the
+			// player is in creative mode or not.
+			drops = container.Inventory().Items()
+			container.Inventory().Clear()
+		}
 		if breakable, ok := b.(block.Breakable); ok && !p.GameMode().CreativeInventory() {
 			if breakable.BreakInfo().Harvestable(t) {
 				drops = append(drops, breakable.BreakInfo().Drops(t, held.Enchantments())...)
 			}
 		}
-		container.Inventory().Clear()
 	} else if breakable, ok := b.(block.Breakable); ok && !p.GameMode().CreativeInventory() {
 		if breakable.BreakInfo().Harvestable(t) {
 			drops = breakable.BreakInfo().Drops(t, held.Enchantments())