Exemple #1
0
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            //TODO broadcast entity animation to nearby players
            switch (this.Hand)
            {
            case Hand.MainHand:
                await server.BroadcastPacketAsync(new EntityAnimation
                {
                    EntityId  = player.EntityId,
                    Animation = EAnimation.SwingMainArm
                }, player);

                break;

            case Hand.OffHand:
                await server.BroadcastPacketAsync(new EntityAnimation
                {
                    EntityId  = player.EntityId,
                    Animation = EAnimation.SwingOffhand
                }, player);

                break;

            default:
                break;
            }
        }
Exemple #2
0
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            var result = await this.HandleAsync();

            switch (result.Type)
            {
            case PluginMessageType.Brand:
                player.client.Brand = result.Value.ToString();
                break;

            case PluginMessageType.Register:
            {
                using var stream = new MinecraftStream(this.PluginData);
                var len = await stream.ReadVarIntAsync();

                //Idk how this would work so I'm assuming a length will be sent first
                for (int i = 0; i < len; i++)
                {
                    server.RegisteredChannels.Add(await stream.ReadStringAsync());
                }

                break;
            }

            case PluginMessageType.UnRegister:
                server.RegisteredChannels.RemoveWhere(x => x == this.Channel.ToLower());
                break;

            case PluginMessageType.Custom:    //This can be ignored for now
            default:
                break;
            }
        }
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            player.Inventory.SetItem(this.ClickedSlot, new ItemStack(this.ClickedItem.Id, this.ClickedItem.Count)
            {
                Nbt     = this.ClickedItem.Nbt,
                Present = this.ClickedItem.Present
            });

            if (this.ClickedSlot >= 36 && this.ClickedSlot <= 44)
            {
                var heldItem = player.GetHeldItem();
                await server.BroadcastPacketAsync(new EntityEquipment
                {
                    EntityId = player.EntityId,
                    Slot     = ESlot.MainHand,
                    Item     = new ItemStack
                    {
                        Present = heldItem.Present,
                        Count   = (sbyte)heldItem.Count,
                        Id      = heldItem.Id,
                        Nbt     = heldItem.Nbt
                    }
                }, player);
            }
        }
Exemple #4
0
 public async Task HandleAsync(Obsidian.Server server, Player player)
 {
     await server.BroadcastPlayerDigAsync(new PlayerDiggingStore
     {
         Player = player.Uuid,
         Packet = this
     });
 }
Exemple #5
0
        public Task HandleAsync(Obsidian.Server server, Player player)
        {
            PacketHandler.Logger.LogDebug($"Successfully kept alive player {player.Username} with ka id " +
                                          $"{this.KeepAliveId} previously missed {player.client.missedKeepalives - 1} ka's"); // missed is 1 more bc we just handled one

            player.client.missedKeepalives = 0;

            return(Task.CompletedTask);
        }
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            if (this.TeleportId == player.TeleportId)
            {
                return;
            }

            await player.KickAsync("Invalid teleport... cheater?");

            //await player.TeleportAsync(player.LastLocation);//Teleport them back we didn't send this packet
        }
Exemple #7
0
        public Task HandleAsync(Obsidian.Server server, Player player)
        {
            switch (this.Action)
            {
            case EAction.StartSneaking:
                player.Sneaking = true;
                break;

            case EAction.StopSneaking:
                player.Sneaking = false;
                break;

            case EAction.LeaveBed:
                player.Sleeping = false;
                break;

            case EAction.StartSprinting:
                player.Sprinting = true;
                break;

            case EAction.StopSprinting:
                player.Sprinting = false;
                break;

            case EAction.StartJumpWithHorse:
                break;

            case EAction.StopJumpWithHorse:
                break;

            case EAction.OpenHorseInventory:
                player.InHorseInventory = true;
                break;

            case EAction.StartFlyingWithElytra:
                player.FlyingWithElytra = true;
                break;

            default:
                break;
            }

            return(Task.CompletedTask);
        }
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            player.CurrentSlot = (short)(this.Slot + 36);

            var heldItem = player.GetHeldItem();

            await server.BroadcastPacketAsync(new EntityEquipment
            {
                EntityId = player.EntityId,
                Slot     = ESlot.MainHand,
                Item     = new ItemStack
                {
                    Present = heldItem.Present,
                    Count   = (sbyte)heldItem.Count,
                    Id      = heldItem.Id,
                    Nbt     = heldItem.Nbt
                }
            }, player);
        }
