public async void OnOpeningGenerator(OpeningGeneratorEventArgs ev)
{
if (Instance.Config.EventsToLog.PlayerOpeningGenerator && (!ev.Player.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack))
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.GeneratorOpened, ev.Player.Nickname, Instance.Config.ShouldLogUserIds ? ev.Player.UserId : Language.Redacted, ev.Player.Role))).ConfigureAwait(false);
}
}
internal void OnOpenGenerator(OpeningGeneratorEventArgs ev)
{
if (!config.Generator.canOpenGeneratorGlobal && !config.Generator.canOpenGenerator[ev.Player.Role])
{
ev.IsAllowed = false;
}
}
internal void OpeningGenerator(OpeningGeneratorEventArgs ev)
{
if (Plugin.Instance.Config.OpeningGenerator == "")
{
return;
}
string message = Plugin.Instance.Config.OpeningGenerator.Replace("%player%", ev.Player.ToString());
if (Plugin.Instance.Config.debug_to_console)
{
Log.Debug(message: "[ " + Plugin.Instance.Config.player_name + "] " + message);
}
Plugin.sendWebHook(Plugin.Instance.Config.player_url, message, Plugin.Instance.Config.player_name);
}
/// <summary> /// Called before opening a generator. /// </summary> /// <param name="ev">The <see cref="OpeningGeneratorEventArgs"/> instance.</param> public static void OnOpeningGenerator(OpeningGeneratorEventArgs ev) => OpeningGenerator.InvokeSafely(ev);
private static bool Prefix(Generator079 __instance, GameObject person, string command)
{
try
{
if (command.StartsWith("EPS_TABLET"))
{
if (__instance.isTabletConnected || !__instance.isDoorOpen || __instance._localTime <= 0.0 ||
Generator079.mainGenerator.forcedOvercharge)
{
return(false);
}
Inventory component = person.GetComponent <Inventory>();
foreach (Inventory.SyncItemInfo syncItemInfo in component.items)
{
if (syncItemInfo.id == ItemType.WeaponManagerTablet)
{
var ev = new InsertingGeneratorTabletEventArgs(API.Features.Player.Get(person), __instance);
Player.OnInsertingGeneratorTablet(ev);
if (!ev.IsAllowed)
{
return(false);
}
component.items.Remove(syncItemInfo);
__instance.NetworkisTabletConnected = true;
break;
}
}
}
else if (command.StartsWith("EPS_CANCEL"))
{
if (!__instance.isTabletConnected)
{
return(false);
}
var ev = new EjectingGeneratorTabletEventArgs(API.Features.Player.Get(person), __instance);
Player.OnEjectingGeneratorTablet(ev);
if (ev.IsAllowed)
{
__instance.EjectTablet();
}
}
else if (command.StartsWith("EPS_DOOR"))
{
Inventory component = person.GetComponent <Inventory>();
if (component == null || __instance._doorAnimationCooldown > 0.0 ||
__instance._deniedCooldown > 0.0)
{
return(false);
}
if (!__instance.isDoorUnlocked)
{
var ev = new UnlockingGeneratorEventArgs(API.Features.Player.Get(person), __instance, person.GetComponent <ServerRoles>().BypassMode);
if (component.curItem > ItemType.KeycardJanitor)
{
foreach (string permission in component.GetItemByID(component.curItem).permissions)
{
if (permission == "ARMORY_LVL_2")
{
ev.IsAllowed = true;
}
}
}
Player.OnUnlockingGenerator(ev);
if (ev.IsAllowed)
{
__instance.NetworkisDoorUnlocked = true;
__instance._doorAnimationCooldown = 0.5f;
}
else
{
__instance.RpcDenied();
}
}
else
{
OpeningGeneratorEventArgs ev;
if (!__instance.NetworkisDoorOpen)
{
ev = new OpeningGeneratorEventArgs(API.Features.Player.Get(person), __instance);
Player.OnOpeningGenerator(ev);
}
else
{
ev = new ClosingGeneratorEventArgs(API.Features.Player.Get(person), __instance);
Player.OnClosingGenerator((ClosingGeneratorEventArgs)ev);
}
if (!ev.IsAllowed)
{
__instance.RpcDenied();
return(false);
}
__instance._doorAnimationCooldown = 1.5f;
__instance.NetworkisDoorOpen = !__instance.isDoorOpen;
__instance.RpcDoSound(__instance.isDoorOpen);
}
}
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.InsertingGeneratorTablet: {e}\n{e.StackTrace}");
return(true);
}
}
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);
}
}
private static bool Prefix(Scp079Generator __instance, ReferenceHub ply, byte colliderId)
{
try
{
if ((__instance._cooldownStopwatch.IsRunning && __instance._cooldownStopwatch.Elapsed.TotalSeconds <
__instance._targetCooldown) || (colliderId != 0 && !__instance.HasFlag(__instance._flags, Scp079Generator.GeneratorFlags.Open)))
{
return(false);
}
__instance._cooldownStopwatch.Stop();
switch (colliderId)
{
case 0:
if (__instance.HasFlag(__instance._flags, Scp079Generator.GeneratorFlags.Unlocked))
{
if (__instance.HasFlag(__instance._flags, Scp079Generator.GeneratorFlags.Open))
{
ClosingGeneratorEventArgs closingGenEvent =
new ClosingGeneratorEventArgs(API.Features.Player.Get(ply), __instance);
Player.OnClosingGenerator(closingGenEvent);
if (!closingGenEvent.IsAllowed)
{
__instance.RpcDenied();
break;
}
}
else
{
OpeningGeneratorEventArgs openingGenEvent =
new OpeningGeneratorEventArgs(API.Features.Player.Get(ply), __instance);
Player.OnOpeningGenerator(openingGenEvent);
if (!openingGenEvent.IsAllowed)
{
__instance.RpcDenied();
break;
}
}
__instance.ServerSetFlag(Scp079Generator.GeneratorFlags.Open, !__instance.HasFlag(__instance._flags, Scp079Generator.GeneratorFlags.Open));
__instance._targetCooldown = __instance._doorToggleCooldownTime;
break;
}
bool flag =
(!(ply.inventory.CurInstance != null) ||
!(ply.inventory.CurInstance is KeycardItem curInstance2)
? 0
: (curInstance2.Permissions.HasFlagFast(__instance._requiredPermission) ? 1 : 0)) != 0;
UnlockingGeneratorEventArgs unlockingEvent = new UnlockingGeneratorEventArgs(API.Features.Player.Get(ply), __instance, flag);
Player.OnUnlockingGenerator(unlockingEvent);
if (unlockingEvent.IsAllowed)
{
__instance.ServerSetFlag(Scp079Generator.GeneratorFlags.Unlocked, true);
}
else
{
__instance.RpcDenied();
}
__instance._targetCooldown = __instance._unlockCooldownTime;
break;
case 1:
if ((ply.characterClassManager.IsHuman() || __instance.Activating) && !__instance.Engaged)
{
if (__instance.Activating)
{
StoppingGeneratorEventArgs stoppingGen = new StoppingGeneratorEventArgs(API.Features.Player.Get(ply), __instance);
Player.OnStoppingGenerator(stoppingGen);
if (!stoppingGen.IsAllowed)
{
__instance.RpcDenied();
break;
}
}
else
{
ActivatingGeneratorEventArgs activatingEvent =
new ActivatingGeneratorEventArgs(API.Features.Player.Get(ply), __instance);
Player.OnActivatingGenerator(activatingEvent);
if (!activatingEvent.IsAllowed)
{
__instance.RpcDenied();
break;
}
}
__instance.Activating = !__instance.Activating;
if (__instance.Activating)
{
__instance._leverStopwatch.Restart();
}
__instance._targetCooldown = __instance._doorToggleCooldownTime;
break;
}
break;
case 2:
if (__instance.Activating && !__instance.Engaged)
{
StoppingGeneratorEventArgs stoppingGen = new StoppingGeneratorEventArgs(API.Features.Player.Get(ply), __instance);
Player.OnStoppingGenerator(stoppingGen);
if (!stoppingGen.IsAllowed)
{
__instance.RpcDenied();
break;
}
__instance.ServerSetFlag(Scp079Generator.GeneratorFlags.Activating, false);
__instance._targetCooldown = __instance._unlockCooldownTime;
break;
}
break;
default:
__instance._targetCooldown = 1f;
break;
}
__instance._cooldownStopwatch.Restart();
}
catch (Exception exception)
{
API.Features.Log.Error(
$"Exiled.Events.Patches.Events.Player.InteractingGeneratorEvent: {exception}\n{exception.StackTrace}");
return(true);
}
return(false);
}
