/// <inheritdoc cref="Events.Handlers.Server.OnSendingRemoteAdminCommand"/>
public void OnRemoteAdminCommand(SendingRemoteAdminCommandEventArgs ev)
{
if (ev.Name.ToLower() == "gban-kick" && ev.Sender.ReferenceHub.queryProcessor._sender.ServerRoles.RaEverywhere)
{
if (!(Player.Get(string.Join(" ", ev.Arguments)) is Player player))
{
return;
}
if (!CustomItem.TryGet(player, out IEnumerable <CustomItem> customItems))
{
return;
}
StringBuilder builder = StringBuilderPool.Shared.Rent();
foreach (CustomItem item in customItems)
{
if (item.ShouldMessageOnGban)
{
builder.Append(item.Name).Append(" - ").Append(item.Description).AppendLine();
}
}
string itemNames = StringBuilderPool.Shared.ToStringReturn(builder);
if (!string.IsNullOrEmpty(itemNames))
{
ev.Sender.SendConsoleMessage(
$"{player.Nickname} has been globally banned while in possession of the following items: {itemNames}\n" +
"Note: The creator(s) of these items have specifically flagged these items as doing something that may cause suspicion of hacking.",
"red");
}
}
}
/// <summary>
/// Tries to add an item to the player's inventory by name.
/// </summary>
/// <param name="player">The <see cref="Player"/> to try giving the item to.</param>
/// <param name="itemName">The name of the item to try adding.</param>
/// <returns>Whether or not the item was able to be added.</returns>
protected bool TryAddItem(Player player, string itemName)
{
if (CustomItem.TryGet(itemName, out CustomItem customItem))
{
customItem.Give(player);
return(true);
}
if (Enum.TryParse(itemName, out ItemType type))
{
if (type.IsAmmo())
{
player.Ammo[type] = 100;
}
else
{
player.AddItem(type);
}
return(true);
}
Log.Warn($"{Name}: {nameof(TryAddItem)}: {itemName} is not a valid ItemType or Custom Item name.");
return(false);
}
/// <summary>
/// Adds a converted item to a player's inventory.
/// </summary>
/// <param name="player">The player to add the converted item to.</param>
public void Convert(Player player)
{
if (ConvertedItems == null || ConvertedItems.Count == 0)
{
return;
}
string itemName = ConvertedItems.ElementAt(Exiled.Loader.Loader.Random.Next(ConvertedItems.Count));
if (CustomItem.TryGet(itemName, out CustomItem customItem))
{
customItem.Give(player);
return;
}
if (Enum.TryParse(itemName, true, out ItemType result))
{
if (!result.IsAmmo())
{
player.AddItem(result);
return;
}
player.Ammo[result] += AmountToAdd.TryGetValue(result.GetAmmoType(), out ushort amount) ? amount : (ushort)50;
}
}
/// <inheritdoc cref="ChangingRoleEventArgs"/>
public void OnChangingRole(ChangingRoleEventArgs ev)
{
if (ev.NewRole == RoleType.Spectator)
{
foreach (Player player in Player.List)
{
if (player == ev.Player)
{
continue;
}
if (CustomItem.TryGet(player, out CustomItem item))
{
if (item.ShouldMessageOnGban)
{
ev.Player.SendFakeSyncVar(player.ReferenceHub.networkIdentity, typeof(NicknameSync), nameof(NicknameSync.Network_displayName), $"{player.Nickname} (CustomItem: {item.Name})");
}
}
}
}
else
{
foreach (Player player in Player.List)
{
if (player == ev.Player || player.ReferenceHub.nicknameSync.Network_displayName is null)
{
continue;
}
ev.Player.SendFakeSyncVar(player.ReferenceHub.networkIdentity, typeof(NicknameSync), nameof(NicknameSync.Network_displayName), player.DisplayNickname);
}
}
}
/// <inheritdoc />
protected override void RoleAdded(Player player)
{
player.UnitName = "Scp035";
Timing.CallDelayed(1.5f, () =>
{
player.ChangeAppearance(VisibleRole);
player.ChangeWalkingSpeed(MovementMultiplier);
player.ChangeRunningSpeed(MovementMultiplier);
player.IsGodModeEnabled = false;
});
player.Scale = Scale;
DissonanceUserSetup dissonance = player.GameObject.GetComponent <DissonanceUserSetup>();
dissonance.EnableListening(TriggerType.Role, Assets._Scripts.Dissonance.RoleType.SCP);
dissonance.EnableSpeaking(TriggerType.Role, Assets._Scripts.Dissonance.RoleType.SCP);
dissonance.SCPChat = true;
foreach (Item item in player.Items.ToList())
{
if (CustomItem.TryGet(item, out CustomItem customItem))
{
customItem.Spawn(player.Position, item);
player.RemoveItem(item);
}
}
player.DropItems();
Timing.RunCoroutine(Appearance(player), $"{player.UserId}-appearance");
Timing.RunCoroutine(Corrosion(player), $"{player.UserId}-corrosion");
base.RoleAdded(player);
}
/// <inheritdoc/>
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("customitems.spawn"))
{
response = "Permission Denied, required: customitems.spawn";
return(false);
}
if (arguments.Count < 2)
{
response = "spawn [Custom item name] [Location name]\nspawn [Custom item name] [Nickname/PlayerID/UserID]\nspawn [Custom item name] [X] [Y] [Z]";
return(false);
}
if (!CustomItem.TryGet(arguments.At(0), out CustomItem item))
{
response = $" {arguments.At(0)} is not a valid custom item.";
return(false);
}
Vector3 position;
if (Enum.TryParse(arguments.At(1), out SpawnLocation location))
{
position = location.GetPosition();
}
else if (Player.Get(arguments.At(1)) is Player player)
{
if (player.IsDead)
{
response = $"Cannot spawn custom items under dead players!";
return(false);
}
position = player.Position;
}
else if (arguments.Count > 3)
{
if (!float.TryParse(arguments.At(1), out float x) || !float.TryParse(arguments.At(2), out float y) || !float.TryParse(arguments.At(3), out float z))
{
response = "Invalid coordinates selected.";
return(false);
}
position = new Vector3(x, y, z);
}
else
{
response = $"Unable to find spawn location: {arguments.At(1)}.";
return(false);
}
item.Spawn(position);
response = $"{item.Name} ({item.Type}) has been spawned at {position}.";
return(true);
}
private static bool Prefix(FragGrenade __instance, Pickup item)
{
if (!CustomItem.TryGet(item, out CustomItem customItem) || !(customItem is CustomGrenade customGrenade))
{
return(true);
}
item.Delete();
customGrenade.Spawn(item.position, Vector3.zero, customGrenade.FuseTime, customGrenade.Type);
return(false);
}
/// <inheritdoc/>
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("customitems.give"))
{
response = "Permission Denied, required: customitems.give";
return(false);
}
if (arguments.Count < 2)
{
response = "give [Custom item name/Custom item ID] [Nickname/PlayerID/UserID/all/*]";
return(false);
}
if (!CustomItem.TryGet(arguments.At(0), out CustomItem item))
{
response = $"Custom item {arguments.At(0)} not found!";
return(false);
}
string identifier = string.Join(" ", arguments.Skip(1));
switch (identifier)
{
case "*":
case "all":
var eligiblePlayers = Player.List.Where(CheckEligible).ToList();
foreach (var ply in eligiblePlayers)
{
item.Give(ply);
}
response = $"Custom item {item.Name} given to all players who can receive them ({eligiblePlayers.Count} players)";
return(true);
default:
if (!(Player.Get(identifier) is Player player))
{
response = $"Unable to find player: {identifier}.";
return(false);
}
if (!CheckEligible(player))
{
response = "Player cannot receive custom items!";
return(false);
}
item.Give(player);
response = $"{item.Name} given to {player.Nickname} ({player.UserId})";
return(true);
}
}
/// <inheritdoc/>
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("customitems.info"))
{
response = "Permission Denied, required: customitems.info";
return(false);
}
if (arguments.Count < 1)
{
response = "info [Custom item name/Custom item ID]";
return(false);
}
if (!(int.TryParse(arguments.At(0), out int id) && CustomItem.TryGet(id, out CustomItem item)) &&
!CustomItem.TryGet(arguments.At(0), out item))
{
response = $"{arguments.At(0)} is not a valid custom item.";
return(false);
}
StringBuilder message = StringBuilderPool.Shared.Rent().AppendLine();
message.Append("<color=#E6AC00>-</color> <color=#00D639>").Append(item.Name).Append("</color> <color=#05C4EB>(").Append(item.Id).AppendLine(")</color>")
.Append("- ").AppendLine(item.Description)
.AppendLine(item.Type.ToString())
.Append("- Spawn Limit: ").AppendLine(item.SpawnProperties.Limit.ToString()).AppendLine()
.Append("[Spawn Locations (").Append(item.SpawnProperties.DynamicSpawnPoints.Count + item.SpawnProperties.StaticSpawnPoints.Count).AppendLine(")]");
foreach (DynamicSpawnPoint spawnPoint in item.SpawnProperties.DynamicSpawnPoints)
{
message.Append(spawnPoint.Name).Append(' ').Append(spawnPoint.Position).Append(" Chance: ").Append(spawnPoint.Chance).AppendLine("%");
}
foreach (StaticSpawnPoint spawnPoint in item.SpawnProperties.StaticSpawnPoints)
{
message.Append(spawnPoint.Name).Append(' ').Append(spawnPoint.Position).Append(" Chance: ").Append(spawnPoint.Chance).AppendLine("%");
}
response = StringBuilderPool.Shared.ToStringReturn(message);
return(true);
}
/// <summary>
/// Resets the player's inventory to the provided list of items and/or customitems names, clearing any items it already possess.
/// </summary>
/// <param name="player">The player to which items will be given.</param>
/// <param name="newItems">The new items that have to be added to the inventory.</param>
/// <param name="displayMessage">Indicates a value whether <see cref="CustomItem.ShowPickedUpMessage"/> will be called when the player receives the <see cref="CustomItem"/> or not.</param>
public static void ResetInventory(this Player player, List <string> newItems, bool displayMessage = false)
{
foreach (Item item in player.Items)
{
if (CustomItem.TryGet(item, out CustomItem customItem))
{
customItem.TrackedSerials.Remove(item.Serial);
}
}
player.ClearInventory();
foreach (string item in newItems)
{
if (Enum.TryParse(item, true, out ItemType parsedItem))
{
player.AddItem(parsedItem);
}
else if (!CustomItem.TryGive(player, item, displayMessage))
{
Log.Debug($"\"{item}\" is not a valid item name, nor a custom item name.", CustomItems.Instance.Config.Debug);
}
}
}
internal void ParseInventorySettings()
{
foreach (PropertyInfo configSetting in GetType().GetProperties())
{
Log.Debug($"Name: {configSetting.Name}");
if (!configSetting.Name.Contains("Inventory"))
{
continue;
}
string configName = configSetting.Name;
Dictionary <string, List <string> > dict = (Dictionary <string, List <string> >)configSetting.GetValue(this);
RoleType role = RoleType.None;
switch (configName)
{
case nameof(ClassDInventory):
role = RoleType.ClassD;
break;
case nameof(ChaosInventory):
role = RoleType.ChaosInsurgency;
break;
case nameof(ScientistInventory):
role = RoleType.Scientist;
break;
case nameof(GuardInventory):
role = RoleType.FacilityGuard;
break;
case nameof(CadetInventory):
role = RoleType.NtfCadet;
break;
case nameof(LieutenantInventory):
role = RoleType.NtfLieutenant;
break;
case nameof(CommanderInventory):
role = RoleType.NtfCommander;
break;
case nameof(NtfSciInventory):
role = RoleType.NtfScientist;
break;
}
if (role == RoleType.None)
{
Log.Error("Role is none - This should never happen.");
continue;
}
if (dict == null || dict.All(l => l.Value == null))
{
Log.Warn($"{nameof(ParseInventorySettings)}: The dictionary for {configName} is empty, they will have default inventory.");
if (Inventories.ContainsKey(role))
{
Inventories.Remove(role);
}
continue;
}
foreach (KeyValuePair <string, List <string> > unparsedDict in dict)
{
string slotName = unparsedDict.Key;
List <string> list = unparsedDict.Value;
if (list == null)
{
Log.Debug($"{nameof(ParseInventorySettings)}: The list for {configName}:{slotName} is empty.");
continue;
}
foreach (string unparsedRaw in list)
{
ItemType item;
if (unparsedRaw == "empty")
{
Log.Debug($"{nameof(ParseInventorySettings)}: {role} inventory has been set to \"empty\", they will spawn with no items.", Debug);
if (!Inventories.ContainsKey(role))
{
Inventories.Add(role, new Dictionary <string, List <Tuple <ItemType, int> > > {
{ slotName, new List <Tuple <ItemType, int> >() }
});
}
continue;
}
string[] rawChance = unparsedRaw.Split(':');
if (!int.TryParse(rawChance[1], out int chance))
{
Log.Error(
$"{nameof(ParseInventorySettings)}: Unable to parse item chance {rawChance[0]} for {rawChance[0]} in {configName} inventory settings.");
continue;
}
if (CustomItem.TryGet(rawChance[0], out CustomItem customItem))
{
Log.Debug($"{nameof(ParseInventorySettings)}: {rawChance[0]} is a custom item, adding to dictionary..", Debug);
if (!CustomInventories.ContainsKey(role))
{
CustomInventories.Add(role, new Dictionary <string, List <Tuple <CustomItem, int> > >
{
{ "slot1", new List <Tuple <CustomItem, int> >() }, { "slot2", new List <Tuple <CustomItem, int> >() }, { "slot3", new List <Tuple <CustomItem, int> >() }, { "slot4", new List <Tuple <CustomItem, int> >() }, { "slot5", new List <Tuple <CustomItem, int> >() }, { "slot6", new List <Tuple <CustomItem, int> >() }, { "slot7", new List <Tuple <CustomItem, int> >() }, { "slot8", new List <Tuple <CustomItem, int> >() },
});
}
CustomInventories[role][slotName].Add(new Tuple <CustomItem, int>(customItem, chance));
continue;
}
try
{
item = (ItemType)Enum.Parse(typeof(ItemType), rawChance[0], true);
}
catch (Exception)
{
Log.Error($"{nameof(ParseInventorySettings)}: Unable to parse item: {rawChance[0]} in {configName} inventory settings.");
continue;
}
Log.Debug($"{nameof(ParseInventorySettings)}: {item} was added to {configName} inventory with {chance} chance.", Debug);
if (!Inventories.ContainsKey(role))
{
Inventories.Add(role, new Dictionary <string, List <Tuple <ItemType, int> > >
{
{ "slot1", new List <Tuple <ItemType, int> >() }, { "slot2", new List <Tuple <ItemType, int> >() }, { "slot3", new List <Tuple <ItemType, int> >() }, { "slot4", new List <Tuple <ItemType, int> >() }, { "slot5", new List <Tuple <ItemType, int> >() }, { "slot6", new List <Tuple <ItemType, int> >() }, { "slot7", new List <Tuple <ItemType, int> >() }, { "slot8", new List <Tuple <ItemType, int> >() }
});
}
Inventories[role][slotName].Add(new Tuple <ItemType, int>(item, chance));
}
}
}
}
/// <inheritdoc/>
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
Player player = Player.Get((sender as PlayerCommandSender)?.ReferenceHub);
if (player == null || Plugin.BlacklistedIds.Contains(player.Id) || player.SessionVariables.ContainsKey("IsGhostSpectator"))
{
response = string.Empty;
return(false);
}
Inventory.SyncItemInfo item = player.CurrentItem;
if (item == default)
{
response = "Sorry, but you can't throw air. yet.";
return(false);
}
player.ReferenceHub.weaponManager.scp268.ServerDisable();
if (CustomItem.TryGet(item, out CustomItem customItem))
{
Pickup p = item.Spawn(player.Position);
player.Inventory.items.Remove(item);
player.ReferenceHub.weaponManager.NetworkcurWeapon = -1;
player.ReferenceHub.inventory.RefreshWeapon();
player.ReferenceHub.inventory.UpdateUniqChange();
if (p.itemId == ItemType.MicroHID)
{
var scale = player.Scale;
Timing.CallDelayed(0.5f, () =>
{
player.Scale = new Vector3(scale.x, scale.y * 0.99f, scale.z);
player.Scale = scale;
});
}
customItem.Spawned.Add(p);
Timing.RunCoroutine(ThrowWhenRigidbody(player, p, (player.CameraTransform.forward + AddLaunchForce).normalized));
response = "custom yeet";
return(true);
}
Pickup pickup = player.Inventory.SetPickup(item.id, item.durability, player.Position, player.Inventory.camera.transform.rotation, item.modSight, item.modBarrel, item.modOther);
player.Inventory.items.Remove(item);
player.ReferenceHub.weaponManager.NetworkcurWeapon = -1;
player.ReferenceHub.inventory.RefreshWeapon();
player.ReferenceHub.inventory.UpdateUniqChange();
if (pickup.itemId == ItemType.MicroHID)
{
var scale = player.Scale;
Timing.CallDelayed(0.5f, () =>
{
player.Scale = new Vector3(scale.x, scale.y * 0.99f, scale.z);
player.Scale = scale;
});
}
Timing.RunCoroutine(ThrowWhenRigidbody(player, pickup, (player.CameraTransform.forward + AddLaunchForce).normalized));
response = "yeet";
return(true);
}
public async void OnHurting(HurtingEventArgs ev)
{
// Verifico si el tipo tiene un medigun primero, y si no paso al log normal.
if (Instance.Config.EventsToLog.HurtingPlayer &&
ev.Attacker != null &&
ev.Target != null &&
(!ev.Attacker.DoNotTrack || !ev.Target.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack) &&
(!Instance.Config.ShouldLogFriendlyFireDamageOnly || (Instance.Config.ShouldLogFriendlyFireDamageOnly && ev.Attacker.Side == ev.Target.Side && ev.Attacker != ev.Target)) && CustomItem.TryGet(ev.Attacker.CurrentItem, out CustomItem medigun) && medigun.CheckMediGun())
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", $"<a:MediGun:841062245349720094> | **{ev.Attacker.Nickname}** (ID: {ev.Attacker.Id} - ROL: {ev.Attacker.Role.Translate()}) **esta curando** a **{ev.Target.Nickname}** (ID: {ev.Target.Id} ROL: {ev.Target.Role.Translate()} Con su arma que es {DamageTypes.FromIndex(ev.Tool).name} | Curacion hecha: {ev.Amount}")).ConfigureAwait(false);
}
else if (Instance.Config.EventsToLog.HurtingPlayer &&
ev.Attacker != null &&
ev.Target != null &&
(!ev.Attacker.DoNotTrack || !ev.Target.DoNotTrack || !Instance.Config.ShouldRespectDoNotTrack) &&
(!Instance.Config.ShouldLogFriendlyFireDamageOnly || (Instance.Config.ShouldLogFriendlyFireDamageOnly && ev.Attacker.Side == ev.Target.Side && ev.Attacker != ev.Target)))
{
await Network.SendAsync(new RemoteCommand("log", "gameEvents", string.Format(Language.HasDamagedForWith, ev.Attacker.Nickname, Instance.Config.ShouldLogUserIds ? ev.Attacker.Id.ToString() : Language.Redacted, ev.Attacker.Role.Translate(), ev.Target.Nickname, ev.Target.Id.ToString(), ev.Target.Role.Translate(), ev.Amount, DamageTypes.FromIndex(ev.Tool).name))).ConfigureAwait(false);
}
else
{
return;
}
}
private bool CheckItem(Pickup pickup)
{
return(CustomItem.TryGet(pickup, out CustomItem customItem) && BlacklistedItems.Contains(customItem.Name) ||
BlacklistedItems.Contains(pickup.Type.ToString()));
}