Esempio n. 1
0
 public void OnInteract(PlayerInteractEvent ev)
 {
     if (Dump.PlayerLock.Contains(ev.Player.UserId))
     {
         ev.Allow = false;
     }
 }
 public void OnPlayerInteract(PlayerInteractEvent evt)
 {
     if (evt.Context != null)
     {
         evt.SetCancelled(ContextOnInterraction(evt.Context));
     }
 }
        public void OnPlayerInteract(PlayerInteractEvent evt)
        {
            if (evt.Context.Method != InteractionMethod.Left && evt.Context.Method != InteractionMethod.Right)
            {
                return;
            }

            if (evt.Context.Player == null || evt.Context.Target == null || !(evt.Context.Target.GetType().ToString().Contains(SIGN_IDENTIFIER)))
            {
                return;
            }

            WorldObject sign = evt.Context.Target as WorldObject;

            if (sign == null)
            {
                return;
            }

            string text = sign.GetComponent <CustomTextComponent>().Text?.ToLower();

            if (string.IsNullOrWhiteSpace(text))
            {
                return;
            }

            if (text.Contains("lift up"))
            {
                FindDestinationSignAndTeleport(evt.Context.Player, sign.Position3i, new Vector3i(0, 1, 0));
            }
            else if (text.Contains("lift down"))
            {
                FindDestinationSignAndTeleport(evt.Context.Player, sign.Position3i, new Vector3i(0, -1, 0));
            }
        }
Esempio n. 4
0
 void OnPlayerInteracted(PlayerInteractEvent @event)
 {
     if (@event.target.CompareTag("Document"))
     {
         document = @event.target;
         EventBus.Publish(new PlayerPromptEvent(@event.target, InteractionType.PickUp));
     }
 }
Esempio n. 5
0
 public void PlayerInteractEvent(PlayerInteractEvent evt)
 {
     if (evt.Context.Method.Equals(InteractionMethod.None))
     {
         return; // avoid spam
     }
     Console.WriteLine(EventUtil.EventToString(evt));
 }
Esempio n. 6
0
    void OnPlayerInteracted(PlayerInteractEvent @event)
    {
        var hidable = @event.target.GetComponent <Hideable>();

        if (hidable && !hidable.inside)
        {
            interacting = hidable;
            EventBus.Publish(new PlayerPromptEvent(@event.target, InteractionType.Hide));
        }
    }
Esempio n. 7
0
        public static void InvokePlayerInteract(GameObject player)
        {
            if (PlayerInteractEvent == null)
            {
                return;
            }

            PlayerInteractEvent ev = new PlayerInteractEvent()
            {
                Player = player.GetPlayer()
            };

            PlayerInteractEvent.InvokeSafely(ev);
        }
Esempio n. 8
0
    void OnPlayerInteracted(PlayerInteractEvent @event)
    {
        var board = @event.target.GetComponent <HeistBoard>();

        if (!board)
        {
            return;
        }

        if (board.practice)
        {
            EventBus.Publish(new PlayerPromptEvent(@event.target, InteractionType.StartPractice));
        }
        else
        {
            EventBus.Publish(new PlayerPromptEvent(@event.target, InteractionType.StartHeist));
        }

        interacting = board;
    }
        public void OnPlayerInteract(PlayerInteractEvent evt)
        {
            if (!evt.Context.HasTarget)
            {
                return;
            }

            if (!typeof(WoodSignObject).IsAssignableFrom(evt.Context.Target.GetType()))
            {
                return;
            }

            if (!evt.Context.Method.Equals(InteractionMethod.Right))
            {
                return;
            }

            WoodSignObject sign = (WoodSignObject)evt.Context.Target;

            WarpCommands.CallWarpSign(evt.Context.Player, sign.GetComponent <CustomTextComponent>().Text);
        }
Esempio n. 10
0
        protected override void HandleItemUseTransaction(ItemUseTransaction transaction)
        {
            var itemInHand = Inventory.GetItemInHand();

            switch ((McpeInventoryTransaction.ItemUseAction)transaction.ActionType)
            {
            case McpeInventoryTransaction.ItemUseAction.Destroy:
            {
                var target = Level.GetBlock(transaction.Position);

                PlayerInteractEvent interactEvent = new PlayerInteractEvent(this, itemInHand, transaction.Position,
                                                                            (BlockFace)transaction.Face,
                                                                            (target is Air)
                                                    ? PlayerInteractEvent.PlayerInteractType.LeftClickAir
                                                    : PlayerInteractEvent.PlayerInteractType.LeftClickBlock);

                EventDispatcher.DispatchEventAsync(interactEvent).Then(result =>
                    {
                        if (result.IsCancelled)
                        {
                            return;
                        }

                        base.HandleItemUseTransaction(transaction);
                    });

                return;
            }

            case McpeInventoryTransaction.ItemUseAction.Use:
            {
                if (!UseItem(itemInHand))
                {
                    //HandleNormalTransaction(transaction);
                    HandleTransactionRecords(transaction.TransactionRecords);
                    return;
                }

                break;
            }

            case McpeInventoryTransaction.ItemUseAction.Place:
            {
                var target = Level.GetBlock(transaction.Position);

                PlayerInteractEvent interactEvent = new PlayerInteractEvent(this, itemInHand, transaction.Position,
                                                                            (BlockFace)transaction.Face, (target is Air)
                                                    ? PlayerInteractEvent.PlayerInteractType.RightClickAir
                                                    : PlayerInteractEvent.PlayerInteractType.RightClickBlock);

                EventDispatcher.DispatchEventAsync(interactEvent).Then(result =>
                    {
                        if (result.IsCancelled)
                        {
                            return;
                        }

                        base.HandleItemUseTransaction(transaction);
                    });

                return;
            }
            }
        }
Esempio n. 11
0
 public void OnPlayerInteract(PlayerInteractEvent e)
 {
     Log.Info($"Player Interact triggered. (Player={e.Player} Action={e.InteractType} Coordinates={e.Coordinates})");
 }