Container events

Obsidian.API/Events/ContainerClickEventArgs.cs

@@ -1,12 +1,9 @@
-namespace Obsidian.API.Events;
+using System.Diagnostics.CodeAnalysis;
 
-public class ContainerClickEventArgs : PlayerEventArgs, ICancellable
-{
-    /// <summary>
-    /// Gets the clicked container
-    /// </summary>
-    public BaseContainer Container { get; }
+namespace Obsidian.API.Events;
 
+public sealed class ContainerClickEventArgs : ContainerEventArgs, ICancellable
+{
     /// <summary>
     /// Gets the current item that was clicked
     /// </summary>
@@ -20,6 +17,7 @@ public class ContainerClickEventArgs : PlayerEventArgs, ICancellable
     /// <inheritdoc />
     public bool IsCancelled { get; private set; }
 
+    [SetsRequiredMembers]
     internal ContainerClickEventArgs(IPlayer player, BaseContainer container, ItemStack item) : base(player)
     {
         this.Container = container;

Obsidian.API/Events/ContainerClosedEventArgs.cs

@@ -0,0 +1,11 @@
+namespace Obsidian.API.Events;
+public sealed class ContainerClosedEventArgs : ContainerEventArgs, ICancellable
+{
+    public bool IsCancelled { get; private set; }
+
+    internal ContainerClosedEventArgs(IPlayer player) : base(player)
+    {
+    }
+
+    public void Cancel() => this.IsCancelled = true;
+}

Obsidian.API/Events/ContainerEventArgs.cs

@@ -0,0 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Obsidian.API.Events;
+
+public class ContainerEventArgs : PlayerEventArgs
+{
+    public required BaseContainer Container { get; init; }
+
+    protected ContainerEventArgs(IPlayer player) : base(player)
+    {
+    }
+}

Obsidian.API/Events/ICancellable.cs

@@ -13,6 +13,6 @@ public interface ICancellable
     /// <summary>
     /// Sets a flag which prevents default (vanilla) behavior from executing.
     /// </summary>
-    /// <remarks>This flag only affects vanilla behavior. If you wish to prevent other handlers from running, see <see cref="AsyncEventArgs.IsHandled"/>.</remarks>
+    /// <remarks>This flag only affects vanilla behavior. If you wish to prevent other handlers from running, see <see cref="AsyncEventArgs.Handled"/>.</remarks>
     public void Cancel();
 }

Obsidian/Entities/Player.cs

@@ -41,7 +41,7 @@ public sealed partial class Player : Living, IPlayer
     public Container Inventory { get; }
     public Container EnderInventory { get; }
 
-    public BaseContainer OpenedContainer { get; set; }
+    public BaseContainer? OpenedContainer { get; set; }
 
     public List<SkinProperty> SkinProperties { get; set; } = new();
 

Obsidian/Events/MinecraftEventHandler.cs

@@ -19,6 +19,7 @@ public class MinecraftEventHandler
     public AsyncEvent<EntityInteractEventArgs> EntityInteract;
     public AsyncEvent<PlayerAttackEntityEventArgs> PlayerAttackEntity;
     public AsyncEvent<PlayerInteractEventArgs> PlayerInteract;
+    public AsyncEvent<ContainerClosedEventArgs> ContainerClosed;
     public AsyncEvent ServerTick;
 
     public MinecraftEventHandler()
@@ -40,6 +41,7 @@ public MinecraftEventHandler()
         EntityInteract = new("EntityInteract", HandleException);
         PlayerAttackEntity = new("PlayerAttackEntity", HandleException);
         PlayerInteract = new("PlayerInteract", HandleException);
+        ContainerClosed = new("ContainerClosed", HandleException);
     }
 
     private void HandleException(AsyncEvent e, Exception exception)
@@ -50,6 +52,12 @@ private void HandleException<T>(AsyncEvent<T> e, Exception exception)
     {
     }
 
+    internal async ValueTask<ContainerClosedEventArgs> InvokeContainerClosedAsync(ContainerClosedEventArgs eventArgs)
+    {
+        await ContainerClosed.InvokeAsync(eventArgs);
+        return eventArgs;
+    }
+
     internal async ValueTask<QueuePacketEventArgs> InvokeQueuePacketAsync(QueuePacketEventArgs eventArgs)
     {
         await QueuePacket.InvokeAsync(eventArgs);

Obsidian/Net/Packets/Play/CloseContainerPacket.cs

@@ -1,6 +1,5 @@
-using Obsidian.API.Builders;
+using Obsidian.API.Events;
 using Obsidian.Entities;
-using Obsidian.Net.Packets.Play.Clientbound;
 using Obsidian.Serialization.Attributes;
 
 namespace Obsidian.Net.Packets.Play;
@@ -14,44 +13,9 @@ public partial class CloseContainerPacket : IClientboundPacket, IServerboundPack
 
     public async ValueTask HandleAsync(Server server, Player player)
     {
-        if (WindowId == 0 || (player.OpenedContainer is not IBlockEntity tileEntity))
+        if (WindowId == 0)
             return;
 
-        var position = tileEntity.BlockPosition;
-
-        var block = await player.World.GetBlockAsync(position);
-
-        if (block == null)
-            return;
-
-        if (block.Is(Material.Chest))
-        {
-            await player.client.QueuePacketAsync(new BlockActionPacket
-            {
-                Position = position,
-                ActionId = 1,
-                ActionParam = 0,
-                BlockType = block.BaseId
-            });
-
-            await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockChestClose)
-                .WithSoundPosition(position.SoundPosition)
-                .Build());
-        }
-        else if (block.Is(Material.EnderChest))
-        {
-            await player.client.QueuePacketAsync(new BlockActionPacket
-            {
-                Position = position,
-                ActionId = 1,
-                ActionParam = 0,
-                BlockType = block.BaseId
-            });
-            await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockEnderChestClose)
-                .WithSoundPosition(position.SoundPosition)
-                .Build());
-        }
-
-        player.OpenedContainer = null;
+        await server.Events.InvokeContainerClosedAsync(new ContainerClosedEventArgs(player) { Container = player.OpenedContainer! });
     }
 }

