public bool Initialize(ICommandArgs args)
{
ChopCommandArgs commandArgs = args as ChopCommandArgs;
if (commandArgs == null)
{
successful = false;
finished = true;
throw new UnityException("Wrong type of args");
}
node = commandArgs.node;
GameObject tree = node.GetBlock();
if (!tree)
{
Stop();
Debug.Log("No tree to chop");
return(false);
}
spriteRenderer = tree.GetComponent <SpriteRenderer>();
TickSystem.Subscribe(Chop);
return(true);
}
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.Lang("PLAYER_NOT_FOUND", args[0]));
}
return(CommandResult.Success());
}
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 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 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();
}
}
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());
}
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 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)
{
var player = src.ToPlayer();
float dist = 2048f;
RaycastInfo veh = TraceRay(player, dist, RayMasks.VEHICLE);
if (veh.vehicle != null)
{
if (!veh.vehicle.isLocked)
{
VehicleManager.instance.channel.send("tellVehicleLock", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, veh.vehicle.instanceID, player.CSteamId, player.UnturnedPlayer.channel.owner.playerID.group, player.CSteamId != CSteamID.Nil);
EssLang.Send(src, "VEHICLE_LOCK");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("VEHICLE_ALREADY_LOCKED"));
}
}
else
{
return(CommandResult.LangError("NO_OBJECT"));
}
}
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))
{
InteractableStorage storage = hit.transform.GetComponent <InteractableStorage>();
if (storage != null)
{
storage.isOpen = true;
storage.opener = player.UnturnedPlayer;
player.Inventory.isStoring = true;
player.Inventory.isStorageTrunk = false;
player.Inventory.storage = storage;
player.Inventory.updateItems(PlayerInventory.STORAGE, storage.items);
player.Inventory.sendStorage();
EssLang.Send(src, "STORAGE_OPEN");
return(CommandResult.Success());
}
else
{
return(CommandResult.LangError("STORAGE_INVALID"));
}
}
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"));
}
}
internal override void OnCommand(ICommandArgs command)
{
//Execute the proxy before the other handlers to maintain consistency with non-proxy commands
ExecuteProxy(command);
base.OnCommand(command);
}
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());
}
public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
var player = src.ToPlayer();
var playerMeta = player.Metadata;
if (!playerMeta.Has(META_KEY_POS) || !playerMeta.Has(META_KEY_DELAY))
{
return(CommandResult.Lang("NOT_DIED_YET"));
}
var deathTime = playerMeta.Get <DateTime>(META_KEY_DELAY);
var delta = UEssentials.Config.BackDelay - (DateTime.Now - deathTime).Seconds;
if (delta > 0 && !player.HasPermission($"essentials.bypass.backdelay"))
{
return(CommandResult.Lang("BACK_DELAY", TimeUtil.FormatSeconds((uint)delta)));
}
var backPosition = playerMeta.Get <Vector3>(META_KEY_POS);
src.ToPlayer().Teleport(backPosition);
EssLang.Send(src, "RETURNED");
playerMeta.Remove(META_KEY_DELAY);
playerMeta.Remove(META_KEY_POS);
return(CommandResult.Success());
}
public override Options Execute(ICommandArgs commandArgs)
{
Console.WriteLine("Write Username which you want to Register:");
var registerUserName = Console.ReadLine();
Console.WriteLine("Enter a password:"******"Register Username {registerUserName}", new List <string>
{
"Register new Member",
"Register new Librarian"
});
switch (option)
{
case "Register new Member":
commandArgs.UsersService.CreateAccount(registerUserName, password, AccountType.Member);
break;
case "Register new Librarian":
commandArgs.UsersService.CreateAccount(registerUserName, password, AccountType.Librarian);
break;
}
Console.WriteLine($"User with name {registerUserName} was create");
Console.ReadKey();
return(Options.HomeMenu);
}
public Options Execute(ICommandArgs commandArgs)
{
var option = commandArgs.MultipleChoice(title: "Login to System:", options: new List <Options>
{
Options.LoginMenu_Login,
Options.LoginMenu_Register,
Options.Quit
});
string username;
switch (option)
{
case Options.LoginMenu_Login:
Console.WriteLine("Enter your username:"******"Wrong username!");
Console.ReadKey();
return(Options.LoginMenu);
}
return(Options.HomeMenu);
case Options.LoginMenu_Register:
Console.WriteLine("Enter your username");
username = Console.ReadLine();
commandArgs.Users.CreateAccount(username, AccountType.Member);
commandArgs.Users.Login(username);
return(Options.HomeMenu);
}
return(option);
}
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());
}
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 static ICommand Create(ICommandArgs args)
{
bool hasInvalidArgsCount = false;
string cmdName = string.Empty;
if (args == null)
{
throw new CommandParseException(new Result("ERROR Unsupported command"));
}
/* Retrieve command name */
cmdName = args.FullCommand.Split(' ')[0];
/* Check if a command is supported */
if (!Commands.IsBound(cmdName))
{
throw new CommandParseException(new Result("ERROR Unsupported command"));
}
/* Split whole command line */
string[] cmd_args = args.FullCommand.Split(' ');
/* Check for correct arguments */
if (!Commands.AreArgumentsValid(cmdName, cmd_args))
{
hasInvalidArgsCount = true;
}
else
{
cmd_args = cmd_args.Skip(1).ToArray();
}
return(Commands.Build(cmdName, args.Context, args.UserContext, cmd_args, hasInvalidArgsCount));
}
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 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 Options Execute(ICommandArgs commandArgs)
{
Console.WriteLine("Write Username which you want to Register:");
var registerUserName = Console.ReadLine();
var option = this.MultipleChoice(title: $"Register Username {registerUserName}", new List <string>
{
"Register new Member",
"Register new Librarian",
"Back"
});
switch (option)
{
case "Register new Member":
var newUsernameMember = commandArgs.UsersService.CreateAccount(registerUserName, AccountType.Member);
commandArgs.UsersService.Accounts.Add(newUsernameMember);
break;
case "Register new Librarian":
var newUsernameLibrarian = commandArgs.UsersService.CreateAccount(registerUserName, AccountType.Librarian);
commandArgs.UsersService.Accounts.Add(newUsernameLibrarian);
break;
case "Back":
Console.WriteLine("Returning to home menu...");
Console.ReadKey();
return(Options.HomeMenu);
}
Console.WriteLine($"Member with name {registerUserName} was create");
return(Options.HomeMenu);
}
public void OnExecute( ICommandSource source, ICommandArgs args )
{
if ( _hasCommandParameter )
_methodActionWithCommand( source, args, this );
else
_methodAction( source, args );
}
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 );
}
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 CommandResult OnExecute(ICommandSource src, ICommandArgs args)
{
switch (args.Length)
{
case 0:
if (src.IsConsole)
{
return(CommandResult.ShowUsage());
}
var eyePos = src.ToPlayer().GetEyePosition(3000);
if (eyePos.HasValue)
{
Explode(eyePos.Value);
}
break;
case 1:
if (args[0].Is("*"))
{
UPlayer caller = null;
if (!src.IsConsole)
{
caller = src.ToPlayer();
}
UServer.Players.Where(p => p != caller).ForEach(p => Explode(p.Position));
}
else
{
var found = UPlayer.TryGet(args[0], player => Explode(player.Position));
if (!found)
{
return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
}
}
break;
case 3:
var pos = args.GetVector3(0);
if (pos.HasValue)
{
Explode(pos.Value);
}
else
{
return(CommandResult.Lang(EssLang.INVALID_COORDS, args[0], args[1], args[2]));
}
break;
default:
return(CommandResult.ShowUsage());
}
return(CommandResult.Success());
}
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());
}
/// <summary>
/// 处理命令系统业务逻辑
/// </summary>
/// <param name="evt"></param>
public override void ProcessLogic(PropertyMessage evt)
{
//执行Undo操作
if (evt.PropertyName.Equals("CommandArgs"))
{
ICommandArgs _args = (ICommandArgs)evt.NewValue;
if (!_args.GetCommandName().ToLower().Equals("undo"))
{
return;
}
_CommandService.GetCommandStack().Undo();
return;
}
//执行Redo操作
if (evt.PropertyName.Equals("CommandArgs"))
{
ICommandArgs _args = (ICommandArgs)evt.NewValue;
if (!_args.GetCommandName().ToLower().Equals("redo"))
{
return;
}
_CommandService.GetCommandStack().Redo();
return;
}
}
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 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 );
}
}
}
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());
}
public override Options Execute(ICommandArgs commandArgs)
{
Console.WriteLine("Please enter the ISBN of the book:");
var isbn = Console.ReadLine();
Console.WriteLine("Please enter the Title of the book:");
var title = Console.ReadLine();
Console.WriteLine("Please enter the Pages of the book:");
var pages = int.Parse(Console.ReadLine());
Console.WriteLine("Please enter the Subject of the book:");
var subject = Console.ReadLine();
Console.WriteLine("Pleae enter the publisher of the book:");
var publishers = Console.ReadLine();
Console.WriteLine("Pleae enter the Publish Date of the book:");
var publishDate = Console.ReadLine();
Console.WriteLine("Please enter the Author of the book:");
var author = Console.ReadLine();
IBook book = new Book(isbn, title, pages, subject, publishers, publishDate, author);
commandArgs.LibraryService.AddBook(book);
return(Options.HomeMenu);
}
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 Options Execute(ICommandArgs commandArgs)
{
Console.WriteLine("Enter ISBN of the book you want to renew");
var isbnBook = Console.ReadLine();
var bookLending = commandArgs.LibraryService.SystemService.BookLendings.FirstOrDefault(b => b.BookItem.Book.ISBN == isbnBook && b.User == commandArgs.UsersService.CurrentAccount);
if (bookLending == null)
{
Console.WriteLine($"Book with the following ISBN: {isbnBook} does not exist");
Console.ReadKey();
return(Options.HomeMenu);
}
if (commandArgs.LibraryService.SystemService.ValidateLendPeriod(bookLending))
{
Console.WriteLine("Enter how many days you want to renew the book");
var days = int.Parse(Console.ReadLine());
if (days > 10)
{
Console.WriteLine("You can renew the book up to 10 days");
Console.ReadKey();
return(Options.HomeMenu);
}
bookLending.Date = bookLending.Date.AddDays(days);
Console.WriteLine($"You renewed the book from {DateTime.Now} to {bookLending.Date}");
Console.ReadKey();
}
return(Options.HomeMenu);
}
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)
{
if (args.IsEmpty)
{
return(CommandResult.ShowUsage());
}
if (args[0].Is("*"))
{
UServer.Players.ForEach(p => p.Kill());
EssLang.KILL_ALL.SendTo(src);
}
else if (args[0].IsValidPlayerName)
{
var target = args[0].ToPlayer;
target.Kill();
EssLang.KILL_PLAYER.SendTo(src, target.DisplayName);
}
else
{
EssLang.PLAYER_NOT_FOUND.SendTo(src, args[0]);
}
return(CommandResult.Success());
}
public override Options Execute(ICommandArgs commandArgs)
{
Console.WriteLine("Enter Username");
var userName = Console.ReadLine();
var user = commandArgs.LibrarySystemContext.AccountsOldData.SingleOrDefault(u => u.UserName == userName);
var option = this.MultipleChoice(title: $"Edit user {user}", new List <Options>
{
Options.EditUsername,
Options.EditUserType,
Options.Quit
});
switch (option)
{
case Options.EditUsername:
Console.WriteLine("Enter new Username");
var newUserName = Console.ReadLine();
user.UserName = newUserName;
break;
case Options.EditUserType:
Console.WriteLine("Enter new userType");
var newUserType = Console.ReadLine();
user.Type = (AccountType)Enum.Parse(typeof(AccountType), newUserType);
break;
}
return(Options.HomeMenu);
}
/// <summary>
/// Run a Smoke unit test.
/// </summary>
/// <param name="element">The unit test element.</param>
/// <param name="previousUnitResults">The previous unit test results.</param>
/// <param name="args">The command arguments passed to WixUnit.</param>
public static void RunUnitTest(XmlElement element, UnitResults previousUnitResults, ICommandArgs args)
{
string arguments = element.GetAttribute("Arguments");
string expectedErrors = element.GetAttribute("ExpectedErrors");
string expectedWarnings = element.GetAttribute("ExpectedWarnings");
string extensions = element.GetAttribute("Extensions");
string toolsDirectory = element.GetAttribute("ToolsDirectory");
string toolFile = Path.Combine(toolsDirectory, "Smoke.exe");
StringBuilder commandLine = new StringBuilder(arguments);
// handle extensions
if (!String.IsNullOrEmpty(extensions))
{
foreach (string extension in extensions.Split(';'))
{
commandLine.AppendFormat(" -ext \"{0}\"", extension);
}
}
// run the tool
ArrayList output = ToolUtility.RunTool(toolFile, commandLine.ToString());
previousUnitResults.Errors.AddRange(ToolUtility.GetErrors(output, expectedErrors, expectedWarnings));
previousUnitResults.Output.AddRange(output);
}
/// <summary>
/// Run a Insignia unit test.
/// </summary>
/// <param name="element">The unit test element.</param>
/// <param name="previousUnitResults">The previous unit test results.</param>
/// <param name="args">The command arguments passed to WixUnit.</param>
public static void RunUnitTest(XmlElement element, UnitResults previousUnitResults, ICommandArgs args)
{
string arguments = element.GetAttribute("Arguments");
string expectedErrors = element.GetAttribute("ExpectedErrors");
string expectedWarnings = element.GetAttribute("ExpectedWarnings");
string tempDirectory = element.GetAttribute("TempDirectory");
string toolsDirectory = element.GetAttribute("ToolsDirectory");
string toolFile = Path.Combine(toolsDirectory, "Insignia.exe");
StringBuilder commandLine = new StringBuilder(arguments);
// handle wixunit arguments
if (args.NoTidy)
{
commandLine.Append(" -notidy");
}
// handle child elements
foreach (XmlNode node in element.ChildNodes)
{
if (node.NodeType == XmlNodeType.Element)
{
switch (node.LocalName)
{
case "SourceFile":
string sourceFile = Environment.ExpandEnvironmentVariables(node.InnerText.Trim());
string outputFile = Path.Combine(tempDirectory, sourceFile);
Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
// If the file already exists, let's throw an error - otherwise one output file overwriting the other
// in the notidy case would be confusing
File.Copy(sourceFile, outputFile, false);
DirectoryInfo inputDirInfo = new DirectoryInfo(Path.GetDirectoryName(sourceFile));
FileInfo[] cabFiles = inputDirInfo.GetFiles("*.cab");
foreach (FileInfo cabFile in cabFiles)
{
File.Copy(cabFile.FullName, Path.Combine(Path.GetDirectoryName(outputFile), cabFile.Name), false);
}
// Remove any read-only attributes on the file
FileAttributes attributes = File.GetAttributes(outputFile);
attributes = (attributes & ~FileAttributes.ReadOnly);
File.SetAttributes(outputFile, attributes);
commandLine.AppendFormat(" -im \"{0}\"", outputFile);
previousUnitResults.OutputFiles.Add(outputFile);
break;
}
}
}
// run the tool
ArrayList output = ToolUtility.RunTool(toolFile, commandLine.ToString());
previousUnitResults.Errors.AddRange(ToolUtility.GetErrors(output, expectedErrors, expectedWarnings));
previousUnitResults.Output.AddRange(output);
}
private static void InitialiseIoC(ICommandArgs commandArgs)
{
var resolver = new WindsorDependencyResolver(commandArgs);
IoC.InitializeWith(resolver);
log.Debug("IOC initialised.....");
}
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 );
}
}
/// <summary>
/// Run a Compare unit test.
/// </summary>
/// <param name="element">The unit test element.</param>
/// <param name="previousUnitResults">The previous unit test results.</param>
/// <param name="update">Indicates whether to give the user the option to fix a failing test.</param>
/// <param name="args">The command arguments passed to WixUnit.</param>
public static void RunUnitTest(XmlElement element, UnitResults previousUnitResults, bool update, ICommandArgs args)
{
string file1 = Environment.ExpandEnvironmentVariables(element.GetAttribute("File1"));
string file2 = Environment.ExpandEnvironmentVariables(element.GetAttribute("File2"));
string testName = element.ParentNode.Attributes["Name"].Value;
// Check the results
ArrayList differences = CompareUnit.CompareResults(file1, file2, testName, update);
previousUnitResults.Errors.AddRange(differences);
previousUnitResults.Output.AddRange(differences);
}
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 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 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 killedCount = 0;
UWorld.Zombies.ForEach( zombie =>
{
if ( zombie.isDead ) return;
ZombieManager.sendZombieDead( zombie, Vector3.zero );
killedCount++;
});
EssLang.KILLED_ZOMBIES.SendTo( source, killedCount );
}
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 before_each_spec()
{
var dependencyResolver = MockRepository.GenerateStub<IDependencyResolver>();
fileSystemProvider = MockRepository.GenerateStub<IFileSystemProvider>();
packageBuilder = MockRepository.GenerateStub<IPackageCommand>();
rootPackageTree = MockRepository.GenerateStub<IPackageTree>();
buildMetaData = MockRepository.GenerateStub<IBuildMetaData>();
commandArgs = new CommandArgs("horn", false, null, false, null);
dependencyResolver.Stub(x => x.HasComponent<ICommandArgs>()).Return(true);
dependencyResolver.Stub(x => x.Resolve<ICommandArgs>()).Return(commandArgs);
dependencyResolver.Stub(x => x.Resolve<IPackageCommand>("install")
).Return(packageBuilder);
IoC.InitializeWith(dependencyResolver);
rootPackageTree.Stub(x => x.Result).Return(new DirectoryInfo(@"z:\horn"));
buildMetaData.ProjectInfo= new Dictionary<string, object>();
rootPackageTree.Stub(x => x.GetAllPackageMetaData()).Return(new List<IBuildMetaData> {buildMetaData});
rootPackageTree.Stub(x => x.Name).Return("horn");
var category = new Category(null, rootPackageTree);
fileSystemProvider.Stub(x => x.GetFiles(Arg<DirectoryInfo>.Is.TypeOf, Arg<string>.Is.TypeOf)).Return(
new List<FileInfo>
{
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 30).ToString(FileSystemProvider.FileDateFormat))),
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 29).ToString(FileSystemProvider.FileDateFormat))),
new FileInfo(string.Format("horn-{0}.zip",
new DateTime(2009, 10, 31).ToString(FileSystemProvider.FileDateFormat)))
}.ToArray());
package = new PackageDouble(category, buildMetaData);
string zipFileName = string.Format("{0}-{1}.zip", package.Name, DateTime.Now.ToString(FileSystemProvider.FileDateFormat));
fileSystemProvider.Stub(
x => x.ZipFolder(Arg<DirectoryInfo>.Is.TypeOf, Arg<DirectoryInfo>.Is.TypeOf, Arg<string>.Is.TypeOf)).
Return(new FileInfo(zipFileName));
}
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 );
}
}
/// <summary>
/// Run a Process unit test.
/// </summary>
/// <param name="element">The unit test element.</param>
/// <param name="previousUnitResults">The previous unit test results.</param>
/// <param name="args">The command arguments passed to WixUnit.</param>
public static void RunUnitTest(XmlElement element, UnitResults previousUnitResults, ICommandArgs args)
{
string arguments = element.GetAttribute("Arguments");
string executable = element.GetAttribute("Executable");
string expectedReturnCode = element.GetAttribute("ExpectedReturnCode");
string workingDirectory = element.GetAttribute("WorkingDirectory");
bool compareReturnCodes = false;
// Check if an ExpectedReturnCode was set
if (null != expectedReturnCode && String.Empty != expectedReturnCode)
{
compareReturnCodes = true;
}
// Set the current working directory if one was specified
string currentDirectory = Environment.CurrentDirectory;
if (null != workingDirectory && String.Empty != workingDirectory)
{
Environment.CurrentDirectory = workingDirectory;
}
// Run the process
int actualReturnCode;
ArrayList output = ToolUtility.RunTool(executable, arguments, out actualReturnCode);
Environment.CurrentDirectory = currentDirectory;
previousUnitResults.Output.AddRange(output);
// Check the results
if (compareReturnCodes)
{
if (actualReturnCode == Convert.ToInt32(expectedReturnCode))
{
previousUnitResults.Output.Add(String.Format("Actual return code {0} matched expected return code {1}", actualReturnCode, expectedReturnCode));
}
else
{
previousUnitResults.Errors.Add(String.Format("Actual return code {0} did not match expected return code {1}", actualReturnCode, expectedReturnCode));
previousUnitResults.Output.Add(String.Format("Actual return code {0} did not match expected return code {1}", actualReturnCode, expectedReturnCode));
}
}
}
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 );
}
}
/// <summary>
/// Run a Dark unit test.
/// </summary>
/// <param name="element">The unit test element.</param>
/// <param name="previousUnitResults">The previous unit test results.</param>
/// <param name="args">The command arguments passed to WixUnit.</param>
public static void RunUnitTest(XmlElement element, UnitResults previousUnitResults, ICommandArgs args)
{
string arguments = element.GetAttribute("Arguments");
string expectedErrors = element.GetAttribute("ExpectedErrors");
string expectedWarnings = element.GetAttribute("ExpectedWarnings");
string tempDirectory = element.GetAttribute("TempDirectory");
string toolsDirectory = element.GetAttribute("ToolsDirectory");
string toolFile = Path.Combine(toolsDirectory, "dark.exe");
StringBuilder commandLine = new StringBuilder(arguments);
// handle wixunit arguments
if (args.NoTidy)
{
commandLine.Append(" -notidy");
}
// determine the correct extension for the decompiled output
string extension = ".wxs";
if (0 <= arguments.IndexOf("-xo"))
{
extension = ".wixout";
}
// handle any previous outputs
string outputFile = null;
foreach (string databaseFile in previousUnitResults.OutputFiles)
{
commandLine.AppendFormat(" \"{0}\"", databaseFile);
outputFile = Path.Combine(tempDirectory, String.Concat("decompiled_", Path.GetFileNameWithoutExtension(databaseFile), extension));
}
previousUnitResults.OutputFiles.Clear();
commandLine.AppendFormat(" \"{0}\" -x \"{1}\"", outputFile, tempDirectory);
previousUnitResults.OutputFiles.Add(outputFile);
// run the tool
ArrayList output = ToolUtility.RunTool(toolFile, commandLine.ToString());
previousUnitResults.Errors.AddRange(ToolUtility.GetErrors(output, expectedErrors, expectedWarnings));
previousUnitResults.Output.AddRange(output);
}
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 PackageBuilder(IGet get, IProcessFactory processFactory, ICommandArgs commandArgs)
{
if (get == null)
{
throw new ArgumentNullException("get");
}
if (processFactory == null)
{
throw new ArgumentNullException("processFactory");
}
if (commandArgs == null)
{
throw new ArgumentNullException("commandArgs");
}
this.get = get;
this.processFactory = processFactory;
this.commandArgs = commandArgs;
}
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 );
}
