예제 #1
0
 private void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
 {
     if (ev.Item.IsScp())
     {
         ev.IsAllowed = false;
     }
 }
예제 #2
0
        private void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
        {
            Log.Debug($"{ev.Player.Nickname} used a medical item: {ev.Item}", CustomItems.Instance.Config.IsDebugEnabled);
            if (!Check(ev.Player.CurrentItem))
            {
                return;
            }

            Timing.CallDelayed(1.5f, () =>
            {
                Log.Debug($"{ev.Player.Nickname} used a {Name}", CustomItems.Instance.Config.IsDebugEnabled);
                foreach (Exiled.API.Features.Player player in Exiled.API.Features.Player.List)
                {
                    if (player.Role == RoleType.Scp096)
                    {
                        Log.Debug($"{ev.Player.Nickname} - {Name} found an 096: {player.Nickname}", CustomItems.Instance.Config.IsDebugEnabled);
                        if (!(player.CurrentScp is Scp096 scp096))
                        {
                            continue;
                        }

                        Log.Debug($"{player.Nickname} 096 component found.", CustomItems.Instance.Config.IsDebugEnabled);
                        if ((!scp096.HasTarget(ev.Player.ReferenceHub) ||
                             scp096.PlayerState != Scp096PlayerState.Enraged) &&
                            scp096.PlayerState != Scp096PlayerState.Enraging &&
                            scp096.PlayerState != Scp096PlayerState.Attacking)
                        {
                            continue;
                        }

                        Log.Debug($"{player.Nickname} 096 checks passed.", CustomItems.Instance.Config.IsDebugEnabled);
                        scp096.ResetEnrage();
                        ev.Player.Kill(DamageTypes.Poison);
                        return;
                    }
예제 #3
0
        private static bool Prefix(ConsumableAndWearableItems __instance)
        {
            if (!__instance._interactRateLimit.CanExecute(true))
            {
                return(false);
            }

            __instance._cancel = false;
            if (__instance.cooldown > 0.0)
            {
                return(false);
            }

            for (int i = 0; i < __instance.usableItems.Length; ++i)
            {
                if (__instance.usableItems[i].inventoryID == __instance._hub.inventory.curItem && __instance.usableCooldowns[i] <= 0.0)
                {
                    var ev = new UsingMedicalItemEventArgs(API.Features.Player.Get(__instance.gameObject), __instance._hub.inventory.curItem, __instance.usableItems[i].animationDuration);

                    Player.OnUsingMedicalItem(ev);

                    __instance.cooldown = ev.Cooldown;

                    if (ev.IsAllowed)
                    {
                        Timing.RunCoroutine(__instance.UseMedicalItem(i), Segment.FixedUpdate);
                    }
                }
            }

            return(false);
        }
예제 #4
0
 internal void OnUseMedicalItem(UsingMedicalItemEventArgs ev)
 {
     if (!config.MedicalItem.canUseMedicalItemGlobal && !config.MedicalItem.canUseMedicalItem[ev.Player.Role])
     {
         ev.IsAllowed = false;
     }
 }
예제 #5
0
        private static void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
        {
            if (ev.Player != _player)
            {
                return;
            }

            if (ev.Item.IsMedical() && (!_config.Scp035Modifiers.CanHealBeyondHostHp &&
                                        ev.Player.Health >=
                                        ev.Player.ReferenceHub.characterClassManager.CurRole.maxHP ||
                                        !_config.Scp035Modifiers.CanUseMedicalItems))
            {
                ev.IsAllowed = false;
            }
        }
예제 #6
0
        /// <summary>
        /// Handles the using of this item.
        /// </summary>
        /// <param name="ev"><see cref="UsingMedicalItemEventArgs"/>.</param>
        private void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
        {
            if (!Check(ev.Player.CurrentItem))
            {
                return;
            }

            IEnumerable <Player> scp096s = Player.Get(RoleType.Scp096);

            Timing.CallDelayed(1f, () =>
            {
                foreach (Player scp in scp096s)
                {
                    if (scp.CurrentScp is PlayableScps.Scp096 scp096 && scp096.HasTarget(ev.Player.ReferenceHub))
                    {
                        scp096._targets.Remove(ev.Player.ReferenceHub);
                    }
                }
예제 #7
0
        private static bool Prefix(ConsumableAndWearableItems __instance)
        {
            try
            {
                if (!__instance._interactRateLimit.CanExecute(true))
                {
                    return(false);
                }

                __instance._cancel = false;
                if (__instance.cooldown > 0f)
                {
                    return(false);
                }

                for (int i = 0; i < __instance.usableItems.Length; ++i)
                {
                    if (__instance.usableItems[i].inventoryID == __instance._hub.inventory.curItem &&
                        __instance.usableCooldowns[i] <= 0.0)
                    {
                        var ev = new UsingMedicalItemEventArgs(Player.Get(__instance.gameObject), __instance._hub.inventory.curItem, __instance.usableItems[i].animationDuration);

                        Handlers.Player.OnUsingMedicalItem(ev);

                        __instance.cooldown = ev.Cooldown;

                        if (ev.IsAllowed)
                        {
                            Timing.RunCoroutine(__instance.UseMedicalItem(i), Segment.FixedUpdate);
                        }
                    }
                }

                return(false);
            }
            catch (Exception exception)
            {
                Log.Error($"Exiled.Events.Patches.Events.Player.UsingMedicalItem: {exception}\n{exception.StackTrace}");

                return(true);
            }
        }
예제 #8
0
 public void MultiuseMedkit(UsingMedicalItemEventArgs e)
 {
     if (e.Item == ItemType.Medkit)
     {
         if (players.ContainsKey(e.Player))
         {
             if (players[e.Player] > 2)
             {
                 e.IsAllowed = false;
                 e.Player.ShowHint("Debilu wystarczy ci leczenia");
             }
             else
             {
                 players[e.Player]++;
             }
         }
         else
         {
             players.Add(e.Player, 1);
         }
     }
 }
예제 #9
0
파일: Player.cs 프로젝트: gamehunt/EXILED
 /// <summary>
 /// Invoked before using a medical item.
 /// </summary>
 /// <param name="ev">The <see cref="UsingMedicalItemEventArgs"/> instance.</param>
 public static void OnUsingMedicalItem(UsingMedicalItemEventArgs ev) => UsingMedicalItem.InvokeSafely(ev);
예제 #10
0
 private static void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
 {
     BlacklistedIds.Add(ev.Player.Id);
     Timing.CallDelayed(3f, () => BlacklistedIds.Remove(ev.Player.Id));
 }
예제 #11
0
        /// <inheritdoc cref="Handlers.Mixed.OnUsingMedicalItem(UsingMedicalItemEventArgs)"/>
        public void OnUsingMedicalItem(UsingMedicalItemEventArgs ev)
        {
            if (!ev.IsAllowed)
            {
                return;
            }

            if (Instance.IsAdvancedSubclassing)
            {
                if (this.HasNoArmorDecayAbility(ev.Player))
                {
                    return;
                }
            }

            switch (ev.Item)
            {
            case ItemType.Adrenaline:
            {
                if (Instance.Config.Adrenaline != 0)
                {
                    if (!Instance.Config.WillDecay)
                    {
                        ev.Player.ArtificialHealth += Instance.Config.Adrenaline;

                        if (ev.Player.ArtificialHealthDecay != 0)
                        {
                            ev.Player.ArtificialHealthDecay = 0;
                        }
                    }
                    else
                    {
                        ev.Player.ArtificialHealth += Instance.Config.Adrenaline;
                    }
                }

                return;
            }

            case ItemType.SCP500:
            {
                if (Instance.Config.SCP500 != 0)
                {
                    if (!Instance.Config.WillDecay)
                    {
                        ev.Player.ArtificialHealth += Instance.Config.SCP500;

                        if (ev.Player.ArtificialHealthDecay != 0)
                        {
                            ev.Player.ArtificialHealthDecay = 0;
                        }
                    }
                    else
                    {
                        ev.Player.ArtificialHealth += Instance.Config.SCP500;
                    }
                }

                return;
            }

            case ItemType.Painkillers:
            {
                if (Instance.Config.Painkillers != 0)
                {
                    if (!Instance.Config.WillDecay)
                    {
                        ev.Player.ArtificialHealth += Instance.Config.Painkillers;

                        if (ev.Player.ArtificialHealthDecay != 0)
                        {
                            ev.Player.ArtificialHealthDecay = 0;
                        }
                    }
                    else
                    {
                        ev.Player.ArtificialHealth += Instance.Config.Painkillers;
                    }
                }

                return;
            }
            }
        }
예제 #12
0
        private IEnumerator <float> RunPillCoroutine(UsingMedicalItemEventArgs ev)
        {
            yield return(Timing.WaitForSeconds(3f));

            if (ev.Item != ItemType.Painkillers)
            {
                yield break;
            }
            var type = this.NextEffect();
            var num  = UnityEngine.Random.Range(_plugin.Config.MinDuration, _plugin.Config.MaxDuration);

            ev.Player.RemoveItem();
            ev.Player.CurrentItem = new Inventory.SyncItemInfo()
            {
                id = ItemType.None
            };
            switch (type)
            {
            case "explode":
            {
                SpawnGrenadeOnPlayer(ev.Player, GrenadeType.FragGrenade, 0.1f);
                if (ev.Player.IsAlive)
                {
                    ev.Player.Kill(DamageTypes.Grenade);
                }
                break;
            }

            case "mutate":
            {
                var cachedMutatorRole = ev.Player.Role;
                ev.Player.DropItems();
                ev.Player.SetRole(RoleType.Scp0492, true);
                Timing.CallDelayed(num, () => ev.Player.SetRole(cachedMutatorRole, true));
                break;
            }

            case "god":
                ev.Player.IsGodModeEnabled = true;
                Timing.CallDelayed(num, () => ev.Player.IsGodModeEnabled = false);
                break;

            case "paper":
                ev.Player.Scale = new Vector3(1f, 1f, 0.01f);
                Timing.CallDelayed(num, () => ev.Player.Scale = new Vector3(1f, 1f, 1f));
                break;

            case "upsidedown":
                ev.Player.Scale = new Vector3(1f, -1f, 1f);
                Timing.CallDelayed(num, () => ev.Player.Scale = new Vector3(1f, 1f, 1f));
                break;

            case "flattened":
                ev.Player.Scale = new Vector3(1f, 0.5f, 1f);
                Timing.CallDelayed(num, () => ev.Player.Scale = new Vector3(1f, 1f, 1f));
                break;

            case "bombvomit":
                Timing.RunCoroutine(GrenadeVomitTime(ev.Player, num));
                break;

            case "flashvomit":
                Timing.RunCoroutine(FlashVomitTime(ev.Player, num));
                break;

            case "ballvomit":
                Timing.RunCoroutine(BallVomitTime(ev.Player, num));
                break;

            case "scp268":
                ev.Player.IsInvisible = true;
                Timing.CallDelayed(num, () => ev.Player.IsInvisible = false);
                break;
            }

            ev.Player.EnableEffect(type, num, true);
            switch (type)
            {
            case "amnesia":
                ev.Player.ShowHint($"You've been given amnesia for {num} seconds");
                break;

            case "bleeding":
                ev.Player.ShowHint($"You've been given bleeding for {num} seconds");
                break;

            case "bombvomit":
                ev.Player.ShowHint($"You've been given bomb vomit for {num} seconds");
                break;

            case "flashvomit":
                ev.Player.ShowHint($"You've been given flash vomit for {num} seconds");
                break;

            case "ballvomit":
                ev.Player.ShowHint($"You've been given ball vomit for {num} seconds");
                break;

            case "corroding":
                ev.Player.ShowHint("You've been sent to the pocket dimension");
                break;

            case "decontaminating":
                ev.Player.ShowHint($"You've been given decontamination for {num} seconds");
                break;

            case "explode":
                ev.Player.ShowHint("You've been exploded");
                break;

            case "flashed":
                ev.Player.ShowHint("You've been flashed");
                break;

            case "god":
                ev.Player.ShowHint($"You've been given god mode for {num} seconds");
                break;

            case "hemorrhage":
                ev.Player.ShowHint($"You've been hemorrhaged for {num} seconds");
                break;

            case "mutate":
                ev.Player.ShowHint($"You've been mutated for {num} seconds");
                break;

            case "panic":
                ev.Player.ShowHint($"You've been panicked for {num} seconds");
                break;

            case "paper":
                ev.Player.ShowHint($"You've been turned into paper for {num} seconds");
                break;

            case "sinkhole":
                ev.Player.ShowHint($"You've been given sinkhole effect for {num} seconds");
                break;

            case "upsidedown":
                ev.Player.ShowHint($"You've been converted to Australian for {num} seconds");
                break;

            default:
                ev.Player.ShowHint($"You've been {type} for {num} seconds");
                break;
            }
        }
예제 #13
0
 public void OnEatThePill(UsingMedicalItemEventArgs ev)
 {
     Timing.RunCoroutine(RunPillCoroutine(ev));
 }