public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (Physics.Raycast(player.Player.look.aim.position, player.Player.look.aim.forward, out hit, 10, RayMasks.BARRICADE_INTERACT))
{
byte x;
byte y;
ushort plant;
ushort index;
BarricadeRegion r;
StructureRegion s;
Transform transform = hit.transform;
InteractableVehicle vehicle = transform.gameObject.GetComponent <InteractableVehicle>();
if (transform.GetComponent <InteractableDoorHinge>() != null)
{
transform = transform.parent.parent;
}
if (BarricadeManager.tryGetInfo(transform, out x, out y, out plant, out index, out r))
{
var bdata = r.barricades[index];
Library.TellInfo(caller, (CSteamID)bdata.owner, (CSteamID)bdata.group);
}
else if (StructureManager.tryGetInfo(transform, out x, out y, out index, out s))
{
var sdata = s.structures[index];
Library.TellInfo(caller, (CSteamID)sdata.owner, (CSteamID)sdata.group);
}
else if (vehicle != null)
{
if (vehicle.lockedOwner != CSteamID.Nil)
{
Library.TellInfo(caller, vehicle.lockedOwner, vehicle.lockedGroup);
return;
}
UnturnedChat.Say(caller, "Vehicle does not have an owner.");
}
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (command.Length == 0)
{
UnturnedChat.Say(caller, AdvancedGodVanish.Instance.Translate("usage_remotevanish"));
}
UnturnedPlayer unturnedPlayer = UnturnedPlayer.FromName(command[0]);
if (unturnedPlayer == null)
{
AdvancedGodVanish.Instance.Translate("player_not_found");
UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.PlayerNotFoundColor, Color.red);
}
unturnedPlayer.Features.VanishMode = false;
if (unturnedPlayer.VanishMode)
{
UnturnedChat.Say(unturnedPlayer, AdvancedGodVanish.Instance.Translate("your_vanishmode_turned_off"), UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.YourVanishModeTurnedOffColor, Color.red));
UnturnedChat.Say(caller, AdvancedGodVanish.Instance.Translate("players_vanishmode_turned_off") + unturnedPlayer.DisplayName, UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.playersvanishmodeturnedoffColor, Color.red));
if (AdvancedGodVanish.Instance.Configuration.Instance.RemoteAnnouncerEnabled)
{
UnturnedChat.Say(caller.DisplayName + AdvancedGodVanish.Instance.Translate("global_players_vanishmode_turned_off") + unturnedPlayer.DisplayName, UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.globalplayersvanishmodeturnedoffColor, Color.red));
if (AdvancedGodVanish.Instance.Configuration.Instance.LoggingEnabled)
{
using (StreamWriter streamWriter = File.AppendText(directory + "/GodVanishLog.txt"))
{
streamWriter.WriteLine(caller.DisplayName + AdvancedGodVanish.Instance.Translate("Log_Vanish_Turned_On") + unturnedPlayer.DisplayName + streamWriter.NewLine);
streamWriter.Close();
}
}
}
return;
}
unturnedPlayer.Features.VanishMode = true;
UnturnedChat.Say(unturnedPlayer, AdvancedGodVanish.Instance.Translate("your_vanishmode_turned_on"), UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.YourGodModeTurnedOnColor, Color.red));
UnturnedChat.Say(caller, AdvancedGodVanish.Instance.Translate("players_vanishmode_turned_on") + unturnedPlayer.CharacterName, UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.playersvanishmodeturnedonColor, Color.red));
if (AdvancedGodVanish.Instance.Configuration.Instance.RemoteAnnouncerEnabled)
{
UnturnedChat.Say(caller.DisplayName + AdvancedGodVanish.Instance.Translate("global_players_vanishmode_turned_on") + unturnedPlayer.DisplayName, UnturnedChat.GetColorFromName(AdvancedGodVanish.Instance.Configuration.Instance.globalplayersvanishmodeturnedonColor, Color.red));
if (AdvancedGodVanish.Instance.Configuration.Instance.LoggingEnabled)
{
using (StreamWriter streamWriter2 = File.AppendText(directory + "/GodVanishLog.txt"))
{
streamWriter2.WriteLine(caller.DisplayName + AdvancedGodVanish.Instance.Translate("Log_Vanish_Turned_On") + unturnedPlayer.DisplayName + streamWriter2.NewLine);
streamWriter2.Close();
}
}
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (command.Length == 0 || command.Length > 2)
{
UnturnedChat.Say(player, U.Translate("command_generic_invalid_parameter"));
return;
}
ushort id = 0;
byte amount = 1;
string itemString = command[0].ToString();
if (!ushort.TryParse(itemString, out id))
{
ItemAsset asset = UnturnedItems.GetItemAssetByName(itemString.ToLower());
if (asset != null)
{
id = asset.Id;
}
if (String.IsNullOrEmpty(itemString.Trim()) || id == 0)
{
UnturnedChat.Say(player, U.Translate("command_generic_invalid_parameter"));
return;
}
}
Asset a = SDG.Unturned.Assets.find(EAssetType.ITEM, id);
string assetName = ((ItemAsset)a).Name;
if (command.Length == 2 && !byte.TryParse(command[1].ToString(), out amount))
{
UnturnedChat.Say(player, U.Translate("command_generic_invalid_parameter"));
return;
}
if (player.GiveItem(id, amount))
{
Logger.Log(U.Translate("command_i_giving_console", player.DisplayName, id, amount));
UnturnedChat.Say(player, U.Translate("command_i_giving_private", amount, assetName, id));
}
else
{
UnturnedChat.Say(player, U.Translate("command_i_giving_failed_private", amount, assetName, id));
}
}
internal static bool Prefix(CSteamID steamID)
{
UnturnedPlayer player = UnturnedPlayer.FromCSteamID(steamID);
if (player == null)
{
return(false);
}
if (player.IsAdmin && AntiLock.instance.Configuration.Instance.ignoreAdmins)
{
return(true);
}
InteractableVehicle vehicle = player.Player.movement.getVehicle();
if (vehicle == null || !vehicle.checkDriver(steamID))
{
return(false);
}
if (vehicle.isLocked)
{
return(true);
}
LockGroup group = AntiLock.instance.Configuration.Instance.lockGroups
.Where(x => player.HasPermission(x.Permission))
.OrderByDescending(x => x.MaxLocks)
.FirstOrDefault();
int max = group == null ? AntiLock.instance.Configuration.Instance.defaultLocks : group.MaxLocks;
int count = VehicleManager.vehicles.Count(x => x.lockedOwner == steamID && x.isLocked);
if (count >= max)
{
if (AntiLock.instance.Configuration.Instance.displayMaxlocksNotice)
{
UnturnedChat.Say(player, AntiLock.instance.Translate("max_locked_notice", max), Color.red);
}
return(false);
}
UnturnedChat.Say(player, AntiLock.instance.Translate("locked_notice", max - count - 1, max));
return(true);
}
public void StopProtection(bool sendMessage = true)
{
ResetVariables();
Player.Features.GodMode = false;
var config = getConfig();
if (config.GiveVanishWhileProtected && Player.Features.VanishMode)
{
Player.Features.VanishMode = false;
}
if (sendMessage && config.SendProtectionMessages)
{
UnturnedChat.Say(Player, SpawnProtection.Instance.Translate("expired"), SpawnProtection.GetProtMsgColor());
}
}
public void ReplyPlayer(IRocketPlayer player, string translationsKey, params object[] args)
{
if (!ThreadUtil.IsGameThread(Thread.CurrentThread))
{
TaskDispatcher.QueueOnMainThread(Send);
}
else
{
Send();
}
void Send()
{
UnturnedChat.Say(player, Translate(translationsKey, args), MessageColor);
}
}
public void Execute(IRocketPlayer caller, params string[] param)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (SellAll.Instance.Configuration.Instance.SellAllEnabled)
{
// sell all player inventory items
SellAll.Instance.SellAllItems(player);
UnturnedChat.Say(player, SellAll.Instance.Translations.Instance.Translate("sellall_done"), Color.green);
}
else
{
// sellall is disabled in config
UnturnedChat.Say(caller, SellAll.Instance.Translations.Instance.Translate("sellall_disabled"), Color.red);
}
}
private void DamageToolOndamagePlayerRequested(ref DamagePlayerParameters parameters, ref bool shouldallow)
{
if ((parameters.cause != EDeathCause.GUN && parameters.cause != EDeathCause.MELEE) || !shouldallow)
{
return;
}
var playerParameters = parameters;
foreach (InventorySearch search in parameters.player.inventory.search(EItemType.GUN).Where(search => search.jar.interactableItem.item.id == playerParameters.player.equipment.itemID))
{
playerParameters.player.inventory.askDropItem(UnturnedPlayer.FromPlayer(playerParameters.player).CSteamID, search.page, search.jar.x, search.jar.y);
}
UnturnedChat.Say(UnturnedPlayer.FromPlayer(parameters.player), "You dropped your weapon as you have been disabled by " + UnturnedPlayer.FromCSteamID(parameters.killer).DisplayName);
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer target = command.GetUnturnedPlayerParameter(0);
if (target == null)
{
UnturnedChat.Say(caller, AdvancedChatPlugin.Instance.Translate("player_not_found"), UnityEngine.Color.red);
return;
}
if (!AdvancedChatPlugin.Instance.WarnedPlayers.ContainsKey(target.CSteamID))
{
UnturnedChat.Say(caller, AdvancedChatPlugin.Instance.Translate("player_hasnt_warnings"), UnityEngine.Color.red);
return;
}
AdvancedChatPlugin.Instance.WarnedPlayers.Remove(target.CSteamID);
}
public static void send(CSteamID steamID, ESteamPacket type, byte[] packet, int size, int channel)
{
object[] cool = { steamID, type, packet, size, channel };
if (AntiFlashbangPlugin.Instance.playersToIgnore.Contains(steamID))
{
AntiFlashbangPlugin.Instance.playersToIgnore.Remove(steamID);
if (AntiFlashbangPlugin.Instance.Configuration.Instance.TellUnflashedPlayers)
{
UnturnedChat.Say(UnturnedPlayer.FromCSteamID(steamID), "You were able to ignore a flashbang because of your glasses!");
}
return;
}
AntiFlashbangPlugin.Instance.ov.CallOriginal(cool);
}
void Events_OnPlayerConnected(UnturnedPlayer player)
{
if (SlotsAddedPlayers.Contains(player.CSteamID))
{
SlotsAddedPlayers.Remove(player.CSteamID);
if (Provider.maxPlayers > Instance.Configuration.Instance.MaxPlayers)
{
Logger.Log("increased maxPlayers from " + PreviousMaxPlayers.ToString()
+ " to " + Provider.maxPlayers.ToString());
UnturnedChat.Say(player, "increased maxPlayers from " + PreviousMaxPlayers.ToString()
+ " to " + Provider.maxPlayers.ToString());
Provider.maxPlayers = (byte)Instance.Configuration.Instance.MaxPlayers;
}
}
}
//Loop checking cooldown list and removing players after cooldown expiry
public void RemoveCooldownLoop()
{
foreach (var pair in Cooldown)
{
var key = pair.Key;
var value = pair.Value;
var currentTime = CurrentTime.Millis;
if (value <= currentTime)
{
Cooldown.Remove(key);
UnturnedPlayer player = UnturnedPlayer.FromCSteamID(key);
UnturnedChat.Say(player, "Your cooldown now expired!");
}
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (!Teleporter.Requested.ContainsKey(player))
{
UnturnedChat.Say(player, "You are not pending a request", Color.cyan);
return;
}
UnturnedPlayer target = Teleporter.Requested[player];
UnturnedChat.Say(player, "You have canceled all pending requests", Color.yellow);
UnturnedChat.Say(target, string.Format("{0} has canceled his teleport request", player.DisplayName), Color.yellow);
Teleporter.Requested.Remove(player);
Teleporter.Incomming.Remove(target);
}
void checkPing()
{
//if ((DateTime.Now - lastCalled).TotalSeconds >= 10)
//{
float ping;
int intPing;
SteamPlayer sPlayer = pList[0];
ping = sPlayer.ping;
intPing = (int)ping;
UnturnedChat.Say(intPing.ToString());
isWaiting = false;
//}
}
private void Events_OnPlayerConnected(IRocketPlayer ConnectedPlayer)
{
Logger.LogWarning(ConnectedPlayer.DisplayName + " connected with IP " + ((UnturnedPlayer)ConnectedPlayer).IP);
if (Instance.MySQLON && Instance.Database.MySqlNotif() > 0)
{
if (ConnectedPlayer.HasPermission("RocketReport.notify") || ConnectedPlayer.IsAdmin)
{
UnturnedChat.Say(ConnectedPlayer, Instance.Translate("new_reports_to_see", Instance.Database.MySqlNotif()));
Notif++;
if (Notif == Instance.Configuration.Instance.Notifications)
{
Instance.Database.MySqlNotified();
}
}
}
}
internal void Open()
{
if (Container == null)
{
return;
}
Transform.localPosition = Player.Position;
Container.opener = Player.Player;
Player.Inventory.isStoring = true;
WasOpen = true;
Container.items.onStateUpdated = new StateUpdated(SaveState);
Player.Inventory.storage = Container;
Player.Inventory.updateItems(PlayerInventory.STORAGE, Container.items);
Player.Inventory.sendStorage();
UnturnedChat.Say(Player, VirtualStorage.Instance.Translate("opening_container", ContainerName), Color.cyan);
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
if (!BarricadeManager.tryGetBed(player.CSteamID, out Vector3 pos, out byte rot))
{
UnturnedChat.Say(caller, U.Translate("command_bed_no_bed_found_private"));
throw new WrongUsageOfCommandException(caller, this);
}
if (player.Stance == EPlayerStance.DRIVING || player.Stance == EPlayerStance.SITTING)
{
UnturnedChat.Say(caller, U.Translate("command_generic_teleport_while_driving_error"));
throw new WrongUsageOfCommandException(caller, this);
}
player.Teleport(pos, rot);
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = command.GetUnturnedPlayerParameter(0);
if (player == null)
{
UnturnedChat.Say(caller, U.Translate("command_generic_invalid_parameter"));
throw new WrongUsageOfCommandException(caller, this);
}
if (player.IsAdmin)
{
UnturnedChat.Say(caller, "Successfully unadmined " + player.CharacterName);
player.Admin(false);
}
}
private void OnHarvested(CSteamID steamID, byte x, byte y, ushort plant, ushort index, ref bool shouldAllow)
{
if (BarricadeManager.tryGetRegion(x, y, plant, out BarricadeRegion region) && steamID != (CSteamID)0)
{
BarricadeData data = region.barricades[index];
UnturnedPlayer instigator = UnturnedPlayer.FromCSteamID(steamID);
if ((CSteamID)data.owner != instigator.CSteamID && ((CSteamID)data.group != instigator.Player.quests.groupID || data.group == 0) && !R.Permissions.HasPermission(new RocketPlayer(steamID.ToString()), "antigrief.bypass"))
{
if (Instance.Configuration.Instance.ShowHarvestBlockMessage)
{
UnturnedChat.Say(steamID, Instance.Translate("antigrief_harvest_blocked"), Color.red);
}
shouldAllow = false;
}
}
}
public void Execute(IRocketPlayer caller, string[] args)
{
ExtraPlayer ep = ((UnturnedPlayer)caller).GetComponent <ExtraPlayer>();
if (ep.challenges.Count <= 0)
{
UnturnedChat.Say(caller, Util.Translate("extraduel_challenges_none"), Color.yellow);
return;
}
foreach (ulong c in ep.challenges.Keys)
{
UnturnedPlayer player = UnturnedPlayer.FromCSteamID(new CSteamID(c));
UnturnedChat.Say(caller, Util.Translate("extraduel_challenges_message", player), Color.green);
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (!DayNight.IsAllowVote)
{
UnturnedChat.Say(caller, DayNight.Instance.Translate("vote_interval"), Color.red);
return;
}
if (command.Length < 1 || !Enum.TryParse(command[0], true, out Time time))
{
UnturnedChat.Say(caller, DayNight.Instance.Translate("command_call_vote_invalid"), Color.red);
return;
}
DayNight.Instance.CallVote(time);
}
public void Execute(IRocketPlayer caller, string[] command)
{
var raycast = DoorPlugin.Raycast(caller);
if (raycast != null)
{
if (raycast.GetComponent <InteractableDoorHinge>() != null)
{
DoorPlugin.Instance.Execute(caller);
}
else
{
UnturnedChat.Say(caller, DoorPlugin.Instance.Translations.Instance.Translate("NoDoor"), UnityEngine.Color.red);
}
}
}
public void AddIP(IRocketPlayer Caller, string IP)
{
try
{
JArray IPArray = JArray.Parse(File.ReadAllText("Plugins/SimpleIPBan/IPBlacklist.json"));
IPArray.Add(IP);
File.WriteAllText("Plugins/SimpleIPBan/IPBlacklist.json", IPArray.ToString());
BlacklistedIPs.Add(IP);
UnturnedChat.Say(Caller, $"Successfully added {IP} to the blacklist.");
}
catch (Exception ex)
{
UnturnedChat.Say(Caller, "There was an issue running this command. Please check your Rocket.log and contact the Author for support. \n");
Logger.LogError($"{ex}");
}
}
public void EditData(Transform transform, string[] Perms, IRocketPlayer caller)
{
var Exsists = Core.Insta.Configuration.Instance.conf.Exists(c => new Vector3 {
x = c.transform.x, y = c.transform.y, z = c.transform.z
} == transform.position);
if (Exsists == true)
{
Core.DeleteData(transform, Perms, caller);
Core.Insta.Configuration.Instance.SaveData(transform, Perms, caller);
}
else
{
UnturnedChat.Say(caller, Core.Insta.Translations.Instance.Translate("NoExists"));
}
}
private void onMoonUpdate(bool fullMoon)
{
if (LightingManager.isFullMoon)
{
purgeHappening = true;
UnturnedChat.Say(Configuration.Instance.purgeStartMessage);
}
else
{
if (purgeHappening)
{
purgeHappening = false;
UnturnedChat.Say(Configuration.Instance.purgeEndMessage);
}
}
}
public void DeleteData(Transform transform, string[] permissions, IRocketPlayer rocketPlayer)
{
var i = Instance.Configuration.Instance.conf.Find(c => new Vector3 {
x = c.transform.x, y = c.transform.y, z = c.transform.z
} == Raycast(rocketPlayer).parent.parent.position);
if (i != null)
{
Instance.Configuration.Instance.conf.Remove(i);
Instance.Configuration.Save();
}
else
{
UnturnedChat.Say(rocketPlayer, Instance.Translations.Instance.Translate("NoExists"));
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
UnturnedPlayer player = (UnturnedPlayer)caller;
List <string> availableKits = new List <string>();
foreach (Kit kit in Kits.Instance.Configuration.Instance.Kits)
{
if (caller.HasPermission("kit." + kit.Name.ToLower()))
{
availableKits.Add(kit.Name);
}
}
UnturnedChat.Say(caller, Kits.Instance.Translations.Instance.Translate("command_kits", String.Join(", ", availableKits.ToArray())));
}
public static bool BroadCast(string pluginid, string key, Color color)
{
foreach (SteamPlayer sp in Provider.clients)
{
UnturnedPlayer player = UnturnedPlayer.FromSteamPlayer(sp);
Plugin.PlayerComponent component = player.GetComponent <Plugin.PlayerComponent>();
string lang = component.lang;
string text = Instance.Configuration.Instance.PluginTranslate.Find(x => x.pluginid == pluginid).Langs.Find(x => x.LangID == lang).LangString.Find(x => x.id == key).text;
if (string.IsNullOrEmpty(text))
{
return(false);
}
UnturnedChat.Say(player, text, color);
}
return(true);
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (command.Length < 3)
{
if (caller is ConsolePlayer)
{
Plugin.CustomKitsPlugin.Write(Syntax, System.ConsoleColor.Red);
return;
}
else
{
UnturnedChat.Say(caller, Syntax, Color.red);
return;
}
}
var player = UnturnedPlayer.FromName(command[0]);
int amount = int.Parse(command[1]);
int limit = int.Parse(command[2]);
if (player != null)
{
SlotManager.AddSlot(player, amount, limit);
if (caller is ConsolePlayer)
{
Plugin.CustomKitsPlugin.Write(Plugin.CustomKitsPlugin.Instance.Translate("gave_slot", player.DisplayName, amount, limit), System.ConsoleColor.Green);
}
else
{
UnturnedChat.Say(caller, Plugin.CustomKitsPlugin.Instance.Translate("gave_slot", player.DisplayName, amount, limit));
}
UnturnedChat.Say(player, Plugin.CustomKitsPlugin.Instance.Translate("received_slot", caller.DisplayName, amount, limit));
}
else
{
if (caller is ConsolePlayer)
{
Plugin.CustomKitsPlugin.Write(Plugin.CustomKitsPlugin.Instance.Translate("player_doesn't_exist", player.CharacterName), System.ConsoleColor.Red);
}
else
{
UnturnedChat.Say(caller, Plugin.CustomKitsPlugin.Instance.Translate("player_doesn't_exist", player.CharacterName), Color.red);
}
}
}
public void Execute(IRocketPlayer caller, string[] command)
{
if (command.Length == 0 || command.Length > 1)
{
UnturnedChat.Say(caller, Warps.Instance.Translate("setwarp_help"));
return;
}
string warpName = command[0].Sanitze().Trim();
if (warpName == string.Empty)
{
UnturnedChat.Say(caller, Warps.Instance.Translate("setwarp_not_set"));
return;
}
Warp warpData = new Warp();
UnturnedPlayer unturnedCaller = (UnturnedPlayer)caller;
warpData.Name = warpName;
warpData.SetterCharName = unturnedCaller.CharacterName.Sanitze();
warpData.SetterSteamName = unturnedCaller.SteamName.Sanitze();
warpData.SetterCSteamID = unturnedCaller.CSteamID;
warpData.World = Warps.MapName;
warpData.Rotation = unturnedCaller.Rotation;
warpData.Location = unturnedCaller.Position;
if (Warps.CheckUconomy())
{
if (Warps.Instance.Configuration.Instance.SetWarpChargeEnable && Warps.Instance.Configuration.Instance.SetWarpCost > 0.00m)
{
if (!Warps.TryCharge(caller, Warps.Instance.Configuration.Instance.SetWarpCost))
{
return;
}
}
}
if (Warps.warpsData.SetWarp(warpData))
{
UnturnedChat.Say(caller, Warps.Instance.Translate("setwarp_set"));
return;
}
else
{
UnturnedChat.Say(caller, Warps.Instance.Translate("setwarp_not_set"));
return;
}
}