Exemple #9
0
 public Task HandleAsync(Obsidian.Server server, Player player) => Task.CompletedTask;
 public Task HandleAsync(Obsidian.Server server, Player player) =>
 server.ParseMessageAsync(this.Message, player.client);
Exemple #11
0
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            var currentItem = player.GetHeldItem();

            var block = Registry.GetBlock(currentItem.Type);

            var location = this.Location;

            var interactedBlock = server.World.GetBlock(location);

            if (interactedBlock.CanInteract() && !player.Sneaking)
            {
                var arg = await server.Events.InvokeBlockInteractAsync(new BlockInteractEventArgs(player, block, this.Location));

                if (arg.Cancel)
                {
                    return;
                }

                //TODO open chests/Crafting inventory ^ ^

                //Logger.LogDebug($"Block Interact: {interactedBlock} - {location}");

                return;
            }

            if (player.Gamemode != Gamemode.Creative)
            {
                player.Inventory.RemoveItem(player.CurrentSlot);
            }

            switch (this.Face) // TODO fix this for logs
            {
            case BlockFace.Bottom:
                location.Y -= 1;
                break;

            case BlockFace.Top:
                location.Y += 1;
                break;

            case BlockFace.North:
                location.Z -= 1;
                break;

            case BlockFace.South:
                location.Z += 1;
                break;

            case BlockFace.West:
                location.X -= 1;
                break;

            case BlockFace.East:
                location.X += 1;
                break;

            default:
                break;
            }

            block.Location = location;
            server.World.SetBlock(location, block);

            await server.BroadcastBlockPlacementAsync(player, block, location);
        }
Exemple #12
0
        public async Task HandleAsync(Obsidian.Server server, Player player)
        {
            await player.UpdateAsync(server, this.Position, this.OnGround);

            await player.World.UpdateChunksForClientAsync(player.client);
        }
Exemple #13
0
 public async Task HandleAsync(Obsidian.Server server, Player player)
 {
     await player.UpdateAsync(server, this.Position, this.Yaw, this.Pitch, this.OnGround);
 }
Exemple #14
0
        public Task HandleAsync(Obsidian.Server server, Player player)
        {
            if (this.WindowId == 0)
            {
                //This is the player inventory
                switch (this.Mode)
                {
                case InventoryOperationMode.MouseClick:    //TODO InventoryClickEvent
                {
                    if (this.Button == 0)
                    {
                        player.Inventory.RemoveItem(this.ClickedSlot, 64);
                    }
                    else
                    {
                        player.Inventory.RemoveItem(this.ClickedSlot, this.Item.Count / 2);
                    }
                    break;
                }

                case InventoryOperationMode.ShiftMouseClick:
                    break;

                case InventoryOperationMode.NumberKeys:
                    break;

                case InventoryOperationMode.MiddleMouseClick:
                    break;

                case InventoryOperationMode.Drop:
                {
                    //If clicked slot is -999 that means they clicked outside the inventory
                    if (this.ClickedSlot != -999)
                    {
                        if (this.Button == 0)
                        {
                            player.Inventory.RemoveItem(this.ClickedSlot);
                        }
                        else
                        {
                            player.Inventory.RemoveItem(this.ClickedSlot, 64);
                        }
                    }
                    break;
                }

                case InventoryOperationMode.MouseDrag:
                {
                    if (this.ClickedSlot == -999)
                    {
                        if (this.Button == 0 || this.Button == 4 || this.Button == 8)
                        {
                            player.IsDragging = true;
                        }
                        else if (this.Button == 2 || this.Button == 6 || this.Button == 10)
                        {
                            player.IsDragging = false;
                        }
                    }
                    else if (player.IsDragging)
                    {
                        if (player.Gamemode == Gamemode.Creative)
                        {
                            if (this.Button != 9)
                            {
                                break;
                            }

                            //creative copy
                            player.Inventory.SetItem(this.ClickedSlot, new ItemStack(this.Item.Id, this.Item.Count)
                                {
                                    Nbt = this.Item.Nbt
                                });
                        }
                        else
                        {
                            if (this.Button != 1 || this.Button != 5)
                            {
                                break;
                            }

                            //survival painting
                            player.Inventory.SetItem(this.ClickedSlot, new ItemStack(this.Item.Id, this.Item.Count)
                                {
                                    Nbt = this.Item.Nbt
                                });
                        }
                    }
                    else
                    {
                        //It shouldn't get here
                    }

                    break;
                }

                case InventoryOperationMode.DoubleClick:
                    break;

                default:
                    break;
                }
            }
            else
            {
            }

            return(Task.CompletedTask);
        }