private CommandResult PositionCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
if (args.Length == 0)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var p = src.ToPlayer();
EssLang.Send(src, "POSITION", p.Position.x, p.Position.y, p.Position.z);
}
else
{
if (!src.HasPermission($"{cmd.Permission}.other"))
{
return(CommandResult.NoPermission($"{cmd.Permission}.other"));
}
if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
var p = args[0].ToPlayer;
EssLang.Send(src, "POSITION_OTHER", p.DisplayName, p.Position.x, p.Position.y, p.Position.z);
}
return(CommandResult.Success());
}
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]));
}
var overpower = args[0].ToBool;
// player or all
if (args.Length > 1)
{
if (args[1].Equals("*"))
{
if (!src.HasPermission($"{Permission}.all"))
{
return(CommandResult.NoPermission($"{Permission}.all"));
}
UServer.Players.ForEach(p => GiveMaxSkills(p, overpower));
EssLang.Send(src, "MAX_SKILLS_ALL");
}
else
{
if (!src.HasPermission($"{Permission}.other"))
{
return(CommandResult.NoPermission($"{Permission}.other"));
}
if (!args[1].IsValidPlayerIdentifier)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[1]));
}
var targetPlayer = args[1].ToPlayer;
GiveMaxSkills(targetPlayer, overpower);
EssLang.Send(src, "MAX_SKILLS_TARGET", targetPlayer.DisplayName);
}
}
else // self (with overpower)
{
GiveMaxSkills(src.ToPlayer(), overpower);
}
}
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
{
playerExp += (uint)amount;
}
if (amount >= 0)
{
EssLang.Send(player, "EXPERIENCE_RECEIVED", amount);
}
else
{
EssLang.Send(player, "EXPERIENCE_LOST", -amount);
}
player.Experience = playerExp;
}
private CommandResult RespawnItemsCommand(ICommandSource src, ICommandArgs args)
{
for (byte x = 0; x < Regions.WORLD_SIZE; x++)
{
for (byte y = 0; y < Regions.WORLD_SIZE; y++)
{
var itemsCount = LevelItems.spawns[x, y].Count;
if (itemsCount <= 0)
{
continue;
}
for (var i = 0; i < itemsCount; i++)
{
var itemSpawnpoint = LevelItems.spawns[x, y][i];
var itemId = LevelItems.getItem(itemSpawnpoint);
if (itemId == 0)
{
continue;
}
var item = new Item(itemId, true);
ItemManager.dropItem(item, itemSpawnpoint.point, false, false, false);
}
}
}
EssLang.Send(src, "RESPAWNED_ITEMS");
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args[0].Equals("*"))
{
UServer.Players
.Where(player => !player.HasComponent <FrozenPlayer>())
.ForEach(player => {
player.AddComponent <FrozenPlayer>();
EssLang.Send(player, "FROZEN_PLAYER", src.DisplayName);
});
EssLang.Send(src, "FROZEN_ALL");
}
else
{
if (!UPlayer.TryGet(args[0].ToString(), out var player))
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
if (player.HasComponent <FrozenPlayer>())
{
EssLang.Send(src, "ALREADY_FROZEN", player.DisplayName);
}
else
{
player.AddComponent <FrozenPlayer>();
EssLang.Send(src, "FROZEN_SENDER", player.DisplayName);
EssLang.Send(player, "FROZEN_PLAYER", src.DisplayName);
}
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource source, ICommandArgs parameters)
{
var kitConfig = EssCore.Instance.Config.Kit;
var hasEconomyProvider = UEssentials.EconomyProvider.IsPresent;
var kits = KitModule.Instance.KitManager.Kits.Where(k => k.CanUse(source)).Select(k => {
if (!hasEconomyProvider || !kitConfig.ShowCost || (k.Cost <= 0 && !kitConfig.ShowCostIfZero))
{
return(k.Name);
}
return(string.Format(kitConfig.CostFormat, k.Name, k.Cost, UEssentials.EconomyProvider.Value.Currency));
}).ToList();
if (kits.Count == 0)
{
EssLang.Send(source, "KIT_NONE");
}
else
{
EssLang.Send(source, "KIT_LIST", string.Join(", ", kits.ToArray()));
}
return(CommandResult.Success());
}
private void OnCommandPosExecuted(CommandPosExecuteEvent e)
{
if (_cachedEconomyProvider == null ||
e.Source.IsConsole || e.Source.HasPermission("essentials.bypass.commandcost"))
{
return;
}
var commands = EssCore.Instance.CommandsConfig.Commands;
/*
* He will not charge if command was not successfully executed.
*/
if (e.Result?.Type != CommandResult.ResultType.SUCCESS ||
!commands.ContainsKey(e.Command.Name))
{
return;
}
var cost = commands[e.Command.Name].Cost;
if (cost <= 0)
{
return;
}
_cachedEconomyProvider.Value.Withdraw(e.Source.ToPlayer(), cost);
EssLang.Send(e.Source, "COMMAND_PAID", cost);
}
private CommandResult ShutdownCommand(ICommandSource src, ICommandArgs args)
{
int delay = 0;
if (args.Length > 0)
{
if (!args[0].IsInt)
{
return(CommandResult.Lang("INVALID_NUMBER", args[0]));
}
else if ((delay = args[0].ToInt) < 0)
{
delay = 0;
}
}
// Will only send the messages if delay > 0
if (delay > 0)
{
if (args.Length > 1)
{
UServer.Broadcast(args.Join(1)); // Broadcast <reason>
}
EssLang.Send(src, "SHUTDOWN_DELAY_SENDER", TimeUtil.FormatSeconds((uint)delay));
}
Provider.shutdown(delay);
return(CommandResult.Success());
}
private void ClearInventory(UPlayer player)
{
var playerInv = player.Inventory;
// "Remove "models" of items from player "body""
player.Channel.send("tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER,
(byte)0, (byte)0, EMPTY_BYTE_ARRAY);
player.Channel.send("tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER,
(byte)1, (byte)0, EMPTY_BYTE_ARRAY);
// Remove items
for (byte page = 0; page < PlayerInventory.PAGES; page++)
{
if (page == PlayerInventory.AREA)
{
continue;
}
var count = playerInv.getItemCount(page);
for (byte index = 0; index < count; index++)
{
playerInv.removeItem(page, 0);
}
}
// Remove clothes
// Remove unequipped cloths
System.Action removeUnequipped = () => {
for (byte i = 0; i < playerInv.getItemCount(2); i++)
{
playerInv.removeItem(2, 0);
}
};
// Unequip & remove from inventory
player.UnturnedPlayer.clothing.askWearBackpack(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearGlasses(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearHat(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearPants(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearMask(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearShirt(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
player.UnturnedPlayer.clothing.askWearVest(0, 0, EMPTY_BYTE_ARRAY, true);
removeUnequipped();
EssLang.Send(player, "INVENTORY_CLEARED");
}
private CommandResult PositionCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
if (args.Length == 0)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var player = src.ToPlayer();
EssLang.Send(player,
"POSITION",
player.Position.x,
player.Position.y,
player.Position.z);
}
else
{
var found = UPlayer.TryGet(args[0], p => {
EssLang.Send(src, "POSITION_OTHER", p.DisplayName, p.Position.x, p.Position.y, p.Position.z);
});
if (!found)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
}
return(CommandResult.Success());
}
public override void Execute(ICommandContext context)
{
if (args[0].Equals("*"))
{
foreach (var player in UServer.Players.Where(player => player.HasComponent <FrozenPlayer>()))
{
player.RemoveComponent <FrozenPlayer>();
EssLang.Send(player, "UNFROZEN_PLAYER", src.DisplayName);
}
context.User.SendLocalizedMessage(Translations, "UNFROZEN_ALL");
}
else if (args[0].IsValidPlayerIdentifier)
{
var target = args[0].ToPlayer;
if (!target.HasComponent <FrozenPlayer>())
{
return(CommandResult.LangError("NOT_FROZEN", target.DisplayName));
}
target.RemoveComponent <FrozenPlayer>();
context.User.SendLocalizedMessage(Translations, "UNFROZEN_SENDER", target.DisplayName);
EssLang.Send(target, "UNFROZEN_PLAYER", src.DisplayName);
}
else
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (args[0].ToString() == "on")
{
player.Look.sendFreecamAllowed(true);
player.Look.sendSpecStatsAllowed(true);
EssLang.Send(src, "FREECAM_ON");
return(CommandResult.Success());
}
else if (args[0].ToString() == "off")
{
player.Look.sendFreecamAllowed(false);
player.Look.sendSpecStatsAllowed(false);
EssLang.Send(src, "FREECAM_OFF");
return(CommandResult.Success());
}
else
{
return(CommandResult.ShowUsage());
}
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args[0].Equals("*"))
{
foreach (var player in UServer.Players.Where(player => player.HasComponent <FrozenPlayer>()))
{
player.RemoveComponent <FrozenPlayer>();
EssLang.Send(player, "UNFROZEN_PLAYER", src.DisplayName);
}
EssLang.Send(src, "UNFROZEN_ALL");
}
else if (args[0].IsValidPlayerIdentifier)
{
var target = args[0].ToPlayer;
if (!target.HasComponent <FrozenPlayer>())
{
return(CommandResult.Lang("NOT_FROZEN", target.DisplayName));
}
target.RemoveComponent <FrozenPlayer>();
EssLang.Send(src, "UNFROZEN_SENDER", target.DisplayName);
EssLang.Send(target, "UNFROZEN_PLAYER", src.DisplayName);
}
else
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
return(CommandResult.Success());
}
private void OnPlayerChatted(UnturnedPlayer player, ref Color c, string message,
EChatMode m, ref bool cancel)
{
if (
!UEssentials.Config.AntiSpam.Enabled ||
message.StartsWith("/") ||
player.HasPermission("essentials.bypass.antispam")
)
{
return;
}
const string METADATA_KEY = "last_chatted";
var uplayer = UPlayer.From(player);
if (!uplayer.Metadata.Has(METADATA_KEY))
{
uplayer.Metadata[METADATA_KEY] = DateTime.Now;
return;
}
var interval = UEssentials.Config.AntiSpam.Interval;
if ((DateTime.Now - uplayer.Metadata.Get <DateTime>(METADATA_KEY)).TotalSeconds < interval)
{
EssLang.Send(uplayer, "CHAT_ANTI_SPAM");
cancel = true;
return;
}
uplayer.Metadata[METADATA_KEY] = DateTime.Now;
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty || args.Length > 1)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
EssLang.Send(src, "PING", src.ToPlayer().Ping);
}
else
{
var target = args[0].ToPlayer;
if (target == null)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
EssLang.Send(src, "PING_OTHER", target.DisplayName, target.Ping);
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var message = args[1].ToString();
var url = args[2].ToString();
if (args[0].Equals("*"))
{
UServer.Players.ForEach(p => {
p.UnturnedPlayer.sendBrowserRequest(message, url);
});
EssLang.Send(src, "REQUEST_URL_SUCCESS", EssLang.Translate("EVERYONE"), url);
}
else if (args[0].IsValidPlayerIdentifier)
{
var target = args[0].ToPlayer;
target.UnturnedPlayer.sendBrowserRequest(message, url);
EssLang.Send(src, "REQUEST_URL_SUCCESS", target.DisplayName, url);
}
else
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var dist = 1000f;
if (args.Length == 1)
{
if (!args[0].IsDouble)
{
return(CommandResult.ShowUsage());
}
dist = (float)args[0].ToDouble;
}
var eyePos = player.GetEyePosition(dist);
if (!eyePos.HasValue)
{
return(CommandResult.Lang("JUMP_NO_POSITION"));
}
var point = eyePos.Value;
point.y += 6;
player.Teleport(point);
EssLang.Send(src, "JUMPED", point.x, point.y, point.z);
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty || args.Length > 1)
{
return(CommandResult.ShowUsage());
}
try {
var steamId = new CSteamID(ulong.Parse(args[0].ToString()));
if (!steamId.IsValid())
{
return(CommandResult.LangError("INVALID_STEAMID", steamId.m_SteamID));
}
ResetPlayer(steamId.m_SteamID);
EssLang.Send(src, "PLAYER_RESET");
} catch (FormatException) {
var target = args[0].ToPlayer;
if (target == null)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
target.Kick(EssLang.Translate("PLAYER_RESET_KICK"));
ResetPlayer(target.CSteamId.m_SteamID);
EssLang.Send(src, "PLAYER_RESET");
}
return(CommandResult.Success());
}
private void OnPlayerChatted(UnturnedPlayer player, ref Color color, string message,
EChatMode mode, ref bool cancel)
{
if (!UEssentials.Config.AntiSpam.Enabled || message.StartsWith("/") ||
player.HasPermission("essentials.bypass.antispam"))
{
return;
}
var playerId = player.CSteamID.m_SteamID;
if (!LastChatted.ContainsKey(playerId))
{
LastChatted.Add(playerId, DateTime.Now);
return;
}
var interval = UEssentials.Config.AntiSpam.Interval;
if ((DateTime.Now - LastChatted[playerId]).TotalSeconds < interval)
{
EssLang.Send(UPlayer.From(playerId), "CHAT_ANTI_SPAM");
cancel = true;
return;
}
LastChatted[playerId] = DateTime.Now;
}
private CommandResult PvpCommand(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
var toggleVal = GetToggleValue(args[0]);
if (!toggleVal.HasValue)
{
return(CommandResult.ShowUsage());
}
if (toggleVal.Value)
{
Provider.isPvP = true;
EssLang.Send(src, "PVP_ENABLED");
}
else
{
Provider.isPvP = false;
EssLang.Send(src, "PVP_DISABLED");
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
float dist = 2048f;
RaycastInfo veh = TraceRay(player, dist, RayMasks.VEHICLE);
if (veh.vehicle != null)
{
if (veh.vehicle.isLocked)
{
VehicleManager.unlockVehicle(veh.vehicle, player.UnturnedPlayer);
EssLang.Send(src, "VEHICLE_UNLOCK");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("VEHICLE_NOT_LOCKED"));
}
}
else
{
return(CommandResult.LangError("NO_OBJECT"));
}
}
private CommandResult DescendCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
if (!args[0].IsFloat)
{
return(CommandResult.Lang("INVALID_NUMBER", args[0]));
}
if (args[0].ToFloat <= 0)
{
return(CommandResult.Lang("MUST_POSITIVE", args[0]));
}
var player = src.ToPlayer();
var pos = new Vector3(player.Position.x, player.Position.y, player.Position.z);
var num = args[0].ToFloat;
pos.y -= num;
player.Teleport(pos);
EssLang.Send(src, "DESCENDED", num);
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
player.Inventory.items.ForEach(item => Repair(player, item));
EssLang.Send(src, "ALL_REPAIRED");
return(CommandResult.Success());
}
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 | RayMasks.STRUCTURE))
{
Interactable2SalvageBarricade barri = hit.transform.GetComponent <Interactable2SalvageBarricade>();
Interactable2SalvageStructure struc = hit.transform.GetComponent <Interactable2SalvageStructure>();
if (barri != null)
{
BarricadeManager.tryGetInfo(barri.root, out byte x, out byte y, out ushort plant, out ushort index, out BarricadeRegion region);
region.barricades.RemoveAt(index);
BarricadeManager manager = (BarricadeManager)typeof(BarricadeManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeBarricade", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
plant,
index
});
EssLang.Send(src, "BARRICADE_REMOVED");
return(CommandResult.Success());
}
else if (struc != null)
{
StructureManager.tryGetInfo(struc.transform, out byte x, out byte y, out ushort index, out StructureRegion region);
region.structures.RemoveAt(index);
StructureManager manager = (StructureManager)typeof(StructureManager).GetField("manager", BindingFlags.NonPublic |
BindingFlags.Static).GetValue(null);
manager.channel.send("tellTakeStructure", ESteamCall.ALL, x, y, StructureManager.STRUCTURE_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
index,
(region.drops[index].model.position - player.UnturnedPlayer.transform.position).normalized * 100f
});
EssLang.Send(src, "STRUCTURE_REMOVED");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("DESTROY_INVALID"));
}
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var players = UServer.Players.ToList();
if (players.Count == (src.IsConsole ? 0 : 1))
{
return(CommandResult.Lang("NO_PLAYERS_FOR_TELEPORT"));
}
switch (args.Length)
{
case 0:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
TeleportAll(src.ToPlayer().RocketPlayer.Position, players);
EssLang.Send(src, "TELEPORTED_ALL_YOU");
break;
case 1:
var found = UPlayer.TryGet(args[0], player => {
TeleportAll(player.Position, players);
EssLang.Send(src, "TELEPORTED_ALL_PLAYER", player.DisplayName);
});
if (!found)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
}
break;
case 3:
var vec3 = args.GetVector3(0);
if (!vec3.HasValue)
{
return(CommandResult.Lang("INVALID_COORDS", src, args[0], args[1], args[2]));
}
var pos = vec3.Value;
TeleportAll(pos, players);
EssLang.Send(src, "TELEPORTED_ALL_COORDS", pos.x);
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private void TpaPlayerMove(UnturnedPlayer player, Vector3 newPosition)
{
Task task;
if (UEssentials.Config.Tpa.TeleportDelay > 0 && UEssentials.Config.Tpa.CancelTeleportWhenMove &&
CommandTpa.WaitingToTeleport.TryGetValue(player.CSteamID.m_SteamID, out task))
{
task.Cancel();
CommandTpa.WaitingToTeleport.Remove(player.CSteamID.m_SteamID);
UPlayer.TryGet(player, p => EssLang.Send(p, "TELEPORT_CANCELLED_MOVED"));
}
}
private void GiveMaxSkills(UPlayer player, bool overpower)
{
var pSkills = player.UnturnedPlayer.skills;
foreach (var skill in pSkills.skills.SelectMany(skArr => skArr))
{
skill.level = overpower ? byte.MaxValue : skill.max;
}
pSkills.askSkills(player.CSteamId);
EssLang.Send(player, "MAX_SKILLS");
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args) {
var killedCount = 0;
UWorld.Zombies.Where(zombie => !zombie.isDead).ForEach(zombie => {
ZombieManager.sendZombieDead(zombie, Vector3.zero);
killedCount++;
});
EssLang.Send(src, "KILLED_ZOMBIES", killedCount);
return CommandResult.Success();
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var playerId = player.CSteamId;
if (Cooldown.HasEntry(playerId))
{
return(CommandResult.Lang("USE_COOLDOWN",
TimeUtil.FormatSeconds((uint)Cooldown.GetRemainingTime(playerId))));
}
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.HomeCommand;
var delay = homeCommand.Delay;
var cooldown = homeCommand.Cooldown;
if (player.HasPermission("essentials.bypass.homecooldown"))
{
delay = 0;
cooldown = 0;
}
if (delay > 0)
{
EssLang.Send(src, "TELEPORT_DELAY", TimeUtil.FormatSeconds((uint)delay));
}
var task = Tasks.New(t => {
Delay.Remove(playerId.m_SteamID);
player.Teleport(position, angle);
EssLang.Send(src, "TELEPORTED_BED");
}).Delay(delay * 1000);
task.Go();
Delay.Add(playerId.m_SteamID, task);
Cooldown.AddEntry(playerId, cooldown);
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.LangError("WARP_NOT_EXIST", args[0]));
}
if (player.Stance == EPlayerStance.DRIVING ||
player.Stance == EPlayerStance.SITTING)
{
return(CommandResult.LangError("CANNOT_TELEPORT_DRIVING"));
}
if (Delay.ContainsKey(player.CSteamId.m_SteamID))
{
return(CommandResult.LangError("ALREADY_WAITING"));
}
var targetWarp = WarpModule.Instance.WarpManager.GetByName(args[0].ToString());
var cooldown = UEssentials.Config.Warp.TeleportDelay;
if (!targetWarp.CanBeUsedBy(src))
{
return(CommandResult.LangError("WARP_NO_PERMISSION", args[0]));
}
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(targetWarp.Location, targetWarp.Rotation);
EssLang.Send(src, "WARP_TELEPORTED", args[0]);
})
.Submit();
Delay.Add(player.CSteamId.m_SteamID, task);
return(CommandResult.Success());
}