private static bool Prefix(Generator079 __instance, GameObject person, PlayerInteract.Generator079Operations command)
        {
            try
            {
                var player    = person.GetPlayer();
                var generator = __instance.GetGenerator();

                switch (command)
                {
                case PlayerInteract.Generator079Operations.Tablet:

                    if (generator.IsTabletConnected || !generator.Open || __instance._localTime <= 0f || Generator079.mainGenerator.forcedOvercharge || !SynapseExtensions.CanHarmScp(player))
                    {
                        return(false);
                    }

                    Inventory component = person.GetComponent <Inventory>();

                    using (SyncList <Inventory.SyncItemInfo> .SyncListEnumerator enumerator = component.items.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            Inventory.SyncItemInfo syncItemInfo = enumerator.Current;
                            if (syncItemInfo.id == ItemType.WeaponManagerTablet)
                            {
                                bool allow2 = true;
                                var  item   = syncItemInfo.GetSynapseItem();
                                Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.TabletInjected, ref allow2);
                                Server.Get.Events.Player.InvokePlayerItemUseEvent(player, item, Api.Events.SynapseEventArguments.ItemInteractState.Finalizing, ref allow2);
                                if (!allow2)
                                {
                                    break;
                                }

                                generator.ConnectedTablet = item;
                                break;
                            }
                        }
                    }
                    return(false);

                case PlayerInteract.Generator079Operations.Cancel:
                    if (!generator.IsTabletConnected)
                    {
                        return(false);
                    }

                    bool allow = true;
                    Server.Get.Events.Player.InvokePlayerGeneratorInteractEvent(player, generator, GeneratorInteraction.TabledEjected, ref allow);
                    return(allow);
                }
                return(true);
            }
            catch (Exception e)
            {
                Logger.Get.Error($"Synapse-Event: PlayerGenerator failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
                return(true);
            }
        }
Beispiel #2
0
        public static bool Prefix(Generator079 __instance, GameObject person, PlayerInteract.Generator079Operations command)
        {
            try
            {
                switch (command)
                {
                case PlayerInteract.Generator079Operations.Tablet:

                    if (__instance.isTabletConnected || !__instance.isDoorOpen || __instance._localTime <= 0f || Generator079.mainGenerator.forcedOvercharge)
                    {
                        return(false);
                    }
                    Inventory component = person.GetComponent <Inventory>();
                    using (SyncList <Inventory.SyncItemInfo> .SyncListEnumerator enumerator = component.items.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            Inventory.SyncItemInfo syncItemInfo = enumerator.Current;
                            if (syncItemInfo.id == ItemType.WeaponManagerTablet)
                            {
                                var allow2 = true;
                                Events.InvokeGeneratorInserted(person.GetPlayer(), __instance, ref allow2);
                                if (!allow2)
                                {
                                    break;
                                }

                                component.items.Remove(syncItemInfo);
                                __instance.NetworkisTabletConnected = true;
                                break;
                            }
                        }
                    }
                    return(false);

                case PlayerInteract.Generator079Operations.Cancel:
                    if (!__instance.isTabletConnected)
                    {
                        return(false);
                    }

                    var allow = true;
                    Events.InvokeGeneratorEjected(person.GetPlayer(), __instance, ref allow);
                    return(allow);
                }
                return(true);
            }
            catch (Exception e)
            {
                Log.Error($"GeneratorTablet Event Error: {e}");
                return(true);
            }
        }
        public static bool Prefix(Generator079 __instance, GameObject person, PlayerInteract.Generator079Operations command)
        {
            Plugin.Log.Debug("Generator079InteractPatch");
            Player ply = Player.Get(__instance.gameObject);

            if (!Plugin.GhostList.Contains(ply))
            {
                return(true);
            }

            ply.ClearBroadcasts();
            ply.Broadcast(3, Translation.Translation.GetText().GeneratorDenied);

            return(false);
        }
Beispiel #4
0
        private static bool Prefix(Generator079 __instance, GameObject person, PlayerInteract.Generator079Operations command)
        {
            try
            {
                API.Features.Player player = API.Features.Player.Get(person);

                switch (command)
                {
                case PlayerInteract.Generator079Operations.Door:
                    bool isAllowed = true;

                    switch (__instance.isDoorOpen)
                    {
                    case false:
                        var openingEventArgs = new OpeningGeneratorEventArgs(player, __instance, isAllowed);

                        Player.OnOpeningGenerator(openingEventArgs);

                        isAllowed = openingEventArgs.IsAllowed;
                        break;

                    case true:
                        var closingEventArgs = new ClosingGeneratorEventArgs(player, __instance, isAllowed);

                        Player.OnClosingGenerator(closingEventArgs);

                        isAllowed = closingEventArgs.IsAllowed;
                        break;
                    }

                    if (isAllowed)
                    {
                        __instance.OpenClose(person);
                    }
                    else
                    {
                        __instance.RpcDenied();
                    }
                    break;

                case PlayerInteract.Generator079Operations.Tablet:
                    if (__instance.isTabletConnected || !__instance.isDoorOpen || (__instance._localTime <= 0.0 || Generator079.mainGenerator.forcedOvercharge))
                    {
                        break;
                    }
                    Inventory component = person.GetComponent <Inventory>();
                    using (SyncList <Inventory.SyncItemInfo> .SyncListEnumerator enumerator = component.items.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            Inventory.SyncItemInfo current = enumerator.Current;
                            if (current.id == ItemType.WeaponManagerTablet)
                            {
                                var insertingEventArgs = new InsertingGeneratorTabletEventArgs(player, __instance);

                                Player.OnInsertingGeneratorTablet(insertingEventArgs);

                                if (insertingEventArgs.IsAllowed)
                                {
                                    component.items.Remove(current);
                                    __instance.NetworkisTabletConnected = true;
                                }

                                break;
                            }
                        }

                        break;
                    }

                case PlayerInteract.Generator079Operations.Cancel:
                    var ejectingEventArgs = new EjectingGeneratorTabletEventArgs(player, __instance);

                    Player.OnEjectingGeneratorTablet(ejectingEventArgs);

                    if (ejectingEventArgs.IsAllowed)
                    {
                        __instance.EjectTablet();
                    }

                    break;
                }

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

                return(true);
            }
        }