Obsidian/Server.Events.cs

@@ -20,6 +20,85 @@ private async Task PlayerAttack(PlayerAttackEntityEventArgs e)
         }
     }
 
+    private async Task OnContainerClosed(ContainerClosedEventArgs e)
+    {
+        if (e.IsCancelled)
+            return;
+
+        var player = (e.Player as Player)!;
+
+        //Player successfully exited container
+        player.OpenedContainer = null;
+
+        if (e.Container is not IBlockEntity blockEntity)
+            return;
+
+        var position = blockEntity.BlockPosition;
+        var block = await e.Player.WorldLocation.GetBlockAsync(position);
+
+        if (block is null)
+            return;
+
+        switch (block.Material)
+        {
+            case Material.Chest:
+            {
+                await player.client.QueuePacketAsync(new BlockActionPacket
+                {
+                    Position = position,
+                    ActionId = 1,
+                    ActionParam = 0,
+                    BlockType = block.BaseId
+                });
+
+                await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockChestClose)
+                    .WithSoundPosition(position.SoundPosition)
+                    .Build());
+
+                break;
+            }
+            case Material.EnderChest:
+            {
+                await player.client.QueuePacketAsync(new BlockActionPacket
+                {
+                    Position = position,
+                    ActionId = 1,
+                    ActionParam = 0,
+                    BlockType = block.BaseId
+                });
+
+                await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockEnderChestClose)
+                    .WithSoundPosition(position.SoundPosition)
+                    .Build());
+                break;
+            }
+            case Material.Barrel://Barrels don't have a block action
+            {
+                await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockBarrelClose)
+                    .WithSoundPosition(position.SoundPosition)
+                    .Build());
+
+                break;
+            }
+            case Material.ShulkerBox:
+            {
+                await player.client.QueuePacketAsync(new BlockActionPacket
+                {
+                    Position = position,
+                    ActionId = 1,
+                    ActionParam = 0,
+                    BlockType = block.BaseId
+                });
+
+                await player.SendSoundAsync(SoundEffectBuilder.Create(SoundId.BlockShulkerBoxClose)
+                    .WithSoundPosition(position.SoundPosition)
+                    .Build());
+
+                break;
+            }
+        }
+    }
+
     private async Task OnPlayerInteract(PlayerInteractEventArgs e)
     {
         var item = e.Item;

Obsidian/Server.cs

@@ -136,6 +136,7 @@ public static string VERSION
         Events.PlayerJoin += OnPlayerJoin;
         Events.PlayerAttackEntity += PlayerAttack;
         Events.PlayerInteract += OnPlayerInteract;
+        Events.ContainerClosed += OnContainerClosed;
 
         PersistentDataPath = Path.Combine(ServerFolderPath, "persistentdata");