public void OnPlayerTriggerTesla(TriggeringTeslaEventArgs ev)
{
if (Blackout.active && Blackout.instance.Config.TeslaFlicker)
{
ev.IsTriggerable = false;
}
}
public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
if (!Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) || !Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.BypassTeslaGates))
{
return;
}
SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
if (Tracking.PlayerJustBypassedTeslaGate(ev.Player)) // The triggering tesla happens a lot, this allows the bypass to last 3 seconds.
{
ev.IsTriggerable = false;
return;
}
if (Tracking.OnCooldown(ev.Player, AbilityType.BypassTeslaGates, subClass))
{
Tracking.DisplayCooldown(ev.Player, AbilityType.BypassTeslaGates, subClass, "bypass tesla gates", Time.time);
}
else
{
Log.Debug($"Player with subclass {Tracking.PlayersWithSubclasses[ev.Player].Name} has been allowed to bypass tesla gate", Subclass.Instance.Config.Debug);
Tracking.AddCooldown(ev.Player, AbilityType.BypassTeslaGates);
if (!Tracking.PlayersThatBypassedTeslaGates.ContainsKey(ev.Player))
{
Tracking.PlayersThatBypassedTeslaGates.Add(ev.Player, 0);
}
Tracking.PlayersThatBypassedTeslaGates[ev.Player] = Time.time;
ev.IsTriggerable = false;
//ev.Player.IsUsingStamina = false;
}
}
internal void OnActivateTesla(TriggeringTeslaEventArgs ev)
{
if (!config.Tesla.canActivateTeslaGlobal && !config.Tesla.canActivateTesla[ev.Player.Role])
{
ev.IsTriggerable = false;
}
}
public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
if (ev.Player.GetEffectActive <CustomPlayerEffects.Scp268>())
{
ev.IsTriggerable = false;
}
}
/// <inheritdoc cref="Exiled.Events.Handlers.Player.OnTriggeringTesla(TriggeringTeslaEventArgs)"/>
public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
if (teslasDisabled)
{
ev.IsTriggerable = false;
}
}
private static void HandleTeslaTrigger(TriggeringTeslaEventArgs ev)
{
if (!Plugin.Config.TeslaTriggerableTeam.Contains(ev.Player.Team))
{
ev.IsTriggerable = false;
}
}
public async void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
if (Instance.Config.EventsToLog.PlayerTriggeringTesla && (!ev.Player.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack))
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.HasTriggeredATeslaGate, ev.Player.Nickname, Instance.Config.ShouldLogUserIds ? ev.Player.UserId : Language.Redacted, ev.Player.Role))).ConfigureAwait(false);
}
}
public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
if ((FacilityControl.Instance.Config.BlackoutTeslasDisabled == true && FacilityControl.LightsOut[ZoneType.HeavyContainment] == true) || FacilityControl.TeslasDisabled)
{
ev.IsTriggerable = false;
}
else
{
bool canDisable = false;
foreach (ItemType i in FacilityControl.Instance.Config.TeslaItems)
{
(bool hasItem, bool isHolding) = API.GetItemInInventory(ev.Player, i);
if (hasItem)
{
if (FacilityControl.Instance.Config.TeslaHoldItems == true)
{
if (isHolding)
{
canDisable = true;
}
}
else
{
canDisable = true;
}
}
}
if (canDisable)
{
ev.IsTriggerable = false;
}
}
}
public void OnTeslaTrigger(TriggeringTeslaEventArgs ev)
{
if (ev.Player.GetCustomRoles().Select(x => x.Id).Intersect(PluginMain.Config.IgnoredCustomroles).Any())
{
ev.IsTriggerable = false;
ev.IsInIdleRange = false;
}
switch (PluginMain.Config.TeslaControlMode)
{
case WorkMode.KeycardMode:
if (ev.Player.IsScp)
{
return;
}
foreach (Item item in ev.Player.Items)
{
if (PluginMain.Config.AllowedCards.Contains(item.Base.ItemTypeId))
{
ev.IsTriggerable = false;
ev.IsInIdleRange = false;
break;
}
}
break;
case WorkMode.RoleMode:
if (PluginMain.Config.WhitelistedRoles.Contains(ev.Player.Role))
{
ev.IsTriggerable = false;
ev.IsInIdleRange = false;
}
break;
}
}
public void TriggeringTeslaGate(TriggeringTeslaEventArgs ev)
{
if (Singleton.Config.MTFTesla)
{
return;
}
else
{
if (ev.Player.Team == Team.MTF)
{
ev.IsTriggerable = false;
}
}
if (Singleton.Config.ScientistTesla)
{
return;
}
else
{
if (ev.Player.Team == Team.RSC)
{
ev.IsTriggerable = false;
}
}
}
public void OnTeslaGate(TriggeringTeslaEventArgs ev)
{
if (ev.Player.Inventory.items.Any(item => item.id == ItemType.WeaponManagerTablet))
{
ev.IsTriggerable = false;
}
}
private static bool Prefix(TeslaGateControl.eventHandlers __instance, TriggeringTeslaEventArgs ev)
{
if (ev.Player.IsNPC())
{
ev.IsTriggerable = false;
return(false);
}
return(true);
}
private void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
foreach (TeslaGate gate in TeslaGate.List)
{
if (Exiled.API.Features.Map.FindParentRoom(gate.GameObject) == ev.Player.CurrentRoom && disabledTeslaGates.Contains(gate))
{
ev.IsTriggerable = false;
}
}
}
// Token: 0x06000008 RID: 8 RVA: 0x00002500 File Offset: 0x00000700
private static void HandleTeslaTrigger(TriggeringTeslaEventArgs ev)
{
if (SameThings.TeslaTriggerableTeam.Count == 0)
{
return;
}
if (!SameThings.TeslaTriggerableTeam.Contains((int)ev.Player.Team))
{
ev.IsTriggerable = false;
}
}
internal void TriggeringTesla(TriggeringTeslaEventArgs ev)
{
if (Plugin.Instance.Config.TriggeringTesla == "")
{
return;
}
string message = Plugin.Instance.Config.TriggeringTesla.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);
}
private static bool Prefix(TeslaGateController __instance)
{
foreach (KeyValuePair<GameObject, ReferenceHub> allHub in ReferenceHub.GetAllHubs())
{
if (allHub.Value.characterClassManager.CurClass == RoleType.Spectator)
continue;
foreach (TeslaGate teslaGate in __instance.TeslaGates)
{
if (!teslaGate.PlayerInRange(allHub.Value) || teslaGate.InProgress)
continue;
var ev = new TriggeringTeslaEventArgs(API.Features.Player.Get(allHub.Key), teslaGate.PlayerInHurtRange(allHub.Key));
Player.OnTriggeringTesla(ev);
if (ev.IsTriggerable)
teslaGate.ServerSideCode();
}
}
return false;
}
private static bool Prefix(TeslaGateController __instance)
{
try
{
foreach (KeyValuePair <GameObject, ReferenceHub> allHub in ReferenceHub.GetAllHubs())
{
if (allHub.Value.characterClassManager.CurClass == RoleType.Spectator)
{
continue;
}
foreach (TeslaGate teslaGate in __instance.TeslaGates)
{
if (!teslaGate.PlayerInRange(allHub.Value) || teslaGate.InProgress)
{
continue;
}
var ev = new TriggeringTeslaEventArgs(API.Features.Player.Get(allHub.Key), teslaGate.PlayerInHurtRange(allHub.Key));
Player.OnTriggeringTesla(ev);
if (ev.IsTriggerable)
{
teslaGate.ServerSideCode();
}
}
}
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.TriggeringTesla: {e}\n{e.StackTrace}");
return(true);
}
}
public void OnTriggeringTesla(TriggeringTeslaEventArgs eventArgs)
{
if (TeslaKeycardBlocker.Instance.Config.ItemsDisableTesla)
{
// Get all disabling items listed in config
ItemType[] disablingItemTypes = TeslaKeycardBlocker.Instance.Config.DisablingItems;
// Check wether item needs to be in hand or is only required in inventory
if (TeslaKeycardBlocker.Instance.Config.OnlyInHands)
{
if (disablingItemTypes.Contains <ItemType>(eventArgs.Player.Inventory.curItem))
{
// Disable tesla gate trigger
eventArgs.IsTriggerable = false;
}
}
else
{
// Search inventory of the player for any of the disabling items
if (eventArgs.Player.Inventory.items.Any <Inventory.SyncItemInfo>(item =>
disablingItemTypes.Contains(item.id)))
{
// Disable tesla gate trigger
eventArgs.IsTriggerable = false;
}
}
}
// If SCP 268 is active, disable tesla trigger
if (TeslaKeycardBlocker.Instance.Config.HatDisablesTesla && eventArgs.Player.ReferenceHub.playerEffectsController.GetEffect <Scp268>().Enabled)
{
eventArgs.IsTriggerable = false;
}
// CASSIE Announcment -> alle x Minuten Statusmeldung über aktuelle Anzahl von Leuten in der Facility nach Klassen sortiert (Facility Scan)
}
public void PlayerTesla(TriggeringTeslaEventArgs ev)
{
string currentTelsa = ev.Player.CurrentRoom.Name;
if (Config.cardSwipe)
{
foreach (lockedTesla r in lt)
{
if (r.locked && currentTelsa == r.roomName)
{
ev.IsTriggerable = false;
return;
}
}
}
switch (Config.cardMode)
{
case (true):
{
bool validCard = false;
var playerHeldItem = ev.Player.CurrentItem;
var playerInventory = ev.Player.Inventory.items;
if (playerInventory != null)
{
foreach (var item in playerInventory)
{
if (Config.allowedCards.Count > 0 && !Config.allowedCards.Contains(item.id))
{
continue;
}
else if (Config.allowedCards.Contains(item.id))
{
validCard = true;
break;
}
}
if (Config.cardSwipe)
{
if (Config.allowedCards.Contains(playerHeldItem.id))
{
int id = gateId(currentTelsa);
coroutine = Timing.RunCoroutine(teslaSwipe(id));
}
}
}
if (validCard)
{
ev.IsTriggerable = false;
}
break;
}
case (false):
{
if (Config.allowedRoles != null)
{
foreach (RoleType role in Config.allowedRoles)
{
if (ev.Player.Role == role)
{
ev.IsTriggerable = false;
}
}
}
break;
}
}
}
/// <summary> /// Called before triggering a tesla. /// </summary> /// <param name="ev">The <see cref="TriggeringTeslaEventArgs"/> instance.</param> public static void OnTriggeringTesla(TriggeringTeslaEventArgs ev) => TriggeringTesla.InvokeSafely(ev);
private static bool Prefix(TeslaGateController __instance)
{
try
{
foreach (TeslaGate teslaGate in __instance.TeslaGates)
{
if (!teslaGate.isActiveAndEnabled || teslaGate.InProgress)
{
continue;
}
if (teslaGate.NetworkInactiveTime > 0f)
{
teslaGate.NetworkInactiveTime = Mathf.Max(0f, teslaGate.InactiveTime - Time.fixedDeltaTime);
continue;
}
bool inIdleRange = false;
bool isTriggerable = false;
foreach (KeyValuePair <GameObject, ReferenceHub> allHub in ReferenceHub.GetAllHubs())
{
if (allHub.Value.isDedicatedServer || allHub.Value.characterClassManager.CurClass == RoleType.Spectator)
{
continue;
}
if (teslaGate.PlayerInIdleRange(allHub.Value))
{
TriggeringTeslaEventArgs ev = new TriggeringTeslaEventArgs(API.Features.Player.Get(allHub.Key), teslaGate, teslaGate.PlayerInHurtRange(allHub.Key), teslaGate.PlayerInRange(allHub.Value));
Player.OnTriggeringTesla(ev);
if (ev.IsTriggerable && !isTriggerable)
{
isTriggerable = ev.IsTriggerable;
}
if (!inIdleRange)
{
inIdleRange = ev.IsInIdleRange;
}
}
}
if (isTriggerable)
{
teslaGate.ServerSideCode();
}
if (inIdleRange != teslaGate.isIdling)
{
teslaGate.ServerSideIdle(inIdleRange);
}
}
return(false);
}
catch (Exception e)
{
API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.TriggeringTesla: {e}\n{e.StackTrace}");
return(true);
}
}
public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
{
ev.IsTriggerable = !Pro079Tesla.Singleton.IsActive;
}
public void TriggeringTeslaGate(TriggeringTeslaEventArgs ev)
{
ev.IsTriggerable = !(ev.Player.Team == Team.MTF || ev.Player.Team == Team.RSC);
}
