internal void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (IsLobby)
{
ev.IsAllowed = false;
}
}
public void OnLockerAccess(InteractingLockerEventArgs ev)
{
if (!RKConfig.HandleLockersAccess)
{
return;
}
RemoteKeycard.instance.Debug($"Player {ev.Player.Nickname} ({ev.Player.UserId}) is trying to access the locker");
RemoteKeycard.instance.Debug("Locker permissions: (null)");
if (ev.IsAllowed)
{
RemoteKeycard.instance.Debug("Locker access allowed");
return;
}
RemoteKeycard.instance.Debug("Further processing allowed...");
var playerIntentory = ev.Player.Inventory.items;
var tempList = ListPool <string> .Shared.Rent();
tempList.Add(ev.Chamber.accessToken);
ev.IsAllowed = Handle(playerIntentory, tempList);
ListPool <string> .Shared.Return(tempList);
}
public async void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (Instance.Config.EventsToLog.PlayerInteractingLocker && (!ev.Player.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack))
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.UsedLocker, ev.Player.Nickname, Instance.Config.ShouldLogUserIds ? ev.Player.UserId : Language.Redacted, ev.Player.Role))).ConfigureAwait(false);
}
}
public void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (Instance.Config.GhostInteract || !GhostList.Contains(ev.Player))
{
return;
}
ev.IsAllowed = false;
}
public void OnLockerInteract(InteractingLockerEventArgs ev)
{
try
{
ResetAFKTime(ev.Player);
}
catch (Exception e)
{
Log.Error($"ERROR In OnLockerInteract(): {e}");
}
}
public void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (scp372.Contains(ev.Player.UserId))
{
ev.Player.IsInvisible = false;
Timing.CallDelayed(1f, () =>
{
ev.Player.IsInvisible = true;
});
}
}
public void OnPlayerLockerInteract(InteractingLockerEventArgs ev)
{
if (ev.Player.Side == Side.Scp)
{
return;
}
if (ev.IsAllowed)
{
return;
}
ev.IsAllowed = HasPermission(ev.Player, ev.Chamber.accessToken);
}
internal void InteractingLocker(InteractingLockerEventArgs ev)
{
if (Plugin.Instance.Config.InteractingLocker == "")
{
return;
}
string message = Plugin.Instance.Config.InteractingLocker.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);
}
public void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (!KeepTheChange.Instance.Config.SpawnCoins)
{
return;
}
if (KeepTheChange.Instance.server.spawnedCoins >= KeepTheChange.Instance.Config.MaxCoins)
{
return;
}
lockersOpened++;
if (lockersOpened % 2 == 0)
{
return; // For some reason it's called twice so we just disregard every 2nd call. I'll remove this once it's fixed
}
if (openedLockers.ContainsKey(ev.LockerId) && openedLockers[ev.LockerId].Contains(ev.ChamberId))
{
return;
}
if (!openedLockers.ContainsKey(ev.LockerId))
{
openedLockers.Add(ev.LockerId, new List <byte>()
{
ev.ChamberId
});
}
else
{
openedLockers[ev.LockerId].Add(ev.ChamberId);
}
int coinsToSpawn = Mathf.Clamp(rnd.Next(0, KeepTheChange.Instance.Config.MaxCoinsInLocker), 0, KeepTheChange.Instance.Config.MaxCoins - KeepTheChange.Instance.server.spawnedCoins);
for (int i = 0; i < coinsToSpawn; i++)
{
Vector3 pos = new Vector3(ev.Chamber.spawnpoint.position.x, ev.Locker.gameObject.position.y + rnd.Next(-1, 2), ev.Chamber.spawnpoint.position.z);
Exiled.API.Extensions.Item.Spawn(ItemType.Coin, 1f, pos, Quaternion.Euler(90, rnd.Next(361), rnd.Next(361)));
Log.Debug($"Spawned coin in locker at pos ({pos.x}, {pos.y}, {pos.z})", KeepTheChange.Instance.Config.Debug);
}
}
public void OnInteractingLocker(InteractingLockerEventArgs ev)
{
if (ev.IsAllowed)
{
return;
}
if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) &&
Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.BypassKeycardReaders))
{
SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
if (Tracking.OnCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass))
{
Tracking.DisplayCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass, "bypass keycard readers", Time.time);
}
else
{
Log.Debug($"Player with subclass {Tracking.PlayersWithSubclasses[ev.Player].Name} has been allowed to access locked locker", Subclass.Instance.Config.Debug);
Tracking.AddCooldown(ev.Player, AbilityType.BypassKeycardReaders);
ev.IsAllowed = true;
}
}
}
public void OnLockerAccess(InteractingLockerEventArgs ev)
{
if (!CanInteract(ev.Player) || !RKConfig.HandleLockersAccess)
{
return;
}
RemoteKeycard.Debug($"Player {ev.Player.Nickname} ({ev.Player.UserId}) is trying to access the locker");
RemoteKeycard.Debug($"Locker permissions: {(!string.IsNullOrEmpty(ev.Chamber.accessToken) ? "(null)" : ev.Chamber.accessToken)}");
if (ev.IsAllowed)
{
RemoteKeycard.Debug("Locker access is allowed");
return;
}
RemoteKeycard.Debug("Further processing is allowed...");
var permissions = Keycard.ToTruthyPermissions(ev.Chamber.accessToken);
var playerIntentory = ev.Player.Inventory.items;
ev.IsAllowed = Handle(playerIntentory, permissions);
}
/// <summary> /// Called before interacting with a locker. /// </summary> /// <param name="ev">The <see cref="PlacingDecalEventArgs"/> instance.</param> public static void OnInteractingLocker(InteractingLockerEventArgs ev) => InteractingLocker.InvokeSafely(ev);
private static bool Prefix(PlayerInteract __instance, int lockerId, int chamberNumber)
{
if (!__instance._playerInteractRateLimit.CanExecute(true) || (__instance._hc.CufferId > 0 && !PlayerInteract.CanDisarmedInteract))
{
return(false);
}
LockerManager singleton = LockerManager.singleton;
if (lockerId < 0 || lockerId >= singleton.lockers.Length)
{
return(false);
}
if (!__instance.ChckDis(singleton.lockers[lockerId].gameObject.position) || !singleton.lockers[lockerId].supportsStandarizedAnimation)
{
return(false);
}
if (chamberNumber < 0 || chamberNumber >= singleton.lockers[lockerId].chambers.Length)
{
return(false);
}
if (singleton.lockers[lockerId].chambers[chamberNumber].doorAnimator == null)
{
return(false);
}
if (!singleton.lockers[lockerId].chambers[chamberNumber].CooldownAtZero())
{
return(false);
}
singleton.lockers[lockerId].chambers[chamberNumber].SetCooldown();
string accessToken = singleton.lockers[lockerId].chambers[chamberNumber].accessToken;
Item itemByID = __instance._inv.GetItemByID(__instance._inv.curItem);
var ev = new InteractingLockerEventArgs(
API.Features.Player.Get(__instance.gameObject),
singleton.lockers[lockerId],
lockerId,
string.IsNullOrEmpty(accessToken) || (itemByID != null && itemByID.permissions.Contains(accessToken)) || __instance._sr.BypassMode);
Player.OnInteractingLocker(ev);
if (ev.IsAllowed)
{
bool flag = (singleton.openLockers[lockerId] & 1 << chamberNumber) != 1 << chamberNumber;
singleton.ModifyOpen(lockerId, chamberNumber, flag);
singleton.RpcDoSound(lockerId, chamberNumber, flag);
bool state = true;
for (int i = 0; i < singleton.lockers[lockerId].chambers.Length; i++)
{
if ((singleton.openLockers[lockerId] & 1 << i) == 1 << i)
{
state = false;
break;
}
}
singleton.lockers[lockerId].LockPickups(state);
if (!string.IsNullOrEmpty(accessToken))
{
singleton.RpcChangeMaterial(lockerId, chamberNumber, false);
}
}
else
{
singleton.RpcChangeMaterial(lockerId, chamberNumber, true);
}
__instance.OnInteract();
return(false);
}
