public override void OnExecute( ICommandSource src, ICommandArgs args )
{
if ( args.Length < 2 )
{
ShowUsage( src );
}
else
{
string name;
if ( args[0].Is( name = "*console*" ) )
{
CommandWindow.ConsoleInput.onInputText( args.Join( 1 ) );
}
else
{
if ( !args[0].IsValidPlayerName )
{
EssLang.PLAYER_NOT_FOUND.SendTo( src, args[0] );
return;
}
var targetPlayer = args[0].ToPlayer;
ChatManager.Instance.askChat( targetPlayer.CSteamId, (byte) EChatMode.GLOBAL, args.Join( 1 ) );
name = targetPlayer.CharacterName;
}
EssLang.SUDO_EXECUTED.SendTo( src, name, args.Join( 1 ) );
}
}
public override void OnExecute( ICommandSource src, ICommandArgs args )
{
var player = src.ToPlayer();
var dist = 1000f;
if ( args.Length == 1 )
{
if ( !args[0].IsDouble )
goto usage;
dist = (float) args[0].ToDouble;
}
var eyePos = player.GetEyePosition( dist );
if ( !eyePos.HasValue )
{
EssLang.JUMP_NO_POSITION.SendTo( src );
}
else
{
var point = eyePos.Value;
point.y += 6;
player.Teleport( point );
EssLang.JUMPED.SendTo( src, point.x, point.y, point.z );
}
return;
usage:
ShowUsage( src );
}
public void AscendCommand( ICommandSource src, ICommandArgs args, ICommand cmd )
{
if ( args.IsEmpty )
{
ShowUsage( src, cmd );
}
else if ( !args[0].IsFloat )
{
EssLang.INVALID_NUMBER.SendTo( src, args[0] );
}
else if ( args[0].ToFloat <= 0 )
{
EssLang.MUST_POSITIVE.SendTo( src, args[0] );
}
else
{
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 );
player.SendMessage( $"You ascended {num} \"meters\"" );
}
}
public void OnExecute( ICommandSource source, ICommandArgs args )
{
if ( _hasCommandParameter )
_methodActionWithCommand( source, args, this );
else
_methodAction( source, args );
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty )
{
if ( source.IsConsole )
ShowUsage( source );
else
GiveMaxSkills( source.ToPlayer(), false );
}
else
{
if ( !parameters[0].IsBool || parameters.Length < 2 && source.IsConsole )
{
ShowUsage( source );
return;
}
var overpower = parameters[0].ToBool;
var targetPlayer = parameters.Length == 2 ? parameters[1].ToPlayer : source.ToPlayer();
if ( targetPlayer == null )
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[1] );
else
{
GiveMaxSkills( targetPlayer, overpower );
if ( source.IsConsole || source.ToPlayer() != targetPlayer )
EssLang.MAX_SKILLS_TARGET.SendTo( source, targetPlayer.DisplayName );
}
}
}
/// <summary>
/// Queries CanExecute status for the CommandSource's command as a RoutedCommand if possible,
/// otherwise as a regular Command.
/// </summary>
/// <param name="parameter">The parameter to the ICommandSource.</param>
/// <param name="commandSource">The ICommandSource being executed.</param>
internal static bool CanExecuteCommandSource(object parameter, ICommandSource commandSource)
{
ICommand command = commandSource.Command;
if (command != null)
{
RoutedCommand routed = command as RoutedCommand;
if (routed != null)
{
IInputElement target = commandSource.CommandTarget;
if (target == null)
{
target = commandSource as IInputElement;
}
return routed.CanExecute(parameter, target);
}
else
{
return command.CanExecute(parameter);
}
}
return true;
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.Length == 0 )
{
if ( source.IsConsole )
{
ShowUsage( source );
}
else
{
var player = source.ToPlayer();
EssLang.POSITION.SendTo( player,
player.Position.x,
player.Position.y,
player.Position.z );
}
}
else
{
var found = UPlayer.TryGet( parameters[0], p =>
{
EssLang.POSITION_OTHER.SendTo( source,
p.DisplayName, p.Position.x, p.Position.y, p.Position.z );
} );
if ( !found )
{
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var player = source.ToPlayer();
if ( parameters.Length == 0 || parameters.Length > 1 )
{
ShowUsage( source );
}
else if ( !EssProvider.WarpManager.Contains( parameters[0].ToString() ) )
{
EssLang.WARP_NOT_EXIST.SendTo( source, parameters[0] );
}
else if ( !player.HasPermission( $"essentials.warp.{parameters[0]}" ) )
{
EssLang.WARP_NO_PERMISSION.SendTo( source, parameters[0] );
}
else
{
var dest = EssProvider.WarpManager[parameters[0].ToString()];
var cooldown = EssProvider.Config.WarpCooldown;
if ( cooldown > 0 && !player.HasPermission( "essentials.warps.bypasscooldown" ) )
{
EssLang.WARP_COOLDOWN.SendTo( source, cooldown );
}
Tasks.New( t =>
{
player.Teleport( dest.Location, dest.Rotation );
EssLang.WARP_TELEPORTED.SendTo( source, parameters[0] );
}).Delay( player.HasPermission( "essentials.warps.bypasscooldown" ) ? 0 : cooldown * 1000 ).Go();
}
}
/// <summary>
/// Carries out the specified action for the CommandSource's command as a RoutedCommand if possible,
/// otherwise as a regular Command.
/// </summary>
/// <param name="parameter">The parameter to the ICommandSource.</param>
/// <param name="commandSource">The ICommandSource being executed.</param>
internal static void InvokeCommandSource(object parameter, object previewParameter, ICommandSource commandSource, CommandOperation operation)
{
ICommand command = commandSource.Command;
if (command != null)
{
RoutedCommand routed = command as RoutedCommand;
if (routed != null)
{
IInputElement target = commandSource.CommandTarget;
if (target == null)
{
target = commandSource as IInputElement;
}
if (routed.CanExecute(parameter, target))
{
//Debug.Assert(operation == CommandOperation.Execute, "We do not support Previewing RoutedCommands.");
switch (operation)
{
case CommandOperation.Execute:
routed.Execute(parameter, target);
break;
}
}
}
else if (command.CanExecute(parameter))
{
IPreviewCommand previewCommand;
switch (operation)
{
case CommandOperation.Preview:
previewCommand = command as IPreviewCommand;
if (previewCommand != null)
{
previewCommand.Preview(previewParameter);
}
break;
case CommandOperation.CancelPreview:
previewCommand = command as IPreviewCommand;
if (previewCommand != null)
{
previewCommand.CancelPreview();
}
break;
case CommandOperation.Execute:
command.Execute(parameter);
break;
}
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty || ( parameters.Length < 5 && source.IsConsole ) )
{
ShowUsage( source );
}
else
{
var rawId = parameters[0].ToString();
var rawAmount = parameters.Length >= 2 ? parameters[1].ToString() : "1";
var pos = source.ToPlayer().Position;
if ( parameters.Length == 5 )
{
var argPos = parameters.GetVector3( 2 );
if ( !argPos.HasValue )
{
EssLang.INVALID_COORDS.SendTo( source, parameters[2], parameters[3], parameters[4] );
return;
}
pos = argPos.Value;
}
ushort amount;
if ( !ushort.TryParse( rawAmount, out amount ) )
{
EssLang.INVALID_NUMBER.SendTo( source, rawAmount );
return;
}
var itemAsset = ItemUtil.GetItem( rawId );
if ( itemAsset.IsAbsent )
{
EssLang.INVALID_ITEM_ID.SendTo( source, rawId );
return;
}
var item = new Item( itemAsset.Value.id, true );
for ( var i = 0; i < amount; i++ )
{
ItemManager.dropItem( item, pos, true, true, true );
}
if ( parameters.Length == 5 )
EssLang.SPAWNED_ITEM_AT.SendTo( source, amount, itemAsset.Value.Name, pos.x, pos.y, pos.z );
else
EssLang.SPAWNED_ITEM.SendTo( source, amount, itemAsset.Value.Name );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var respawnedCount = 0;
UWorld.Animals.ForEach( animal =>
{
AnimalManager.sendAnimalAlive( animal, animal.transform.position, 0 );
respawnedCount++;
});
EssLang.RESPAWNED_ANIMALS.SendTo( source, respawnedCount );
}
public override void OnExecute( ICommandSource src, ICommandArgs args )
{
if ( args.Length == 2 )
{
var found = UPlayer.TryGet( args[1], player => {
var vehId = args[0];
if ( !vehId.IsUshort || !IsValidVehicleId( vehId.ToUshort ) )
{
EssLang.INVALID_VEHICLE_ID.SendTo( src, vehId );
}
else
{
VehicleTool.giveVehicle( player.UnturnedPlayer, vehId.ToUshort );
EssLang.SPAWNED_VEHICLE_AT_PLAYER.SendTo( src, args[1] );
}
});
if ( !found )
{
EssLang.PLAYER_NOT_FOUND.SendTo( src, args[1] );
}
}
else if ( args.Length == 4 )
{
var pos = args.GetVector3( 1 );
var vehId = args[0];
if ( pos.HasValue )
{
var pVal = pos.Value;
if ( !vehId.IsUshort || !IsValidVehicleId( vehId.ToUshort ) )
{
EssLang.INVALID_VEHICLE_ID.SendTo( src, vehId );
}
else
{
SpawnVehicle( pVal, vehId.ToUshort );
EssLang.SPAWNED_VEHICLE_AT_POSITION.SendTo( src, pVal.x, pVal.y, pVal.z );
}
}
else
{
EssLang.INVALID_COORDS.SendTo( src, args[1], args[2], args[3] );
}
}
else
{
ShowUsage( src );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var warps = (
from warp in EssProvider.WarpManager.Warps
where warp.CanUse( source )
select warp.Name
).ToArray();
if ( warps.Length == 0 )
EssLang.WARP_NONE.SendTo( source );
else
EssLang.WARP_LIST.SendTo( source, string.Join( ", ", warps ) );
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var kits = (
from kit in EssProvider.KitManager.Kits
where kit.CanUse( source )
select kit.Name
).ToList();
if ( kits.Count == 0 )
EssLang.KIT_NONE.SendTo( source );
else
EssLang.KIT_LIST.SendTo( source, string.Join( ", ", kits.ToArray() ) );
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var killedCount = 0;
UWorld.Zombies.ForEach( zombie =>
{
if ( zombie.isDead ) return;
ZombieManager.sendZombieDead( zombie, Vector3.zero );
killedCount++;
});
EssLang.KILLED_ZOMBIES.SendTo( source, killedCount );
}
/// <summary>
/// Disconnects command source from the command.
/// </summary>
/// <param name="commandSource">Reference to command source.</param>
/// <param name="command">Reference to the command.</param>
public static void UnRegisterCommandSource(ICommandSource commandSource, ICommand command)
{
if (commandSource == null)
throw new NullReferenceException("commandSource cannot be null");
if (command == null)
throw new NullReferenceException("command cannot be null");
if (_CommandBindings.Contains(command))
{
ArrayList subscribers = (ArrayList)_CommandBindings[command];
if (subscribers.Contains(commandSource))
subscribers.Remove(commandSource);
}
command.CommandSourceUnregistered(commandSource);
}
/// <summary>
/// 当可以执行时给予一个特殊的方法
/// </summary>
/// <param name="commandSource">核实命令</param>
/// <returns></returns>
public static bool CanExecuteCommandSource(ICommandSource commandSource)
{
ICommand baseCommand = commandSource.Command;
if (baseCommand == null)
return false;
object commandParameter = commandSource.CommandParameter;
IInputElement commandTarget = commandSource.CommandTarget;
RoutedCommand command = baseCommand as RoutedCommand;
if (command == null)
return baseCommand.CanExecute(commandParameter);
if (commandTarget == null)
commandTarget = commandSource as IInputElement;
return command.CanExecute(commandParameter, commandTarget);
}
public override void OnExecute( ICommandSource src, ICommandArgs args )
{
switch ( args.Length )
{
case 0:
if ( src.IsConsole )
{
ShowUsage( src );
return;
}
var eyePos = src.ToPlayer().GetEyePosition( 3000 );
if ( eyePos.HasValue )
{
Explode( eyePos.Value );
}
break;
case 1:
var found = UPlayer.TryGet( args[0], player =>
Explode( player.Position )
);
if ( !found )
{
EssLang.PLAYER_NOT_FOUND.SendTo( src, args[0] );
}
break;
case 3:
var pos = args.GetVector3( 0 );
if ( pos.HasValue )
{
Explode( pos.Value );
}
else
{
EssLang.INVALID_COORDS.SendTo( src, args[0], args[1], args[2] );
}
break;
default:
ShowUsage( src );
return;
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty || parameters.Length > 1 )
{
ShowUsage( source );
}
else if ( !EssProvider.WarpManager.Contains( parameters[0].ToString() ) )
{
EssLang.WARP_NOT_EXIST.SendTo( source, parameters[0] );
}
else
{
EssProvider.WarpManager.Delete( parameters[0].ToString() );
EssLang.WARP_REMOVED.SendTo( source, parameters[0] );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.Length < 2 )
{
ShowUsage( source );
}
else
{
var target = parameters[0].ToPlayer;
if ( target == null )
{
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
}
else
{
var message = string.Format(
EssProvider.Config.PrivateMessageFormat,
source.DisplayName,
parameters.Join( 1 )
);
target.SendMessage( message );
Spies.ForEach( p =>
{
UPlayer.From( p ).SendMessage(
$"Spy: ({source.DisplayName} -> {target.CharacterName}): {parameters.Join( 1 )}",
Color.gray
);
} );
if ( Conversations.ContainsKey( source.DisplayName ) )
{
if ( !Conversations[ source.DisplayName ].Equals( target.DisplayName ) )
{
Conversations[ source.DisplayName ] = target.CharacterName;
}
}
else
{
Conversations.Add( source.DisplayName, target.DisplayName );
}
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var displayName = source.DisplayName;
if ( BackDict.ContainsKey( displayName ) )
{
source.ToPlayer().Teleport( BackDict[displayName] );
BackDict.Remove( displayName );
EssLang.RETURNED.SendTo( source );
}
else
{
EssLang.NOT_DIED_YET.SendTo( source );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty || parameters.Length > 1 )
{
if ( source.IsConsole )
source.SendMessage( "Use /ping [player]" );
else
EssLang.PING.SendTo( source, source.ToPlayer().Ping );
}
else
{
var target = parameters[0].ToPlayer;
if ( target == null )
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
else
EssLang.PING_OTHER.SendTo( source, target.DisplayName, target.Ping );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var player = source.ToPlayer();
if ( parameters.IsEmpty )
{
ShowUsage( source );
}
else if ( parameters[0].Is( "all" ) )
{
player.RocketPlayer.Inventory.Items.ToList().ForEach( item => Repair( player, item ) );
EssLang.ALL_REPAIRED.SendTo( source );
}
else if ( parameters[0].Is( "hand" ) )
{
Repair( player, player.RocketPlayer.Inventory.Items[0] );
EssLang.HAND_REPAIRED.SendTo( source );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty )
{
if ( source.IsConsole )
{
ShowUsage( source );
return;
}
var currentVeh = source.ToPlayer().CurrentVehicle;
if ( currentVeh != null )
{
VehicleManager.sendVehicleFuel( currentVeh, currentVeh.asset.fuel );
EssLang.VEHICLE_REFUELED.SendTo( source );
}
else
{
EssLang.NOT_IN_VEHICLE.SendTo( source );
}
}
else if ( parameters[0].Is( "all" ) )
{
var allVehicles = UWorld.Vehicles;
lock ( allVehicles )
{
allVehicles
.Where( veh => !veh.isExploded && !veh.isUnderwater)
.ToList()
.ForEach( vehicle =>
{
VehicleManager.sendVehicleFuel( vehicle, vehicle.asset.fuel );
});
EssLang.VEHICLE_REFUELED_ALL.SendTo( source );
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.IsEmpty )
{
ShowUsage( source );
}
else
{
var target = parameters[0].ToPlayer;
if ( target == null )
{
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
}
else
{
target.Kill();
EssLang.KILL_PLAYER.SendTo( source, target.DisplayName );
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var count = 0;
UWorld.Zombies.ForEach( zombie =>
{
ZombieManager.sendZombieAlive(
zombie,
zombie.type,
(byte) zombie.speciality,
zombie.shirt,
zombie.pants,
zombie.hat,
zombie.gear,
zombie.transform.position,
0
);
count++;
});
EssLang.RESPAWNED_ZOMBIES.SendTo( source, count );
}
/// <summary>
/// Connects the Command Source to the Command.
/// </summary>
/// <param name="commandSource">Command source to connect to the command.</param>
/// <param name="command">Reference to the command.</param>
public static void RegisterCommand(ICommandSource commandSource, ICommand command)
{
if (commandSource == null)
throw new NullReferenceException("commandSource cannot be null");
if (command == null)
throw new NullReferenceException("command cannot be null");
ArrayList subscribers = null;
if (_CommandBindings.Contains(command))
{
subscribers = (ArrayList)_CommandBindings[command];
if (!subscribers.Contains(commandSource))
subscribers.Add(commandSource);
}
else
{
subscribers = new ArrayList();
subscribers.Add(commandSource);
_CommandBindings.Add(command, subscribers);
}
command.CommandSourceRegistered(commandSource);
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
var players = new List<UPlayer>( UServer.Players );
if ( players.Count == 0 )
{
EssLang.NO_PLAYERS_FOR_KICK.SendTo( source );
}
else
{
string noReasonMessage = EssLang.KICK_NO_SPECIFIED_REASON.GetMessage();
players.ForEach( player =>
{
player.Kick( parameters.IsEmpty
? noReasonMessage
: parameters.Join( 0 ) );
} );
EssLang.KICKED_ALL.SendTo( source, players.Count );
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
if ( parameters.Length == 0 )
{
ShowUsage( source );
}
else if ( parameters[0].IsOneOf( new []{ "*", "all" } ) )
{
foreach ( var player in UServer.Players.Where( player => player.HasComponent<FrozenPlayer>() ) )
{
player.RemoveComponent<FrozenPlayer>();
EssLang.UNFROZEN_PLAYER.SendTo( player, source.DisplayName );
}
EssLang.UNFROZEN_ALL.SendTo( source );
}
else
{
var found = UPlayer.TryGet( parameters[0], player => {
if ( !player.HasComponent<FrozenPlayer>() )
{
EssLang.NOT_FROZEN.SendTo( source, player.DisplayName );
}
else
{
player.RemoveComponent<FrozenPlayer>();
EssLang.UNFROZEN_SENDER.SendTo( source, player.DisplayName );
EssLang.UNFROZEN_PLAYER.SendTo( player, source.DisplayName );
}
} );
if ( !found )
{
EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
}
}
}
public override void OnExecute( ICommandSource source, ICommandArgs parameters )
{
switch ( parameters.Length )
{
case 1:
if ( source.IsConsole )
{
ShowUsage( source );
break;
}
var player = source.ToPlayer();
var warp = new Warp( parameters[0].ToString(), player.Position, player.Rotation );
EssProvider.WarpManager.Add( warp );
EssLang.WARP_SET.SendTo( source, parameters[0] );
break;
case 4:
var pos = parameters.GetVector3( 1 );
if ( pos.HasValue )
{
warp = new Warp( parameters[0].ToString(), pos.Value, 0.0F );
EssProvider.WarpManager.Add( warp );
EssLang.WARP_SET.SendTo( source, parameters[0] );
}
else
{
EssLang.INVALID_COORDS.SendTo( source, parameters[1], parameters[2], parameters[3] );
}
break;
default:
ShowUsage( source );
break;
}
}
private CommandResult ClearCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
/*
* TODO: Options
* -i = items
* -v = vehicles
* -z = zombies
* -b = barricades
* -s = structures
* -a = ALL
*
* /clear -i -z -v = items, zombies, vehicles
*/
var distance = -1;
if (args.Length > 1)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
if (!args[1].IsInt)
{
return(CommandResult.Lang("INVALID_NUMBER", args[1]));
}
if (args[1].ToInt < 1)
{
return(CommandResult.Lang("NUMBER_BETWEEN", 1, int.MaxValue));
}
distance = args[1].ToInt;
}
switch (args[0].ToLowerString)
{
case "ev":
case "emptyvehicles":
if (!src.HasPermission(cmd.Permission + ".emptyvehicles"))
{
return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
}
src.SendMessage("This command is instable and can cause bugs.", Color.red);
var toRemove = new List <uint>();
UWorld.Vehicles
.Where(v => v.passengers.All(p => p?.player == null))
.Where(v => {
if (distance == -1)
{
return(true);
}
return(Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance);
})
.Select(v => v.instanceID)
.ForEach(toRemove.Add);
toRemove.ForEach(id => {
VehicleManager.Instance.SteamChannel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
});
EssLang.Send(src, "CLEAR_EMPTY_VEHICLES", toRemove.Count);
break;
case "v":
case "vehicle":
return(CommandResult.Generic("This option is currently disabled."));
/*
* if (!src.HasPermission(cmd.Permission + ".vehicles")) {
* return CommandResult.Lang("COMMAND_NO_PERMISSION");
* }
*
* new Thread(() => {
* UWorld.Vehicles.ForEach(v => {
* for (byte i = 0; i < v.passengers.Length; i++) {
* if (v.passengers[i] == null ||
* v.passengers[i].player == null) continue;
*
* Vector3 point;
* byte angle;
*
* v.getExit(i, out point, out angle);
* VehicleManager.sendExitVehicle(v, i, point, angle, true);
* }
* });
*
* VehicleManager.askVehicleDestroyAll();
* EssLang.Send(src, "CLEAR_VEHICLES");
* }).Start();
* break;*/
case "i":
case "items":
if (!src.HasPermission(cmd.Permission + ".items"))
{
return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
}
ItemManager.askClearAllItems();
EssLang.Send(src, "CLEAR_ITEMS");
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private CommandResult StopTasksCommand(ICommandSource src, ICommandArgs args)
{
UEssentials.TaskExecutor.DequeueAll();
return(CommandResult.Success());
}
/// <summary>
/// Execute <see cref="ICommandSource.Command"/> using <see cref="ICommandSource.CommandParameter"/> and <see cref="ICommandSource.CommandTarget"/>.
/// </summary>
public static void ExecuteCommand(this ICommandSource commandSource)
{
CommandHelper.Execute(commandSource.Command, commandSource.CommandParameter, commandSource.CommandTarget);
}
public void RemoveCommandSource(ICommandSource commandSource)
{
m_CommandSources.Remove(commandSource);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.IsEmpty || _validInputs.None(i => i.EqualsIgnoreCase(args[0].ToString())))
{
return(CommandResult.ShowUsage());
}
if (!src.HasPermission($"{Permission}.{args[0]}"))
{
return(CommandResult.NoPermission($"{Permission}.{args[0]}"));
}
switch (args[0].ToString().ToLower())
{
case "start": {
if (args.Length < 4)
{
return(CommandResult.InvalidArgs("/poll start [name] [duration] [description]"));
}
var pollName = args[1].ToString();
lock (Polls) {
if (Polls.ContainsKey(pollName))
{
return(CommandResult.Lang("POLL_NAME_IN_USE"));
}
}
var pollDescription = args.Join(3);
if (args[2].IsInt)
{
var poll = new Poll(
pollName,
pollDescription,
args[2].ToInt
);
poll.Start();
}
else
{
return(CommandResult.Lang("INVALID_NUMBER", args[2]));
}
break;
}
case "stop": {
if (args.Length < 2)
{
return(CommandResult.InvalidArgs("/poll stop [name]"));
}
var pollName = args[1].ToString();
if (!PollExists(pollName, src))
{
return(CommandResult.Empty());
}
lock (Polls) {
Polls[pollName].Stop();
}
break;
}
case "list": {
lock (Polls) {
if (!Polls.Any())
{
return(CommandResult.Lang("POLL_NONE"));
}
EssLang.Send(src, "POLL_LIST");
foreach (var poll in Polls.Values)
{
EssLang.Send(src,
"POLL_LIST_ENTRY",
poll.Name,
poll.Description,
poll.YesVotes,
poll.NoVotes
);
}
}
break;
}
case "info": {
lock (Polls) {
if (!Polls.Any())
{
return(CommandResult.Lang("POLL_NONE"));
}
if (args.Length < 2)
{
return(CommandResult.InvalidArgs("Use /poll info [poll_name]"));
}
var pollName = args[1].ToString();
if (!PollExists(pollName, src))
{
return(CommandResult.Empty());
}
var poll = Polls[pollName];
EssLang.Send(src, "POLL_INFO", pollName);
EssLang.Send(
src,
"POLL_LIST_ENTRY",
pollName,
poll.Description,
poll.YesVotes,
poll.NoVotes
);
}
break;
}
}
return(CommandResult.Success());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length == 0 || (args.Length == 1 && src.IsConsole))
{
return(CommandResult.ShowUsage());
}
if (args.Length == 1)
{
var player = src.ToPlayer();
if (!KitModule.Instance.KitManager.Contains(args[0].ToString()))
{
return(CommandResult.Lang("KIT_NOT_EXIST", args[0]));
}
var kitName = args[0].ToLowerString;
var requestedKit = KitModule.Instance.KitManager.GetByName(kitName);
if (!requestedKit.CanUse(player))
{
return(CommandResult.Lang("KIT_NO_PERMISSION"));
}
var steamPlayerId = player.CSteamId.m_SteamID;
var kitCost = requestedKit.Cost;
if (kitCost > 0 && UEssentials.EconomyProvider.IsPresent)
{
var ecoProvider = UEssentials.EconomyProvider.Value;
if (!ecoProvider.Has(player, kitCost))
{
return(CommandResult.Lang("KIT_NO_MONEY", kitCost, ecoProvider.CurrencySymbol));
}
}
if (!src.HasPermission("essentials.bypass.kitcooldown"))
{
var globalCooldown = EssCore.Instance.Config.Kit.GlobalCooldown;
if (globalCooldown > 0)
{
if (GlobalCooldown.ContainsKey(steamPlayerId))
{
var remainingTime = DateTime.Now - GlobalCooldown[steamPlayerId];
if ((remainingTime.TotalSeconds + 1) > globalCooldown)
{
GlobalCooldown[steamPlayerId] = DateTime.Now;
}
else
{
return(CommandResult.Lang("KIT_GLOBAL_COOLDOWN",
TimeUtil.FormatSeconds((uint)(globalCooldown - remainingTime.TotalSeconds))));
}
}
else
{
GlobalCooldown.Add(steamPlayerId, DateTime.Now);
}
}
else
{
var kitCooldown = requestedKit.Cooldown;
if (!Cooldowns.ContainsKey(steamPlayerId))
{
Cooldowns.Add(steamPlayerId, new Dictionary <string, DateTime>());
}
else if (Cooldowns[steamPlayerId] == null)
{
Cooldowns[steamPlayerId] = new Dictionary <string, DateTime>();
}
if (Cooldowns[steamPlayerId].ContainsKey(kitName))
{
var remainingTime = DateTime.Now - Cooldowns[steamPlayerId][kitName];
if ((remainingTime.TotalSeconds + 1) > kitCooldown)
{
Cooldowns[steamPlayerId][kitName] = DateTime.Now;
}
else
{
return(CommandResult.Lang("KIT_COOLDOWN", TimeUtil.FormatSeconds(
(uint)(kitCooldown - remainingTime.TotalSeconds))));
}
}
else
{
Cooldowns[steamPlayerId].Add(kitName, DateTime.Now);
}
}
}
if (kitCost > 0)
{
UEssentials.EconomyProvider.IfPresent(ec => {
ec.Withdraw(player, kitCost);
EssLang.Send(player, "KIT_PAID", kitCost, ec.CurrencySymbol);
});
}
requestedKit.GiveTo(player);
}
else if (args.Length == 2)
{
var kitName = args[0].ToLowerString;
if (!src.HasPermission($"essentials.kit.{kitName}.other"))
{
return(CommandResult.Empty());
}
if (!KitModule.Instance.KitManager.Contains(kitName))
{
return(CommandResult.Lang("KIT_NOT_EXIST", kitName));
}
var kit = KitModule.Instance.KitManager.GetByName(kitName);
if (args[1].Equals("*"))
{
UServer.Players.ForEach(kit.GiveTo);
EssLang.Send(src, "KIT_GIVEN_SENDER_ALL", kitName);
}
else
{
var target = args[1].ToPlayer;
if (target == null)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND", args[1]));
}
kit.GiveTo(target);
EssLang.Send(src, "KIT_GIVEN_SENDER", kitName, target);
}
}
return(CommandResult.Success());
}
internal static void ExecuteCommandSource(ICommandSource commandSource)
{
CriticalExecuteCommandSource(commandSource, false);
}
private CommandResult SystemTimeCommand(ICommandSource src, ICommandArgs args)
{
src.SendMessage(DateTime.Now, Color.yellow);
return(CommandResult.Success());
}
private CommandResult VehicleCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
switch (args.Length)
{
case 1:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var optAsset = VehicleUtil.GetVehicle(args[0].ToString());
if (optAsset.IsAbsent)
{
return(CommandResult.LangError("INVALID_VEHICLE_ID", args[0]));
}
var id = optAsset.Value.id;
if (UEssentials.Config.VehicleBlacklist.Contains(id) &&
!src.HasPermission("essentials.bypass.blacklist.vehicle"))
{
return(CommandResult.LangError("BLACKLISTED_VEHICLE", $"{optAsset.Value.vehicleName} ({id})"));
}
VehicleTool.giveVehicle(src.ToPlayer().UnturnedPlayer, id);
EssLang.Send(src, "RECEIVED_VEHICLE", optAsset.Value.vehicleName, id);
break;
case 2:
if (!src.HasPermission($"{cmd.Permission}.other"))
{
return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
}
optAsset = VehicleUtil.GetVehicle(args[1].ToString());
if (optAsset.IsAbsent)
{
return(CommandResult.LangError("INVALID_VEHICLE_ID", args[1]));
}
var vehAsset = optAsset.Value;
if (args[0].Equals("*"))
{
UServer.Players.ForEach(p => {
VehicleTool.giveVehicle(p.UnturnedPlayer, vehAsset.id);
});
EssLang.Send(src, "GIVEN_VEHICLE_ALL", vehAsset.vehicleName, vehAsset.id);
}
else if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
else
{
var target = args[0].ToPlayer;
VehicleTool.giveVehicle(target.UnturnedPlayer, vehAsset.id);
EssLang.Send(src, "GIVEN_VEHICLE", vehAsset.vehicleName, vehAsset.id, target.DisplayName);
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private CommandResult OnlineCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
EssLang.Send(src, "ONLINE_PLAYERS", UServer.Players.Count(), UServer.MaxPlayers);
return(CommandResult.Success());
}
/// <summary>
/// <returns> If determinated player has permission for this kit </returns>
/// </summary>
public bool CanUse(ICommandSource player)
{
return(player.HasPermission($"essentials.kit.{Name.ToLowerInvariant()}"));
}
public void AddCommandSource(ICommandSource commandSource)
{
m_CommandSources.Add(commandSource);
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
if (args.Length < 1)
{
return(CommandResult.ShowUsage());
}
var player = src.ToPlayer();
var senderId = player.CSteamId.m_SteamID;
switch (args[0].ToLowerString)
{
case "accept":
case "a":
{
if (!player.HasPermission($"{Permission}.accept"))
{
return(CommandResult.Lang(EssLang.COMMAND_NO_PERMISSION));
}
if (!Requests.ContainsValue(senderId))
{
return(CommandResult.Lang(EssLang.TPA_NONE));
}
var whoSentId = new List <ulong>(Requests.Keys).FirstOrDefault(k => Requests[k] == senderId);
var whoSent = UPlayer.From(new Steamworks.CSteamID(whoSentId));
/* Should never happen */
if (whoSent == null)
{
return(CommandResult.Lang(EssLang.TPA_NONE));
}
if (whoSent.Stance == EPlayerStance.DRIVING ||
whoSent.Stance == EPlayerStance.SITTING)
{
EssLang.CANNOT_TELEPORT_DRIVING.SendTo(whoSent);
return(CommandResult.Lang(EssLang.TPA_CANNOT_TELEPORT, whoSent.DisplayName));
}
EssLang.TPA_ACCEPTED_SENDER.SendTo(src, whoSent.DisplayName);
EssLang.TPA_ACCEPTED.SendTo(whoSent, src.DisplayName);
Requests.Remove(whoSentId);
var tpaSettings = EssCore.Instance.Config.Tpa;
if (tpaSettings.TeleportDelay > 0)
{
Tasks.New(t => {
if (!whoSent.IsOnline || !player.IsOnline)
{
return;
}
whoSent.Teleport(player.Position);
}).Delay(tpaSettings.TeleportDelay * 1000).Go();
}
else
{
whoSent.Teleport(player.Position);
}
break;
}
case "deny":
case "d":
{
if (!player.HasPermission($"{Permission}.deny"))
{
return(CommandResult.Lang(EssLang.COMMAND_NO_PERMISSION));
}
if (!Requests.ContainsValue(senderId))
{
return(CommandResult.Lang(EssLang.TPA_NONE));
}
var whoSentId = new List <ulong>(Requests.Keys).FirstOrDefault(k => Requests[k] == senderId);
var whoSent = UPlayer.From(new Steamworks.CSteamID(whoSentId));
if (whoSent != null)
{
EssLang.TPA_DENIED.SendTo(whoSent, src.DisplayName);
}
EssLang.TPA_DENIED_SENDER.SendTo(src, whoSent == null ? "Unknown" : whoSent.DisplayName);
Requests.Remove(whoSentId);
break;
}
case "cancel":
case "c":
{
if (!player.HasPermission($"{Permission}.cancel"))
{
return(CommandResult.Lang(EssLang.COMMAND_NO_PERMISSION));
}
if (!Requests.ContainsKey(senderId))
{
return(CommandResult.Lang(EssLang.TPA_NONE));
}
Requests.Remove(senderId);
EssLang.TPA_CANCELLED.SendTo(src);
break;
}
default:
{
if (!player.HasPermission($"{Permission}.send"))
{
return(CommandResult.Lang(EssLang.COMMAND_NO_PERMISSION));
}
if (!args[0].IsValidPlayerName)
{
return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
}
/*
* Cancel current request
*/
if (Requests.ContainsKey(senderId))
{
Requests.Remove(senderId);
}
var target = args[0].ToPlayer;
if (target == player)
{
return(CommandResult.Lang(EssLang.TPA_YOURSELF));
}
Requests.Add(senderId, target.CSteamId.m_SteamID);
EssLang.TPA_SENT_SENDER.SendTo(src, target.DisplayName);
EssLang.TPA_SENT.SendTo(target, src.DisplayName);
var tpaSettings = EssCore.Instance.Config.Tpa;
if (tpaSettings.ExpireDelay > 0)
{
Tasks.New(t => {
Requests.Remove(senderId);
}).Delay(tpaSettings.ExpireDelay * 1000).Go();
}
else
{
Requests.Remove(senderId);
}
break;
}
}
return(CommandResult.Success());
}
public CommandEvent([NotNull] ICommand command, ICommandArgs args, ICommandSource src)
{
Command = command;
Arguments = args;
Source = src;
}
private CommandResult ClsCommand(ICommandSource src, ICommandArgs args)
{
Console.Clear();
return(CommandResult.Success());
}
public static void Execute(ICommandSource source)
{
Execute(source, source.CommandParameter);
}
public CommandPosExecuteEvent(ICommand command, ICommandArgs args, ICommandSource src,
CommandResult result) : base(command, args, src)
{
Preconditions.NotNull(result, "result cannot be null");
Result = result;
}
private CommandResult VehicleFeaturesCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
var toggleVal = GetToggleValue(args[1]);
if (!toggleVal.HasValue)
{
return(CommandResult.LangError("INVALID_BOOLEAN", args[1]));
}
var player = src.ToPlayer();
var component = player.GetComponent <VehicleFeatures>() ?? player.AddComponent <VehicleFeatures>();
switch (args[0].ToLowerString)
{
case "autorefuel":
if (!src.HasPermission($"{cmd.Permission}.autorefuel"))
{
return(CommandResult.NoPermission($"{cmd.Permission}.autorefuel"));
}
if (toggleVal.Value)
{
component.AutoRefuel = true;
EssLang.Send(src, "AUTO_REFUEL_ENABLED");
}
else
{
component.AutoRefuel = false;
EssLang.Send(src, "AUTO_REFUEL_DISABLED");
}
break;
case "autorepair":
if (!src.HasPermission($"{cmd.Permission}.autorepair"))
{
return(CommandResult.NoPermission($"{cmd.Permission}.autorepair"));
}
if (toggleVal.Value)
{
component.AutoRepair = true;
EssLang.Send(src, "AUTO_REPAIR_ENABLED");
}
else
{
component.AutoRepair = false;
EssLang.Send(src, "AUTO_REPAIR_DISABLED");
}
break;
case "all":
if (!src.HasPermission($"{cmd.Permission}.all"))
{
return(CommandResult.NoPermission($"{cmd.Permission}.all"));
}
if (toggleVal.Value)
{
component.AutoRepair = true;
component.AutoRefuel = true;
EssLang.Send(src, "AUTO_REPAIR_ENABLED");
EssLang.Send(src, "AUTO_REFUEL_ENABLED");
}
else
{
component.AutoRepair = false;
component.AutoRefuel = false;
EssLang.Send(src, "AUTO_REPAIR_DISABLED");
EssLang.Send(src, "AUTO_REFUEL_DISABLED");
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
/// <summary>
/// <returns> If determinated player has permission for this kit </returns>
/// </summary>
public bool CanUse(ICommandSource player)
{
return(player.HasPermission($"essentials.kit.{Name}"));
}
private CommandResult ItemCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
switch (args.Length)
{
/*
* /i [item]
*/
case 1:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
GiveItem(src, src.ToPlayer(), args[0], One);
break;
/*
* /i [item] [amount]
* /i [player] [item]
* /i all [item]
*/
case 2:
if (args[1].IsInt)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
GiveItem(src, src.ToPlayer(), args[0], args[1]);
}
else if (args[0].Equals("*"))
{
GiveItem(src, null, args[1], One, true);
}
else if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
else
{
GiveItem(src, args[0].ToPlayer, args[1], One);
}
break;
/*
* /i [player] [item] [amount]
* /i all [item] [amount]
*/
case 3:
if (args[0].Equals("*"))
{
GiveItem(src, null, args[1], args[2], true);
}
else if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
}
else
{
GiveItem(src, args[0].ToPlayer, args[1], args[2]);
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private CommandResult SkillCommand(ICommandSource src, ICommandArgs args)
{
switch (args.Length)
{
// /skill [skill] [value]
case 2:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var optSkill = USkill.FromName(args[0].ToString());
if (optSkill.IsAbsent)
{
return(CommandResult.Lang("INVALID_SKILL", args[0]));
}
var player = src.ToPlayer();
byte value;
if (args[1].Equals("max"))
{
value = player.GetSkill(optSkill.Value).max;
}
else if (args[1].IsInt)
{
if (args[1].ToInt <0 || args[1].ToInt> byte.MaxValue)
{
return(CommandResult.Lang("NEGATIVE_OR_LARGE"));
}
value = (byte)args[1].ToInt;
}
else
{
return(CommandResult.Lang("INVALID_NUMBER", args[1]));
}
player.SetSkillLevel(optSkill.Value, value);
EssLang.Send(src, "SKILL_SET", optSkill.Value.Name.Capitalize(), args[1]);
break;
// /skill [player|*] [skill] [value]
case 3:
if (args[0].Equals("*"))
{
if (!UServer.Players.Any())
{
return(CommandResult.Lang("ANYONE_ONLINE"));
}
player = UServer.Players.First();
}
else
{
if (!args[0].IsValidPlayerIdentifier)
{
return(CommandResult.Lang("PLAYER_NOT_FOUND"));
}
player = args[0].ToPlayer;
}
optSkill = USkill.FromName(args[1].ToString());
if (optSkill.IsAbsent)
{
return(CommandResult.Lang("INVALID_SKILL", args[0]));
}
if (args[2].Equals("max"))
{
value = player.GetSkill(optSkill.Value).max;
}
else if (args[2].IsInt)
{
if (args[2].ToInt <0 || args[2].ToInt> byte.MaxValue)
{
return(CommandResult.Lang("NEGATIVE_OR_LARGE"));
}
value = (byte)args[2].ToInt;
}
else
{
return(CommandResult.Lang("INVALID_NUMBER", args[2]));
}
if (args[0].Equals("*"))
{
UServer.Players.ForEach(p => p.SetSkillLevel(optSkill.Value, value));
EssLang.Send(src, "SKILL_SET_ALL", optSkill.Value.Name.Capitalize(), args[2]);
}
else
{
player.SetSkillLevel(optSkill.Value, value);
EssLang.Send(src, "SKILL_SET_PLAYER", optSkill.Value.Name.Capitalize(),
player.CharacterName, args[2]);
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private CommandResult ClearCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
/*
* TODO: Options
* -i = items
* -v = vehicles
* -z = zombies
* -b = barricades
* -s = structures
* -a = ALL
*
* /clear -i -z -v = items, zombies, vehicles
*/
var distance = -1;
if (args.Length > 1)
{
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
if (!args[1].IsInt)
{
return(CommandResult.LangError("INVALID_NUMBER", args[1]));
}
if (args[1].ToInt < 1)
{
return(CommandResult.LangError("NUMBER_BETWEEN", 1, int.MaxValue));
}
distance = args[1].ToInt;
}
switch (args[0].ToLowerString)
{
case "ev":
case "emptyvehicles":
if (!src.HasPermission(cmd.Permission + ".emptyvehicles"))
{
return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
}
src.SendMessage("This command is unstable and can cause bugs.", Color.yellow);
var numRemoved = 0;
//VehicleManager.vehicles
// .Where(v => v.passengers.All(p => p?.player == null)) // Check if it's has no passengers
// .Where(v =>
// {
// if (v.id == 186 || v.id == 187) return false; // Ignore trains; TODO: config blacklist for this?
// if (distance == -1) return true;
// return Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance;
// })
// .Select(v => v.instanceID)
// .ToList()
// .ForEach(id =>
// {
// VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
// numRemoved++;
// });
//VehicleManager.vehicles
// .Where(v => v.passengers.All(p => p?.player == null)) // Check if it's has no passengers
// .Where(v =>
// {
// if (v.id == 186 || v.id == 187) return false; // Ignore trains; TODO: config blacklist for this?
// if (distance == -1) return true;
// return Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance;
// })
// .Select(v => v.instanceID)
// .ToList()
// .ForEach(id =>
// {
// VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
// numRemoved++;
// });
for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
{
VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
numRemoved++;
}
for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
{
VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
numRemoved++;
}
//while (VehicleManager.vehicles.Count != 0)
//{
// for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
// {
// VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
// numRemoved++;
// }
//}
//for (byte i = (byte)(VehicleManager.vehicles.Count - 1); i >= 0 ; i--)
//{
// VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
// numRemoved++;
//}
//InteractableVehicle[] vehicles = new InteractableVehicle[VehicleManager.vehicles.Count];
//for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
//{
// vehicles[i] = VehicleManager.vehicles[i];
//}
//Console.WriteLine($"VehicleManager.vehicles.Count: {VehicleManager.vehicles.Count}");
//int len = (VehicleManager.vehicles.Count - 1);
//for (int index1 = len; index1 >= 0; index1--)
//{
// Console.WriteLine($"index1: {index1}");
// //VehicleManager.vehicles.Remove(VehicleManager.vehicles[index1]);
// UnityEngine.Object.Destroy((UnityEngine.Object)VehicleManager.vehicles[index1].gameObject);
//}
//Console.WriteLine($"VehicleManager.vehicles.Count: {VehicleManager.vehicles.Count}");
//VehicleManager.respawnVehicleIndex = (ushort)0;
//VehicleManager.vehicles.Clear();
//for (byte i = 1; i < vehicles.Length - 1; i++)
//{
// if (vehicles[i].passengers != null || vehicles[i].passengers.Length != 0 || vehicles[i].id == 186 || vehicles[i].id == 187)
// continue;
// VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, vehicles[i].instanceID);
//}
EssLang.Send(src, "CLEAR_EMPTY_VEHICLES", numRemoved);
break;
case "i":
case "items":
if (!src.HasPermission(cmd.Permission + ".items"))
{
return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
}
ItemManager.askClearAllItems();
EssLang.Send(src, "CLEAR_ITEMS");
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
private static void GiveItem(ICommandSource src, UPlayer target, ICommandArgument itemArg,
ICommandArgument amountArg, bool allPlayers = false)
{
if (!src.HasPermission("essentials.command.item.other") && target != src)
{
EssLang.Send(src, "COMMAND_NO_PERMISSION");
return;
}
var optAsset = ItemUtil.GetItem(itemArg.ToString());
if (optAsset.IsAbsent)
{
EssLang.Send(src, "ITEM_NOT_FOUND", itemArg);
return;
}
if (UEssentials.Config.GiveItemBlacklist.Contains(optAsset.Value.id) &&
!src.HasPermission("essentials.bypass.blacklist.item"))
{
EssLang.Send(src, "BLACKLISTED_ITEM", $"{optAsset.Value.itemName} ({optAsset.Value.Id})");
return;
}
ushort amt = 1;
if (amountArg != null)
{
if (!amountArg.IsShort)
{
EssLang.Send(src, "INVALID_NUMBER", amountArg);
}
else if (amountArg.ToShort <= 0)
{
EssLang.Send(src, "MUST_POSITIVE");
}
else
{
amt = amountArg.ToUShort;
goto give;
}
return;
}
give:
var asset = optAsset.Value;
var playersToReceive = new List <UPlayer>();
var item = new Item(asset.id, true);
if (asset is ItemFuelAsset)
{
item.Metadata[0] = 244;
item.Metadata[1] = 1;
}
if (!src.HasPermission("essentials.bypass.itemlimit") && amt > UEssentials.Config.ItemSpawnLimit)
{
amt = UEssentials.Config.ItemSpawnLimit;
EssLang.Send(src, "ITEM_LIMIT", amt);
}
if (allPlayers)
{
UServer.Players.ForEach(playersToReceive.Add);
EssLang.Send(src, "GIVEN_ITEM_ALL", amt, asset.Name, asset.Id);
}
else
{
playersToReceive.Add(target);
if (!src.IsConsole && src.ToPlayer() == target)
{
goto give2;
}
EssLang.Send(src, "GIVEN_ITEM", amt, asset.Name, asset.Id, target.CharacterName);
}
give2:
playersToReceive.ForEach(p => {
var success = p.GiveItem(item, amt, true);
EssLang.Send(p, "RECEIVED_ITEM", amt, asset.Name, asset.Id);
if (!success)
{
EssLang.Send(p, "INVENTORY_FULL");
}
});
}
/// <summary>
/// Determines whether the <see cref="ICommandSource.Command"/> can be executed using <see cref="ICommandSource.CommandParameter"/> and <see cref="ICommandSource.CommandTarget"/>.
/// </summary>
/// <returns>Returns the commands result of CanExecute.</returns>
public static bool CanExecuteCommand(this ICommandSource commandSource)
{
return(CommandHelper.CanExecute(commandSource.Command, commandSource.CommandParameter, commandSource.CommandTarget));
}
public static bool CanExecute(ICommandSource source)
{
return(CanExecute(source.Command, source.CommandParameter, source.CommandTarget));
}
private CommandResult SuicideCommand(ICommandSource src, ICommandArgs args)
{
src.ToPlayer().Suicide();
return(CommandResult.Success());
}
public CommandPosExecuteEvent(ICommand command, ICommandArgs args,
ICommandSource src, CommandResult result) : base(command, args, src)
{
Result = result;
}
/// <summary>
/// Check If source has permission to use this warp
/// </summary>
/// <param name="source">Source that you want to check if is authorized</param>
/// <returns>If source has permission to use this warp</returns>
public bool CanUse(ICommandSource source)
{
return(source.HasPermission($"essentials.warp.{Name.ToLowerInvariant()}"));
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
if (args.Length < 1)
{
return(CommandResult.ShowUsage());
}
var name = args[0].ToString();
uint cooldown = 0;
var resetCooldownWhenDie = false;
var cost = 0d;
if (KitModule.Instance.KitManager.Contains(name))
{
return(CommandResult.Lang(EssLang.KIT_ALREADY_EXIST, name));
}
if (args.Length > 1)
{
if (!args[1].IsInt)
{
return(CommandResult.Lang(EssLang.INVALID_NUMBER, args[1]));
}
if (args[1].ToInt < 0)
{
return(CommandResult.Lang(EssLang.MUST_POSITIVE));
}
cooldown = args[1].ToUint;
}
if (args.Length > 2)
{
if (!args[2].IsBool)
{
return(CommandResult.Lang(EssLang.INVALID_BOOLEAN, args[2]));
}
resetCooldownWhenDie = args[2].ToBool;
}
if (args.Length > 3)
{
if (!args[3].IsDouble)
{
return(CommandResult.Lang(EssLang.INVALID_NUMBER, args[3]));
}
if (args[3].ToDouble < 0)
{
return(CommandResult.Lang(EssLang.MUST_POSITIVE));
}
cost = args[3].ToDouble;
}
var inventory = player.Inventory;
var clothing = player.Clothing;
var items = new List <AbstractKitItem>();
Action <byte> addItemsFromPage = page =>
{
var count = inventory.getItemCount(page);
for (byte index = 0; index < count; index++)
{
var item = inventory.getItem(page, index).item;
if (item == null)
{
continue;
}
var asset = GetItem(item.id).Value;
KitItem kitItem;
if (asset is ItemWeaponAsset)
{
var ammo = GetWeaponAmmo(item);
var firemode = GetWeaponFiremode(item).OrElse(EFiremode.SAFETY);
var kItem = new KitItemWeapon(item.id, item.Durability, 1, ammo.OrElse(0), firemode)
{
Magazine = GetWeaponAttachment(item, AttachmentType.MAGAZINE).OrElse(null),
Barrel = GetWeaponAttachment(item, AttachmentType.BARREL).OrElse(null),
Sight = GetWeaponAttachment(item, AttachmentType.SIGHT).OrElse(null),
Grip = GetWeaponAttachment(item, AttachmentType.GRIP).OrElse(null),
Tactical = GetWeaponAttachment(item, AttachmentType.TACTICAL).OrElse(null)
};
kitItem = kItem;
}
else if (asset is ItemMagazineAsset || asset is ItemSupplyAsset)
{
kitItem = new KitItemMagazine(item.id, item.Durability, 1, item.Amount);
}
else
{
kitItem = new KitItem(item.id, item.Durability, 1);
}
kitItem.Metadata = item.Metadata;
items.Add(kitItem);
}
};
addItemsFromPage(0); // Primary slot
addItemsFromPage(1); // Secondary slot
addItemsFromPage(2); // Hands
// Backpack
if (clothing.backpack != 0)
{
items.Add(new KitItem(clothing.backpack, clothing.backpackQuality, 1)
{
Metadata = clothing.backpackState
});
}
addItemsFromPage(3);
// End Backpack
// Shirt
if (clothing.shirt != 0)
{
items.Add(new KitItem(clothing.shirt, clothing.shirtQuality, 1)
{
Metadata = clothing.shirtState
});
}
addItemsFromPage(5);
// End Shirt
// Vest
if (clothing.vest != 0)
{
items.Add(new KitItem(clothing.vest, clothing.vestQuality, 1)
{
Metadata = clothing.vestState
});
}
addItemsFromPage(4);
// End Vest
// Pants
if (clothing.pants != 0)
{
items.Add(new KitItem(clothing.pants, clothing.pantsQuality, 1)
{
Metadata = clothing.pantsState
});
}
addItemsFromPage(6);
// End Pants
// Mask, Glasses & Hat
if (clothing.mask != 0)
{
items.Add(new KitItem(clothing.mask, clothing.maskQuality, 1)
{
Metadata = clothing.maskState
});
}
if (clothing.hat != 0)
{
items.Add(new KitItem(clothing.hat, clothing.hatQuality, 1)
{
Metadata = clothing.hatState
});
}
if (clothing.glasses != 0)
{
items.Add(new KitItem(clothing.glasses, clothing.glassesQuality, 1)
{
Metadata = clothing.glassesState
});
}
// End Mask, Glasses & Hat
var kit = new Kit(name, cooldown, (decimal)cost, resetCooldownWhenDie)
{
Items = items
};
KitModule.Instance.KitManager.Add(kit);
EssLang.CREATED_KIT.SendTo(src, name);
return(CommandResult.Success());
}
public override CommandResult OnExecute( ICommandSource src, ICommandArgs args )
{
if ( args.IsEmpty )
{
if ( src.IsConsole )
{
return CommandResult.ShowUsage();
}
}
else if ( !src.HasPermission( Permission + ".other" ) )
{
return CommandResult.Lang( EssLang.COMMAND_NO_PERMISSION );
}
var player = args.Length > 0 ? args[0].ToPlayer : src.ToPlayer();
if ( player == null )
{
return CommandResult.Lang( EssLang.PLAYER_NOT_FOUND, args[0] );
}
var playerInventory = player.Inventory;
// "Remove "models" of items from player "body""
player.Channel.send( "tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, (byte) 0, (byte) 0, new byte[0] );
player.Channel.send( "tellSlot", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, (byte) 1, (byte) 0, new byte[0] );
// Remove items
for ( byte page = 0; page < 8; page++ )
{
var count = playerInventory.getItemCount( page );
for ( byte index = 0; index < count; index++ )
{
playerInventory.removeItem( page, 0 );
}
}
// Remove clothes
// Remove unequipped cloths
System.Action removeUnequipped = () =>
{
for ( byte i = 0; i < playerInventory.getItemCount( 2 ); i++ )
{
playerInventory.removeItem( 2, 0 );
}
};
// Unequip & remove from inventory
player.UnturnedPlayer.clothing.askWearBackpack( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearGlasses( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearHat( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearPants( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearMask( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearShirt( 0, 0, new byte[0], true );
removeUnequipped();
player.UnturnedPlayer.clothing.askWearVest( 0, 0, new byte[0], true );
removeUnequipped();
EssLang.INVENTORY_CLEAN.SendTo( player );
return CommandResult.Success();
}
