private void OnHandcuffing(HandcuffingEventArgs ev)
{
if (ev.Cuffer == _player && _player.Role != _config.Role)
{
ev.IsAllowed = false;
}
}
public async void OnHandcuffing(HandcuffingEventArgs ev)
{
if (Instance.Config.EventsToLog.HandcuffingPlayer && ((!ev.Cuffer.DoNotTrack && !ev.Target.DoNotTrack) || !Instance.Config.ShouldRespectDoNotTrack))
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.HasBeenHandcuffedBy, ev.Target.Nickname, Instance.Config.ShouldLogUserIds ? ev.Target.UserId : Language.Redacted, ev.Target.Role, ev.Cuffer.Nickname, Instance.Config.ShouldLogUserIds ? ev.Cuffer.UserId : Language.Redacted, ev.Cuffer.Role))).ConfigureAwait(false);
}
}
public void onDetain(HandcuffingEventArgs ev)
{
if (EventHandlers.scp343.Contains(ev.Target))
{
ev.IsAllowed = false;
ev.Cuffer.Broadcast(3, "You cannot cuff <color=red>SCP-343</color>", 0);
}
}
public void OnHandcuff(HandcuffingEventArgs ev)
{
if (!pCuffedDict.ContainsKey(ev.Cuffer))
{
pCuffedDict.Add(ev.Cuffer, ev.Target);
}
else
{
pCuffedDict[ev.Cuffer] = ev.Target;
}
}
public void OnHandcuffing(HandcuffingEventArgs ev)
{
if (SimpleCuffProtection.DisallowUncuffing && Handcuffs.ContainsKey(ev.Cuffer))
{
Handcuffs[ev.Cuffer] = ev.Target;
}
else if (SimpleCuffProtection.DisallowUncuffing)
{
Handcuffs.Add(ev.Cuffer, ev.Target);
}
}
public async void OnHandcuffing(HandcuffingEventArgs ev)
{
if (ev.IsAllowed)
{
await _privateWebhook.ExecuteWebhook(
$"{ev.Cuffer.Nickname} ({ev.Cuffer.UserId}) is handcuffing {ev.Target.Nickname} ({ev.Target.UserId})!",
"SCP-Bot",
false
);
}
}
internal void Handcuffing(HandcuffingEventArgs ev)
{
if (Plugin.Instance.Config.Handcuffing == "")
{
return;
}
string message = Plugin.Instance.Config.Handcuffing.Replace("%player%", ev.Target.ToString());
message = message.Replace("%team%", ev.Target.Team.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 void OnCuffEvent(HandcuffingEventArgs ev)
{
RoleType source = ev.Cuffer.Role;
RoleType target = ev.Target.Role;
if (
source == _ntfRole && target == RoleType.ClassD ||
source == _chaosRole && target == RoleType.Scientist
)
{
//Allowed to do cuffing
Timing.RunCoroutine(RandomPlayerRespawn(ev.Target));
string color = ev.Cuffer.Role == _chaosRole ? "green" : "blue";
AnnounceUnthawing(ev.Cuffer, ev.Target, color, color);
}
else
{
ev.IsAllowed = false;
ev.Cuffer.ShowHint("You cannot cuff that person! Bad!");
}
}
/// <summary> /// Invoked before handcuffing a player. /// </summary> /// <param name="ev">The <see cref="HandcuffingEventArgs"/> instance.</param> public static void OnHandcuffing(HandcuffingEventArgs ev) => Handcuffing.InvokeSafely(ev);
public static bool Prefix(NetworkConnection conn, DisarmMessage msg)
{
try
{
if (!DisarmingHandlers.ServerCheckCooldown(conn) || !ReferenceHub.TryGetHub(conn.identity.gameObject, out ReferenceHub hub))
{
return(false);
}
if (!msg.PlayerIsNull)
{
Vector3 vector3 = msg.PlayerToDisarm.transform.position - hub.transform.position;
if (vector3.sqrMagnitude > 20.0 || (msg.PlayerToDisarm.inventory.CurInstance is not null && msg.PlayerToDisarm.inventory.CurInstance.TierFlags != ItemTierFlags.Common))
{
return(false);
}
}
bool flag1 = !msg.PlayerIsNull && msg.PlayerToDisarm.inventory.IsDisarmed();
bool flag2 = !msg.PlayerIsNull && hub.CanDisarm(msg.PlayerToDisarm);
if (flag1 && !msg.Disarm)
{
if (!hub.inventory.IsDisarmed())
{
var ev = new RemovingHandcuffsEventArgs(API.Features.Player.Get(hub), API.Features.Player.Get(msg.PlayerToDisarm));
Player.OnRemovingHandcuffs(ev);
if (!ev.IsAllowed)
{
return(false);
}
msg.PlayerToDisarm.inventory.SetDisarmedStatus(null);
}
}
else if (!flag1 & flag2 && msg.Disarm)
{
if (msg.PlayerToDisarm.inventory.CurInstance is null || msg.PlayerToDisarm.inventory.CurInstance.CanHolster())
{
if (msg.PlayerToDisarm.characterClassManager.CurRole.team == Team.MTF && hub.characterClassManager.CurClass == RoleType.ClassD)
{
AchievementHandlerBase.ServerAchieve(hub.networkIdentity.connectionToClient, AchievementName.TablesHaveTurned);
}
var ev = new HandcuffingEventArgs(API.Features.Player.Get(hub), API.Features.Player.Get(msg.PlayerToDisarm));
Player.OnHandcuffing(ev);
if (!ev.IsAllowed)
{
return(false);
}
msg.PlayerToDisarm.inventory.SetDisarmedStatus(hub.inventory);
}
}
else
{
hub.networkIdentity.connectionToClient.Send <DisarmedPlayersListMessage>(DisarmingHandlers.NewDisarmedList, 0);
return(false);
}
DisarmingHandlers.NewDisarmedList.SendToAuthenticated <DisarmedPlayersListMessage>();
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.RemovingHandcuffs: {e}\n{e.StackTrace}");
return(true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OwnerHandcuffingEventArgs"/> class.
/// </summary>
/// <param name="item"><inheritdoc cref="Item"/></param>
/// <param name="ev">The <see cref="HandcuffingEventArgs"/> instance.</param>
public OwnerHandcuffingEventArgs(Item item, HandcuffingEventArgs ev)
: this(item, ev.Cuffer, ev.Target, ev.IsAllowed)
{
}
private static bool Prefix(Handcuffs __instance, GameObject target)
{
try
{
if (!__instance._interactRateLimit.CanExecute() || target == null ||
Vector3.Distance(target.transform.position, __instance.transform.position) >
__instance.raycastDistance * 1.10000002384186)
{
return(false);
}
Handcuffs handcuffs = ReferenceHub.GetHub(target).handcuffs;
if (handcuffs == null || __instance.MyReferenceHub.inventory.curItem != ItemType.Disarmer ||
(__instance.MyReferenceHub.characterClassManager.CurClass < RoleType.Scp173 ||
handcuffs.CufferId >= 0) || handcuffs.MyReferenceHub.inventory.curItem != ItemType.None)
{
return(false);
}
Team team1 = __instance.MyReferenceHub.characterClassManager.Classes
.SafeGet(__instance.MyReferenceHub.characterClassManager.CurClass).team;
Team team2 = __instance.MyReferenceHub.characterClassManager.Classes
.SafeGet(handcuffs.MyReferenceHub.characterClassManager.CurClass).team;
bool flag = false;
switch (team1)
{
case Team.MTF:
if (team2 == Team.CHI || team2 == Team.CDP)
{
flag = true;
}
if (team2 == Team.RSC && ConfigFile.ServerConfig.GetBool("mtf_can_cuff_researchers"))
{
flag = true;
}
break;
case Team.CHI:
if (team2 == Team.MTF || team2 == Team.RSC)
{
flag = true;
}
if (team2 == Team.CDP && ConfigFile.ServerConfig.GetBool("ci_can_cuff_class_d"))
{
flag = true;
}
break;
case Team.RSC:
if (team2 == Team.CHI || team2 == Team.CDP)
{
flag = true;
}
break;
case Team.CDP:
if (team2 == Team.MTF || team2 == Team.RSC)
{
flag = true;
}
break;
}
if (!flag)
{
return(false);
}
__instance.ClearTarget();
var ev = new HandcuffingEventArgs(API.Features.Player.Get(__instance.gameObject), API.Features.Player.Get(target));
Player.OnHandcuffing(ev);
if (!ev.IsAllowed)
{
return(false);
}
handcuffs.NetworkCufferId = __instance.MyReferenceHub.queryProcessor.PlayerId;
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.Handcuffing: {e}\n{e.StackTrace}");
return(true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OwnerHandcuffingEventArgs"/> class.
/// </summary>
/// <param name="item"><inheritdoc cref="Item"/></param>
/// <param name="ev">The <see cref="HandcuffingEventArgs"/> instance.</param>
public OwnerHandcuffingEventArgs(Inventory.SyncItemInfo item, HandcuffingEventArgs ev)
: this(item, ev.Cuffer, ev.Target, ev.IsAllowed)
{
}
