public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
switch (args.Length)
{
case 1:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
DropKit(src, args[0], src.ToPlayer().Position);
EssLang.Send(src, "DROPKIT_SENDER", args[0]);
break;
case 2:
if (!src.HasPermission($"{Permission}.other"))
{
return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
}
if (!UPlayer.TryGet(args[1].ToString(), out var player))
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[1]));
}
DropKit(src, args[0], player.Position);
EssLang.Send(src, "DROPKIT_PLAYER", args[0], player.DisplayName);
break;
case 4:
var pos = args.GetVector3(1);
if (pos.HasValue)
{
DropKit(src, args[0], pos.Value);
EssLang.Send(src, "DROPKIT_LOCATION", args[1], args[2], args[3]);
}
else
{
return(CommandResult.LangError("INVALID_COORDS", args[1], args[2], args[3]));
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private void HandleCost(CommandPosExecuteEvent e, CommandOptions.CommandEntry commandOptions)
{
// Make sure it has an EconomyProvider and check if the player can bypass the cost
if (!UEssentials.EconomyProvider.IsPresent || e.Source.HasPermission("essentials.bypass.commandcost"))
{
return;
}
var commandCost = GetCommandCost(commandOptions, e.Source.ToPlayer());
if (commandCost > 0)
{
UEssentials.EconomyProvider.Value.Withdraw(e.Source.ToPlayer(), commandCost);
EssLang.Send(e.Source, "COMMAND_PAID", commandCost, UEssentials.EconomyProvider.Value.CurrencySymbol);
}
}
private void HomePlayerMove(UnturnedPlayer player, Vector3 newPosition)
{
if (!UEssentials.Config.Home.CancelTeleportWhenMove || !CommandHome.Delay.ContainsKey(player.CSteamID.m_SteamID))
{
return;
}
CommandHome.Delay[player.CSteamID.m_SteamID].Cancel();
CommandHome.Delay.Remove(player.CSteamID.m_SteamID);
UPlayer.TryGet(player, p =>
{
EssLang.Send(p, "TELEPORT_CANCELLED_MOVED");
});
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var playerId = player.CSteamId;
if (player.Stance == EPlayerStance.DRIVING ||
player.Stance == EPlayerStance.SITTING)
{
return(CommandResult.LangError("CANNOT_TELEPORT_DRIVING"));
}
if (!BarricadeManager.tryGetBed(player.CSteamId, out var bedPosition, out var bedAngle))
{
return(CommandResult.LangError("WITHOUT_BED"));
}
if (Delay.ContainsKey(player.CSteamId.m_SteamID))
{
return(CommandResult.LangError("ALREADY_WAITING"));
}
var homeCommand = UEssentials.Config.Home;
var delay = homeCommand.TeleportDelay;
if (player.HasPermission("essentials.bypass.homecooldown"))
{
delay = 0;
}
if (delay > 0)
{
EssLang.Send(src, "TELEPORT_DELAY", TimeUtil.FormatSeconds((uint)delay));
}
var task = Task.Create()
.Delay(TimeSpan.FromSeconds(delay))
.Action(t => {
Delay.Remove(playerId.m_SteamID);
bedPosition.y += .5f;
player.UnturnedPlayer.teleportToLocation(bedPosition, MeasurementTool.byteToAngle(bedAngle));
EssLang.Send(src, "TELEPORTED_BED");
})
.Submit();
Delay.Add(playerId.m_SteamID, task);
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (!player.Metadata.Has("back_pos"))
{
return(CommandResult.Lang("NOT_DIED_YET"));
}
var backPosition = player.Metadata.Get <Vector3>("back_pos");
src.ToPlayer().Teleport(backPosition);
EssLang.Send(src, "RETURNED");
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (!player.HasMetadata(Consts.BACK_METADATA_KEY))
{
return(CommandResult.Lang("NOT_DIED_YET"));
}
var backPosition = player.GetMetadata <Vector3>(Consts.BACK_METADATA_KEY);
src.ToPlayer().Teleport(backPosition);
EssLang.Send(src, "RETURNED");
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (args.Length == 0 || args.Length > 1)
{
return(CommandResult.ShowUsage());
}
if (!WarpModule.Instance.WarpManager.Contains(args[0].ToString()))
{
return(CommandResult.Lang("WARP_NOT_EXIST", args[0]));
}
if (!player.HasPermission($"essentials.warp.{args[0]}"))
{
return(CommandResult.Lang("WARP_NO_PERMISSION", args[0]));
}
if (player.RocketPlayer.Stance == EPlayerStance.DRIVING ||
player.RocketPlayer.Stance == EPlayerStance.SITTING)
{
return(CommandResult.Lang("CANNOT_TELEPORT_DRIVING"));
}
var dest = WarpModule.Instance.WarpManager.GetByName(args[0].ToString());
var cooldown = UEssentials.Config.Warp.TeleportDelay;
if (cooldown > 0 && !player.HasPermission("essentials.bypass.warpcooldown"))
{
EssLang.Send(src, "WARP_COOLDOWN", cooldown);
}
var task = Task.Create()
.Id($"Warp teleport '{player.DisplayName}'")
.Delay(player.HasPermission("essentials.bypass.warpcooldown") ? 0 : cooldown * 1000)
.Action(t => {
Delay.Remove(player.CSteamId.m_SteamID);
player.Teleport(dest.Location, dest.Rotation);
EssLang.Send(src, "WARP_TELEPORTED", args[0]);
})
.Submit();
Delay.Add(player.CSteamId.m_SteamID, task);
return(CommandResult.Success());
}
/// <summary>
/// Start the poll
/// </summary>
public void Start()
{
EssLang.Broadcast("POLL_STARTED", Name, Description);
var thiz = this;
lock (Polls) Polls.Add(Name, thiz);
if (Duration > 0)
{
Tasks.New(task => {
lock (Polls) {
if (!Polls.ContainsKey(thiz.Name))
{
return;
}
thiz.Stop();
}
}).Delay(Duration * 1000).Go();
}
if (!UEssentials.Config.EnablePollRunningMessage)
{
return;
}
var interval = UEssentials.Config.PollRunningMessageCooldown * 1000;
Tasks.New(task => {
lock (Polls) {
if (!Polls.ContainsKey(thiz.Name))
{
task.Cancel();
return;
}
EssLang.Broadcast(
"POLL_RUNNING",
thiz.Name,
thiz.Description,
thiz.YesVotes,
thiz.NoVotes
);
}
}).Interval(interval).Delay(interval).Go();
}
private void OnCommandPreExecuted(CommandPreExecuteEvent e)
{
if (e.Source.IsConsole || e.Source.HasPermission("essentials.bypass.commandcost"))
{
return;
}
if (_cachedEconomyProvider == null)
{
_cachedEconomyProvider = UEssentials.EconomyProvider;
}
if (_cachedEconomyProvider.IsAbsent)
{
/*
* If economy hook is not present, this "handler" will be unregistered.
*/
EssCore.Instance.EventManager.Unregister(GetType(), nameof(OnCommandPreExecuted));
EssCore.Instance.EventManager.Unregister(GetType(), nameof(OnCommandPosExecuted));
}
var commands = EssCore.Instance.CommandsConfig.Commands;
if (!commands.ContainsKey(e.Command.Name))
{
return;
}
var cost = commands[e.Command.Name].Cost;
if (cost <= 0)
{
return;
}
/*
* Check if player has sufficient money to use this command.
*/
if (_cachedEconomyProvider.Value.Has(e.Source.ToPlayer(), cost))
{
return;
}
EssLang.Send(e.Source, "COMMAND_NO_MONEY", cost, _cachedEconomyProvider.Value.Currency);
e.Cancelled = true;
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
GiveMaxSkills(src.ToPlayer(), false);
}
else
{
if (args.Length < 2 && src.IsConsole)
{
return(CommandResult.ShowUsage());
}
if (!args[0].IsBool)
{
return(CommandResult.Lang("INVALID_BOOLEAN", args[0]));
}
if (args.Length == 2 && !src.HasPermission(Permission + ".other"))
{
return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
}
var overpower = args[0].ToBool;
var targetPlayer = args.Length == 2 ? args[1].ToPlayer : src.ToPlayer();
if (targetPlayer == null)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[1]));
}
GiveMaxSkills(targetPlayer, overpower);
if (src.IsConsole || src.ToPlayer() != targetPlayer)
{
EssLang.Send(src, "MAX_SKILLS_TARGET", targetPlayer.DisplayName);
}
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var playerId = player.CSteamId;
Vector3 position;
byte angle;
if (player.RocketPlayer.Stance == EPlayerStance.DRIVING ||
player.RocketPlayer.Stance == EPlayerStance.SITTING)
{
return(CommandResult.Lang("CANNOT_TELEPORT_DRIVING"));
}
if (!BarricadeManager.tryGetBed(player.CSteamId, out position, out angle))
{
return(CommandResult.Lang("WITHOUT_BED"));
}
var homeCommand = UEssentials.Config.Home;
var delay = homeCommand.TeleportDelay;
if (player.HasPermission("essentials.bypass.homecooldown"))
{
delay = 0;
}
if (delay > 0)
{
EssLang.Send(src, "TELEPORT_DELAY", TimeUtil.FormatSeconds((uint)delay));
}
var task = Task.Create()
.Delay(TimeSpan.FromSeconds(delay))
.Action(t => {
Delay.Remove(playerId.m_SteamID);
player.Teleport(position, angle);
EssLang.Send(src, "TELEPORTED_BED");
})
.Submit();
Delay.Add(playerId.m_SteamID, task);
return(CommandResult.Success());
}
private CommandResult SpyCommand(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var playerId = player.CSteamId.m_SteamID;
if (Spies.Contains(playerId))
{
Spies.Remove(playerId);
EssLang.Send(src, "SPY_MODE_OFF");
}
else
{
Spies.Add(playerId);
EssLang.Send(src, "SPY_MODE_ON");
}
return(CommandResult.Success());
}
public static void DropKit(ICommandSource src, ICommandArgument kitArg, Vector3 pos)
{
var kitManager = KitModule.Instance.KitManager;
var kitName = kitArg.ToString();
if (!kitManager.Contains(kitName))
{
EssLang.Send(src, "KIT_NOT_EXIST", kitName);
}
else
{
var kitItems = kitManager.GetByName(kitName).Items;
kitItems.Where(i => i is KitItem).Cast <KitItem>().ForEach(i =>
ItemManager.dropItem(i.UnturnedItem, pos, true, true, true)
);
}
}
private CommandResult RefuelGeneratorCommand(ICommandSource src, ICommandArgs args)
{
float radius = 20;
float percentage = 100;
if (args.Length > 0)
{
if (!args[0].IsFloat)
{
return(CommandResult.Lang("INVALID_NUMBER", args[0]));
}
if ((radius = args[0].ToFloat) <= 0)
{
return(CommandResult.Lang("MUST_POSITIVE"));
}
}
if (args.Length > 1)
{
if (!args[1].IsFloat)
{
return(CommandResult.Lang("INVALID_NUMBER", args[1]));
}
if (!args[1].IsInRange(0, 100))
{
return(CommandResult.Lang("NUMBER_BETWEEN", 0, 100));
}
percentage = args[1].ToFloat / 100;
}
var count = 0;
var player = src.ToPlayer();
var rayResult = Physics.SphereCastAll(player.Position, radius, Vector3.forward, RayMasks.BARRICADE);
rayResult
.Select(r => r.transform.GetComponent <InteractableGenerator>())
.Where(r => r != null)
.ForEach(r => {
BarricadeManager.sendFuel(r.transform, (ushort)Math.Floor(r.capacity * percentage));
count++;
});
EssLang.Send(player, "REFUEL_GENERATOR_REFUELED", count);
return(CommandResult.Success());
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo(UPlayer player)
{
var sentInventoryFullMessage = false;
foreach (var kitItem in Items)
{
var added = kitItem.GiveTo(player);
if (added || sentInventoryFullMessage)
{
continue;
}
EssLang.Send(player, "INVENTORY_FULL");
sentInventoryFullMessage = true;
}
EssLang.Send(player, "KIT_GIVEN_RECEIVER", Name);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var currentVeh = src.ToPlayer().CurrentVehicle;
if (currentVeh != null)
{
VehicleManager.sendVehicleHealth(currentVeh, currentVeh.asset.health);
EssLang.Send(src, "VEHICLE_REPAIRED");
}
else
{
return(CommandResult.Lang("NOT_IN_VEHICLE"));
}
}
else if (args[0].Equals("all"))
{
if (!src.HasPermission($"{Permission}.all"))
{
return(CommandResult.NoPermission($"{Permission}.all"));
}
lock (UWorld.Vehicles) {
UWorld.Vehicles
.WhereNot(veh => veh.isExploded || veh.isUnderwater)
.ToList()
.ForEach(vehicle => {
VehicleManager.sendVehicleHealth(vehicle, vehicle.asset.health);
});
EssLang.Send(src, "VEHICLE_REPAIRED_ALL");
}
}
return(CommandResult.Success());
}
/// <summary>
/// Give this kit to player
/// </summary>
public void GiveTo(UPlayer player)
{
var onetime = false;
foreach (var kitItem in Items)
{
var added = kitItem.GiveTo(player);
if (added || onetime)
{
continue;
}
EssLang.Send(player, "INVENTORY_FULL"); // TODO: Remove msgs
onetime = true;
}
EssLang.Send(player, "KIT_GIVEN_RECEIVER", Name);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var warps = (
from warp in WarpModule.Instance.WarpManager.Warps
where warp.CanUse(src)
select warp.Name
).ToArray();
if (warps.Length == 0)
{
EssLang.Send(src, "WARP_NONE");
}
else
{
EssLang.Send(src, "WARP_LIST", string.Join(", ", warps));
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
var km = KitModule.Instance.KitManager;
if (!km.Contains(args[0].ToString()))
{
return(CommandResult.Lang("KIT_NOT_EXIST", args[0]));
}
km.Remove(km.GetByName(args[0].ToString()));
EssLang.Send(src, "DELETED_KIT", args[0]);
return(CommandResult.Success());
}
private void OnCommandPreExecuted(CommandPreExecuteEvent e)
{
var commandName = e.Command.Name.ToLowerInvariant();
if (
e.Source.IsConsole ||
!EssCore.Instance.CommandOptions.Commands.TryGetValue(commandName, out var commandOptions)
)
{
return;
}
// Check cooldown
if (!e.Source.HasPermission("essentials.bypass.commandcooldown"))
{
var playerId = e.Source.ToPlayer().CSteamId.m_SteamID;
if (
CommandCooldowns.ContainsKey(playerId) &&
CommandCooldowns[playerId].TryGetValue(commandName, out var nextUse) &&
nextUse > DateTime.Now
)
{
var diffSec = (uint)(nextUse - DateTime.Now).TotalSeconds;
EssLang.Send(e.Source, "COMMAND_COOLDOWN", TimeUtil.FormatSeconds(diffSec));
e.Cancelled = true;
return;
}
}
// Check if player has money enough to run this command
if (UEssentials.EconomyProvider.IsPresent && !e.Source.HasPermission("essentials.bypass.commandcost"))
{
var cost = GetCommandCost(commandOptions, e.Source.ToPlayer());
var ecoProvider = UEssentials.EconomyProvider.Value;
if (cost > 0 && !ecoProvider.Has(e.Source.ToPlayer(), cost))
{
EssLang.Send(e.Source, "COMMAND_NO_MONEY", cost, ecoProvider.CurrencySymbol);
e.Cancelled = true;
}
}
}
private void DeathMessages(UnturnedPlayer player, EDeathCause cause, ELimb limb, CSteamID killer)
{
if (!(EssLang.GetEntry($"DEATH_{cause}") is string message))
{
return;
}
var hasKiller = killer != CSteamID.Nil;
var arguments = new object[hasKiller ? 3 : 2];
var color = ColorUtil.GetColorFromString(ref message);
arguments[0] = player.CharacterName;
arguments[1] = EssLang.Translate($"LIMB_{limb}") ?? "?";
if (hasKiller)
{
arguments[2] = UPlayer.From(killer)?.CharacterName ?? "?";
}
UServer.Broadcast(string.Format(message, arguments), color);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var players = new List <UPlayer>(UServer.Players);
if (players.Count == 0)
{
return(CommandResult.Lang("NO_PLAYERS_FOR_KICK"));
}
var reason = args.IsEmpty
? EssLang.Translate("KICK_NO_SPECIFIED_REASON")
: args.Join(0);
players.ForEach(player => {
player.Kick(reason);
});
EssLang.Send(src, "KICKED_ALL", players.Count);
return(CommandResult.Success());
}
private CommandResult RespawnVehiclesCommand(ICommandSource src, ICommandArgs args)
{
var spawns = LevelVehicles.spawns;
foreach (var vehicleSpawnpoint in spawns)
{
var vehicleId = LevelVehicles.getVehicle(vehicleSpawnpoint);
if (vehicleId == 0)
{
continue;
}
var point = vehicleSpawnpoint.point;
point.y += 1f;
VehicleManager.spawnVehicle(vehicleId, point, Quaternion.Euler(0f, vehicleSpawnpoint.angle, 0f));
}
EssLang.Send(src, "RESPAWNED_VEHICLES");
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args[0].Is("*"))
{
UServer.Players.ForEach(p => p.Kill());
EssLang.Send(src, "KILL_ALL");
return(CommandResult.Success());
}
if (!args[0].IsValidPlayerName)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
var target = args[0].ToPlayer;
target.Kill();
EssLang.Send(src, "KILL_PLAYER", target.DisplayName);
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length < 2)
{
return(CommandResult.ShowUsage());
}
string name;
if (args[0].Equals(name = "*console*"))
{
CommandWindow.input.onInputText(args.Join(1));
}
else if (args[0].Equals("*"))
{
UServer.Players.ForEach(p => {
ChatManager.instance.askChat(p.CSteamId, (byte)EChatMode.GLOBAL, args.Join(1));
});
name = "Everyone";
}
else
{
if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
var targetPlayer = args[0].ToPlayer;
ChatManager.instance.askChat(targetPlayer.CSteamId, (byte)EChatMode.GLOBAL, args.Join(1));
name = targetPlayer.CharacterName;
}
EssLang.Send(src, "SUDO_EXECUTED", name, args.Join(1));
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var currentVeh = src.ToPlayer().CurrentVehicle;
if (currentVeh != null)
{
RefuelVehicle(currentVeh);
EssLang.Send(src, "VEHICLE_REFUELED");
}
else
{
return(CommandResult.Lang("NOT_IN_VEHICLE"));
}
}
else if (args[0].Is("all"))
{
if (!src.HasPermission($"{Permission}.all"))
{
return(CommandResult.NoPermission($"{Permission}.all"));
}
lock (UWorld.Vehicles) {
UWorld.Vehicles
.WhereNot(veh => veh.isExploded || veh.isUnderwater)
.ForEach(RefuelVehicle);
EssLang.Send(src, "VEHICLE_REFUELED_ALL");
}
}
return(CommandResult.Success());
}
private void GiveExp(UPlayer player, int amount)
{
var playerExp = player.UnturnedPlayer.skills.experience;
if (amount < 0)
{
if ((playerExp - amount) < 0)
{
playerExp = 0;
}
else
{
playerExp += (uint)amount;
}
}
else
{
if ((playerExp + amount) > int.MaxValue)
{
playerExp = int.MaxValue;
}
else
{
playerExp += (uint)amount;
}
}
if (amount >= 0)
{
EssLang.Send(player, "EXPERIENCE_RECEIVED", amount);
}
else
{
EssLang.Send(player, "EXPERIENCE_LOST", -amount);
}
player.Experience = playerExp;
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var look = player.Look;
if (PhysicsUtility.raycast(new Ray(look.aim.position, look.aim.forward), out RaycastHit hit, Mathf.Infinity, RayMasks.BARRICADE))
{
InteractableDoorHinge hinge = hit.transform.GetComponent <InteractableDoorHinge>();
if (hinge != null)
{
InteractableDoor door = hinge.door;
bool open = !door.isOpen;
BarricadeManager.tryGetInfo(door.transform, out byte x, out byte y, out ushort plant, out ushort index, out BarricadeRegion region);
BarricadeManager manager = (BarricadeManager)typeof(BarricadeManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
door.updateToggle(open);
manager.channel.send("tellToggleDoor", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
plant,
index,
open
});
EssLang.Send(src, "DOOR_TOGGLED", open ? "opened" : "closed");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("DOOR_INVALID"));
}
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (args[0].ToString() == "third")
{
player.Look.setPerspective(SDG.Unturned.EPlayerPerspective.THIRD);
EssLang.Send(src, "PERSPECTIVE_THIRD");
return(CommandResult.Success());
}
else if (args[0].ToString() == "first")
{
player.Look.setPerspective(SDG.Unturned.EPlayerPerspective.FIRST);
EssLang.Send(src, "PERSPECTIVE_FIRST");
return(CommandResult.Success());
}
else
{
return(CommandResult.ShowUsage());
}
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var count = 0;
UWorld.Zombies.Where(z => z.isDead).ForEach(zombie => {
ZombieManager.sendZombieAlive(
zombie,
zombie.type,
(byte)zombie.speciality,
zombie.shirt,
zombie.pants,
zombie.hat,
zombie.gear,
zombie.transform.position,
0
);
count++;
});
EssLang.Send(src, "RESPAWNED_ZOMBIES", count);
return(CommandResult.Success());
}
