public UserActionProvider(IFacebookClientProvider facebookClientProvider, IPlayerReadModel playerReadModel, IPlayerSession playerSession, ICommandSender bus)
{
_facebookClientProvider = facebookClientProvider;
_playerReadModel = playerReadModel;
_playerSession = playerSession;
_bus = bus;
}
public static IEnumerable<object> Receptors(ICommandSender service)
{
var flow = new DomainSender(service);
yield return new ReplicationReceptor(flow);
yield return new RegistrationReceptor(flow);
// more senders go here
}
public static IEnumerable<object> Ports(ICommandSender service)
{
var flow = new DomainSender(service);
yield return new SecurityUserAggregateReplication(flow);
yield return new RegistrationPort(flow);
// more senders go here
}
public CommandQuit(GameWorld world, ICommandSender sender)
: base(world, sender)
{
Name = "quit";
Aliases.Add("exit");
RequiredPermission = CommandPermission.Admin;
}
public Command(GameWorld world, ICommandSender sender)
{
Aliases = new List<string>();
RequiredPermission = CommandPermission.User;
World = world;
Sender = sender;
}
public static IEnumerable<Func<CancellationToken, Task>> Tasks(ICommandSender service, IDocumentStore docs,
bool isTest)
{
var flow = new DomainSender(service);
// more tasks go here
yield break;
}
public AccountController(IFormsAuthentication formsAuthentication,
IUserRepository users, ICommandSender cmds)
{
_formsAuthentication = formsAuthentication;
_users = users;
_cmds = cmds;
}
public LoansController(ICommandSender command)
{
_command = command;
//TODO : Need to fix the denendency issue with the ILoansViewRepository!!
var connection = ConfigurationManager.AppSettings["MongoDBconnection"];
MongoContextProvider contextProvider = new MongoContextProvider(connection, "LoansViewRepository");
_loansViewRepository = new LoansViewRepository(contextProvider);
}
public void Setup()
{
_session = Substitute.For<IPlayerSession>();
_bus = Substitute.For<ICommandSender>();
_playerReadModel = Substitute.For<IPlayerReadModel>();
_target = new NativeUserActions(_session, _bus, _playerReadModel);
}
public FileDepositModule(ICommandSender sender)
{
Get["/deposit"] = _ =>
{
sender.Send(new FileDeposit());
return "File Deposit Made";
};
}
public CommandDie(GameWorld world, ICommandSender sender)
: base(world, sender)
{
Name = "die";
Aliases.Add("suicide");
Description = "Kill yourself.";
Usage = "die";
Hidden = true;
}
public override ICommand Create(ICommandSender sender, string[] args)
{
if (sender is Entity)
{
return new CommandDie(World, sender);
}
throw new UsageException();
}
public GestureToCommandAdapter(string GestureFilePath,ICommandSender sender, params IGestureDetector[] detectors)
{
_commandSender = sender;
_gestureDetectors = detectors;
_gestureToCommandMap = new Dictionary<string, IList<XbmcCommand>>();
foreach(var detector in _gestureDetectors)
detector.GestureDetected += OnGestureRecognized;
LoadAndRegisterGestures(GestureFilePath);
}
public CheckInPageViewModel(IReadModelFacade readModel, ICommandSender commandSender)
{
_readModel = readModel;
_commandSender = commandSender;
this.SaveCommand = new RelayCommand(ExecuteSave);
Messenger.Default.Register<Guid>(this, "RefreshPage", RefreshPage);
}
public CategoryController(
ICommandSender commandSender,
IGetAvailableCategoriesQueryService getAvailableCategoriesQueryService,
IGetAvailableCategoryByIdQueryService getAvailableCategoryByIdQueryService)
{
_commandSender = commandSender;
_getAvailableCategoriesQueryService = getAvailableCategoriesQueryService;
_getAvailableCategoryByIdQueryService = getAvailableCategoryByIdQueryService;
}
public UploadPhoto(Guid id, Guid user, Stream file, string filename, string contenttype, Privacy privacy, ICommandSender bus)
{
Id = id;
UserId = user;
File = file;
Filename = filename;
ContentType = contenttype;
Privacy = privacy;
Bus = bus;
}
public TransactionController(ILogger<TransactionController> logger,
IOptions<AppConfig> optionsAccessor,
ICommandSender commandSender,
IReadModelFacade readmodel)
{
_logger = logger;
_optionsAccessor = optionsAccessor.Value;
_readmodel = readmodel;
_commandSender = commandSender;
string conn = _optionsAccessor.MONGOLAB_URI;
}
public async Task SendMissedMessages(ICommandSender sender, SayPlace place, string target, int accountID, int maxCount = OfflineMessageResendCount)
{
using (var db = new ZkDataContext()) {
var acc = await db.Accounts.FindAsync(accountID);
await
db.LobbyChatHistories.Where(x => x.Target == target && x.SayPlace == place && x.Time >= acc.LastLogout)
.OrderByDescending(x => x.Time)
.Take(maxCount)
.OrderBy(x => x.Time)
.ForEachAsync(async (chatHistory) => { await sender.SendCommand(chatHistory.ToSay()); });
}
}
protected void ExamineInjury(ICommandSender examiner)
{
if (!Alive)
{
examiner.SendLine();
examiner.SendLine("{0}'s dead.", Pronoun.FirstCharToUpper());
}
else if (Hp < Attributes.MaxHp / 2)
{
examiner.SendLine();
examiner.SendLine("{0} looks injured.", Pronoun.FirstCharToUpper());
}
}
public RepositoryListViewModel(
ImportRepositoryCommand importRepositoryCommand,
Func<RepositoryListDto, RepositoryViewModel> repositoryFactory,
ICommandSender commandSender,
IGithubReadModel readModel)
{
_importRepositoryCommand = importRepositoryCommand;
_repositoryFactory = repositoryFactory;
_commandSender = commandSender;
_readModel = readModel;
_repositories = new ObservableCollection<RepositoryViewModel>();
_importRepositoryCommand.RepositoryImported += RepositoryImportedEventHandler;
Initialize();
}
public async Task SendMissedMessages(ICommandSender sender, SayPlace place, string target, int accountID, int maxCount = OfflineMessageResendCount)
{
using (var db = new ZkDataContext()) {
var acc = await db.Accounts.FindAsync(accountID);
await
db.LobbyChatHistories.Where(x => x.Target == target && x.SayPlace == place && x.Time >= acc.LastLogout)
.OrderByDescending(x => x.Time)
.Take(maxCount)
.OrderBy(x => x.Time)
.ForEachAsync(async (chatHistory) => { await sender.SendCommand(chatHistory.ToSay()); });
if (place == SayPlace.User) { // don't keep PMs longer than needed
db.LobbyChatHistories.DeleteAllOnSubmit(db.LobbyChatHistories.Where(x => x.Target == target && x.SayPlace == SayPlace.User).ToList());
db.SaveChanges();
}
}
}
/// <summary>
/// Enables message queuing.
/// </summary>
/// <param name="configuration">The <see cref="ProcessorConfiguration"/>.</param>
/// <param name="degreeOfParallelism">The maximum degree of parallelism.</param>
/// <param name="sender">The <see cref="ICommandSender"/> used to send commands.</param>
/// <param name="receiver">The <see cref="ICommandReceiver"/> used to receive commands.</param>
public static void EnableMessageQueuing(this ProcessorConfiguration configuration, int degreeOfParallelism, ICommandSender sender, ICommandReceiver receiver)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
var innerWorker = configuration.Services.GetCommandWorker();
configuration.Services.Replace(typeof(ICommandWorker), new CommandQueueWorker(innerWorker));
configuration.Services.Replace(typeof(ICommandSender), sender);
configuration.Services.Replace(typeof(ICommandReceiver), receiver);
configuration.RegisterForDispose(sender as IDisposable);
if (!object.ReferenceEquals(sender, receiver))
{
configuration.RegisterForDispose(receiver as IDisposable);
}
Action<ProcessorConfiguration> defaultInitializer = configuration.Initializer;
configuration.Initializer = originalConfig =>
{
MessageProcessor processor = null;
try
{
CommandHandlerSettings settings = new CommandHandlerSettings(originalConfig);
settings.Services.Replace(typeof(ICommandWorker), innerWorker);
var config = ProcessorConfiguration.ApplyHandlerSettings(settings, originalConfig);
config.Initializer = defaultInitializer;
processor = new MessageProcessor(config);
var commandReceiver = originalConfig.Services.GetCommandReceiver();
originalConfig.CommandBroker = new CommandRunner(processor, commandReceiver, degreeOfParallelism);
originalConfig.RegisterForDispose(processor);
processor = null;
}
finally
{
if (processor != null)
{
processor.Dispose();
}
}
defaultInitializer(originalConfig);
};
}
public void RunCommand(string command, ICommandSender sender)
{
try
{
ICommand commandObj = Parser.Parse(command, sender);
commandObj.Execute();
}
catch (CommandNotFoundException)
{
sender.SendLine("Invalid command.");
}
catch (UsageException)
{
sender.SendLine("Invalid usage.");
}
catch (InsufficientPermissionException)
{
sender.SendLine("Invalid permissions.");
}
}
public Task SendMissedMessagesAsync(ICommandSender sender,
SayPlace place,
string target,
int accountID,
int maxCount = MessageResendCount)
{
return Task.Run(async () =>
{
await sendHistorySemaphore.WaitAsync();
try
{
using (var db = new ZkDataContext())
{
var acc = db.Accounts.Find(accountID);
foreach (var entry in
db.LobbyChatHistories.Where(x => (x.Target == target) && (x.SayPlace == place) && (x.Time >= acc.LastLogout))
.OrderByDescending(x => x.Time)
.Take(maxCount)
.OrderBy(x => x.Time)) await sender.SendCommand(entry.ToSay());
if (place == SayPlace.User)
{
// don't keep PMs longer than needed
db.LobbyChatHistories.DeleteAllOnSubmit(
db.LobbyChatHistories.Where(x => (x.Target == target) && (x.SayPlace == SayPlace.User)).ToList());
db.SaveChanges();
}
}
}
catch (Exception ex)
{
Trace.TraceError("Error sending chat history: {0}", ex);
}
finally
{
sendHistorySemaphore.Release();
}
});
}
public ICommand Parse(string command, ICommandSender sender)
{
if (command == null)
return null;
command = command.Trim();
string[] args = command.Split(' ');
string commandName = args[0];
ICommandFactory commandFactory = GetCommandByName(commandName);
if (commandFactory != null)
return commandFactory.Create(sender, args);
List<Command> factoriesFound = GetCommandsByAlias(commandName);
if (factoriesFound.Count == 1)
return factoriesFound[0].Create(sender, args);
if (factoriesFound.Count == 0)
throw new CommandNotFoundException(commandName);
else
throw new SharedAliasException(commandName);
}
public void Examine(ICommandSender examiner)
{
examiner.SendLine(RantEngine.RunPattern("You are on \\a {0} tile.", Adjective));
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
Player player = Player.Get(((PlayerCommandSender)sender).SenderId);
if ((player.Team != Team.MTF && player.Team != Team.CHI) ||
!TrackingAndMethods.PlayersWithSubclasses.ContainsKey(player) ||
!TrackingAndMethods.PlayersWithSubclasses[player].Abilities.Contains(AbilityType.BackupCommand))
{
Log.Debug($"Player {player.Nickname} could not use the backup command", Subclass.Instance.Config.Debug);
response = "";
return(true);
}
SubClass subClass = TrackingAndMethods.PlayersWithSubclasses[player];
if (TrackingAndMethods.OnCooldown(player, AbilityType.BackupCommand, subClass))
{
Log.Debug($"Player {player.Nickname} failed to use the backup command", Subclass.Instance.Config.Debug);
TrackingAndMethods.DisplayCooldown(player, AbilityType.BackupCommand, subClass, "backup", Time.time);
response = "";
return(true);
}
if (!TrackingAndMethods.CanUseAbility(player, AbilityType.BackupCommand, subClass))
{
TrackingAndMethods.DisplayCantUseAbility(player, AbilityType.BackupCommand, subClass, "backup");
response = "";
return(true);
}
int min = subClass.IntOptions.ContainsKey("BackupMinSpawn") ? subClass.IntOptions["BackupMinSpawn"] : 3;
int max = subClass.IntOptions.ContainsKey("BackupMaxSpawn") ? subClass.IntOptions["BackupMaxSpawn"] : 7;
List <Player> spectators = Player.List.Where(p => p.Role == RoleType.Spectator).ToList();
if (spectators.Count == 0)
{
player.Broadcast(2, Subclass.Instance.Config.NoAvailableSpectators);
response = "";
return(true);
}
TrackingAndMethods.UseAbility(player, AbilityType.BackupCommand, subClass);
TrackingAndMethods.AddCooldown(player, AbilityType.BackupCommand);
int spawns = Mathf.Clamp((int)(rnd.NextDouble() * ((max - min) + 1)) + min, 0, spectators.Count);
bool isMTF = player.Team == Team.MTF;
int commanders = 1;
int lieutenants = 0;
int cadets = 0;
if (isMTF)
{
lieutenants = Mathf.Clamp(spawns - commanders, 0, 3);
cadets = spawns - lieutenants - commanders;
}
for (int i = 0; i < spawns; i++)
{
int index = rnd.Next(spectators.Count);
Player p = spectators[index];
spectators.RemoveAt(index);
if (!isMTF)
{
p.SetRole(RoleType.ChaosInsurgency);
}
else
{
if (commanders > 0)
{
p.SetRole(RoleType.NtfCommander);
commanders--;
}
else if (lieutenants > 0)
{
p.SetRole(RoleType.NtfLieutenant);
lieutenants--;
}
else
{
p.SetRole(RoleType.NtfCadet);
}
}
}
response = "";
return(true);
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
Updater.run = true;
response = "Updater launched, check server console for details";
return(true);
}
public NotesController(ICommandSender commandSender, INoteStore store)
{
this.commandSender = commandSender;
this.store = store;
}
public InventoryController(ICommandSender bus, IReadModelFacade readModel)
{
_bus = bus;
_readModel = readModel;
}
/// <summary>
/// Enables message queuing.
/// </summary>
/// <param name="configuration">The <see cref="ProcessorConfiguration"/>.</param>
/// <param name="degreeOfParallelism">The maximum degree of parallelism.</param>
/// <param name="sender">The <see cref="ICommandSender"/> used to send commands.</param>
/// <param name="receiver">The <see cref="ICommandReceiver"/> used to receive commands.</param>
public static void EnableMessageQueuing(this ProcessorConfiguration configuration, int degreeOfParallelism, ICommandSender sender, ICommandReceiver receiver)
{
if (configuration == null)
{
throw Error.ArgumentNull("configuration");
}
var innerWorker = configuration.Services.GetCommandWorker();
configuration.Services.Replace(typeof(ICommandWorker), new CommandQueueWorker(innerWorker));
configuration.Services.Replace(typeof(ICommandSender), sender);
configuration.Services.Replace(typeof(ICommandReceiver), receiver);
configuration.RegisterForDispose(sender as IDisposable);
if (!object.ReferenceEquals(sender, receiver))
{
configuration.RegisterForDispose(receiver as IDisposable);
}
Action <ProcessorConfiguration> defaultInitializer = configuration.Initializer;
configuration.Initializer = originalConfig =>
{
MessageProcessor processor = null;
try
{
CommandHandlerSettings settings = new CommandHandlerSettings(originalConfig);
settings.Services.Replace(typeof(ICommandWorker), innerWorker);
var config = ProcessorConfiguration.ApplyHandlerSettings(settings, originalConfig);
config.Initializer = defaultInitializer;
processor = new MessageProcessor(config);
var commandReceiver = originalConfig.Services.GetCommandReceiver();
originalConfig.CommandBroker = new CommandRunner(processor, commandReceiver, degreeOfParallelism);
originalConfig.RegisterForDispose(processor);
processor = null;
}
finally
{
if (processor != null)
{
processor.Dispose();
}
}
defaultInitializer(originalConfig);
};
}
protected override bool ExecuteParent(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
EventHandlers.LogCommandUsed((CommandSender)sender, EventHandlers.FormatArguments(arguments, 0));
if (!((CommandSender)sender).CheckPermission("at.dummy"))
{
response = "You do not have permission to use this command";
return(false);
}
Player Sender = Player.Get(((CommandSender)sender).ReferenceHub);
if (arguments.Count < 1)
{
response = "Usage:\ndummy ((player id / name) or (all / *)) (RoleType) (x value) (y value) (z value)" +
"\ndummy clear (player id / name) (minimum index) (maximum index)" +
"\ndummy clearall" +
"\ndummy count (player id / name) ";
return(false);
}
switch (arguments.At(0))
{
case "clear":
if (arguments.Count != 4)
{
response = "Usage: dummy clear (player id / name) (minimum index) (maximum index)\nNote: Minimum < Maximum, you can remove from a range of dummies a user spawns";
return(false);
}
Player Ply = Player.Get(arguments.At(1));
if (Ply == null)
{
response = $"Player not found: {arguments.At(1)}";
return(false);
}
if (!int.TryParse(arguments.At(2), out int Min) && Min < 0)
{
response = $"Invalid value for minimum index: {arguments.At(2)}";
return(false);
}
if (!int.TryParse(arguments.At(3), out int Max) && Max < 0)
{
response = $"Invalid value for maximum index: {arguments.At(3)}";
return(false);
}
if (Max < Min)
{
response = $"{Max} is not greater than {Min}";
return(false);
}
if (!Plugin.DumHubs.TryGetValue(Ply, out List <GameObject> objs))
{
response = $"{Ply.Nickname} has not spawned in any dummies in";
return(false);
}
if (Min > objs.Count)
{
response = $"{Min} (minimum) is higher than the number of dummies {Ply.Nickname} spawned! (Which is {objs.Count})";
return(false);
}
if (Max > objs.Count)
{
response = $"{Max} (maximum) is higher than the number of dummies {Ply.Nickname} spawned! (Which is {objs.Count})";
return(false);
}
Min = Min == 0 ? 0 : Min - 1;
Max = Max == 0 ? 0 : Max - 1;
for (int i = Min; i <= Max; i++)
{
UnityEngine.Object.Destroy(objs.ElementAt(i));
objs[i] = null;
}
objs.RemoveAll(r => r == null);
response = $"All dummies from {Min + 1} to {Max + 1} have been cleared from Player {Ply.Nickname}";
return(true);
case "clearall":
if (arguments.Count != 1)
{
response = "Usage: dummy clearall";
return(false);
}
foreach (KeyValuePair <Player, List <GameObject> > Dummy in Plugin.DumHubs)
{
foreach (GameObject Dum in Dummy.Value)
{
UnityEngine.Object.Destroy(Dum);
}
Dummy.Value.Clear();
}
Plugin.DumHubs.Clear();
response = $"All spawned dummies have now been removed";
return(true);
case "count":
if (arguments.Count != 2)
{
response = "Usage: dummy count (player id / name)";
return(false);
}
Player Plyr = Player.Get(arguments.At(1));
if (Plyr == null)
{
response = $"Player not found: {arguments.At(1)}";
return(false);
}
if (!Plugin.DumHubs.TryGetValue(Plyr, out List <GameObject> obj) || obj.Count == 0)
{
response = $"{Plyr.Nickname} has not spawned in any dummies in";
return(false);
}
response = $"{Plyr.Nickname} has spawned in {(obj.Count != 1 ? $"{obj.Count} dummies" : $"{obj.Count} dummy")}";
return(true);
public string[] OnCall(ICommandSender sender, string[] args)
{
AdminToolbox.AddMissingPlayerVariables();
Server server = PluginManager.Manager.Server;
if (args.Length > 0)
{
if (args[0].ToLower() == "all" || args[0].ToLower() == "*")
{
if (args.Length > 1)
{
if (bool.TryParse(args[1], out bool j))
{
int playerNum = 0;
foreach (Player pl in server.GetPlayers())
{
AdminToolbox.ATPlayerDict[pl.SteamId].dmgOff = j;
playerNum++;
}
return(new string[] { "Set " + playerNum + " player's \"No Dmg\" to " + j });
}
else
{
return new string[] { "Not a valid bool!" }
};
}
else
{
foreach (Player pl in server.GetPlayers())
{
AdminToolbox.ATPlayerDict[pl.SteamId].dmgOff = !AdminToolbox.ATPlayerDict[pl.SteamId].dmgOff;
}
return(new string[] { "Toggled all player's \"No Dmg\"" });
}
}
else if (args[0].ToLower() == "list" || args[0].ToLower() == "get")
{
string str = "\nPlayers with \"No Dmg\" enabled: \n";
List <string> myPlayerList = new List <string>();
foreach (Player pl in server.GetPlayers())
{
if (AdminToolbox.ATPlayerDict[pl.SteamId].dmgOff)
{
myPlayerList.Add(pl.Name);
}
}
if (myPlayerList.Count > 0)
{
myPlayerList.Sort();
foreach (var item in myPlayerList)
{
str += "\n - " + item;
}
}
else
{
str = "\nNo players with \"No Dmg\" enabled!";
}
return(new string[] { str });
}
Player myPlayer = API.GetPlayerFromString.GetPlayer(args[0]);
if (myPlayer == null)
{
return(new string[] { "Couldn't get player: " + args[0] });;
}
if (args.Length > 1)
{
bool changedValue = false;
if (args.Length > 2)
{
if (args[2].ToLower() == "godmode")
{
changedValue = true;
}
}
if (args[1].ToLower() == "on" || args[1].ToLower() == "true")
{
AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff = true;
}
else if (args[1].ToLower() == "off" || args[1].ToLower() == "false")
{
AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff = false;
}
if (changedValue)
{
AdminToolbox.ATPlayerDict[myPlayer.SteamId].godMode = AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff;
return(new string[] { myPlayer.Name + " No Dmg: " + AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff, myPlayer.Name + " Godmode: " + AdminToolbox.ATPlayerDict[myPlayer.SteamId].godMode });
}
return(new string[] { myPlayer.Name + " No Dmg: " + AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff });
}
else
{
AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff = !AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff;
return(new string[] { myPlayer.Name + " No Dmg: " + AdminToolbox.ATPlayerDict[myPlayer.SteamId].dmgOff });
}
}
else
{
return new string[] { GetUsage() }
};
}
}
public string[] OnCall(ICommandSender sender, string[] args)
{
PlayerXP.isToggled = !PlayerXP.isToggled;
return(new string[] { $"PlayerXP has been toggled {(PlayerXP.isToggled ? "on" : "off")}." });
}
private async Task Handle(ConfirmationSavedEvent evt, ICommandSender sender)
{
var hash = evt.TransactionHash;
var clientId = evt.ClientId;
var balanceChangeTransaction = await _balanceChangeTransactionsRepository.GetAsync(hash);
var operation = await _internalOperationsRepository.GetAsync(hash);
var tx = balanceChangeTransaction.First(x => x.ClientId == clientId);
ChaosKitty.Meow();
if (operation != null && operation.CommandType == BitCoinCommands.Transfer)
{
foreach (var id in operation.OperationIds)
{
if (string.IsNullOrWhiteSpace(id))
{
continue;
}
sender.SendCommand(new ProcessTransferCommand
{
TransferId = id
}, "transfer");
}
}
else
{
if (tx.IsCashIn(tx.Multisig))
{
var cashIns = tx.GetOperationSummary(tx.Multisig);
if (cashIns.Count > 1)
{
_log.WriteWarning(nameof(ConfirmationSavedEvent), evt, $"Multiple assets in a single transaction detected: {cashIns.ToJson()}");
// there should be only one asset in cash-in operation;
// code bellow with 'foreach' statement is kept for a while in case of obsolete request with multiple assets;
}
var skipBtc = (await _appGlobalSettingsRepositry.GetAsync()).BtcOperationsDisabled;
foreach (var cashIn in cashIns)
{
var asset = await GetAssetByBcnIdAsync(cashIn.Key);
ChaosKitty.Meow();
if (asset.Id == LykkeConstants.BitcoinAssetId && skipBtc)
{
sender.SendCommand(new SavePostponedCashInCommand
{
TransactionHash = tx.Hash
}, "cashin");
}
else
{
var sum = (cashIn.Value * Math.Pow(10, -asset.MultiplierPower)).TruncateDecimalPlaces(asset.Accuracy);
var cmd = new RegisterCashInOutCommand
{
Transaction = new Transaction {
Hash = tx.Hash, ClientId = tx.ClientId, Multisig = tx.Multisig, IsSegwit = tx.IsSegwit
},
Asset = new Asset {
Id = asset.Id, Accuracy = asset.Accuracy
},
Amount = sum,
CommandId = Guid.NewGuid().ToString("N")
};
sender.SendCommand(cmd, "cashin");
}
}
}
}
}
/// <inheritdoc />
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("ca.fscp"))
{
response = "Insufficient permission. Required: ca.fscp";
return(false);
}
response =
"Syntax: scpa (scp number) (death type)\nDeath Types: tesla, dclass, scientist, mtf, chaos, decont";
if (arguments.Count != 2)
{
return(false);
}
string scpNum = arguments.At(0);
if (!int.TryParse(scpNum, out _))
{
return(false);
}
for (int i = 0; i <= scpNum.Length; i += 2)
{
scpNum = scpNum.Insert(i, " ");
}
string deathCause = string.Empty;
switch (arguments.At(1))
{
case "t":
case "tesla":
deathCause = "Successfully Terminated by Automatic Security System";
break;
case "d":
case "dclass":
deathCause = "terminated by ClassD personnel";
break;
case "s":
case "science":
case "scientist":
deathCause = "terminated by science personnel";
break;
case "c":
case "chaos":
deathCause = "terminated by ChaosInsurgency";
break;
case "m":
case "mtf":
Player dummy = Player.List.FirstOrDefault(player => player.Role.Team == Team.MTF);
if (dummy == null)
{
response = "There are currently no alive MTF to mimic the unit of.";
return(false);
}
if (!Respawning.NamingRules.UnitNamingRules.TryGetNamingRule(
Respawning.SpawnableTeamType.NineTailedFox,
out Respawning.NamingRules.UnitNamingRule unitNamingRule))
{
deathCause = "Unknown";
}
else
{
deathCause = "CONTAINEDSUCCESSFULLY CONTAINMENTUNIT " + unitNamingRule.GetCassieUnitName(dummy.UnitName);
}
break;
case "decont":
deathCause = "Lost in Decontamination Sequence";
break;
}
if (string.IsNullOrEmpty(deathCause))
{
return(false);
}
Cassie.Message($"scp {scpNum} {deathCause}");
response = "Playing announcement.";
return(true);
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
throw new NotImplementedException();
if (!sender.CheckPermission("ast.playermgm"))
{
response = "You can't use this command, you don't have \"ast.playermgm\" permission.";
return(false);
}
if (arguments.Count < 1)
{
response = "Subcommands: clear (c), additem (ai), display(d)";
return(true);
}
else if (arguments.At(0) == "clear" || arguments.At(0) == "c")
{
if (arguments.Count > 1)
{
P Ply = P.Get(arguments.At(1));
if (Ply == null)
{
response = $"Player not found: {arguments.At(1)}";
return(false);
}
if (Ply.Role == RoleType.Spectator || Ply.Role == RoleType.None || Ply.Team == Team.SCP)
{
response = "You cannot clear the inventory of this player.";
return(false);
}
Ply.Inventory.Clear();
response = $"Succesfully cleared the inventory of {Ply.Nickname}";
return(true);
}
else
{
response = $"Clears the inventory of a player. Usage: {Command} c <user>";
return(true);
}
}
else if (arguments.At(0) == "additem" || arguments.At(0) == "ai")
{
if (arguments.Count > 1)
{
P Ply = P.Get(arguments.At(1));
if (Ply == null)
{
response = $"Player not found: {arguments.At(1)}";
return(false);
}
if (arguments.Count > 2)
{
}
else
{
response = "";
return(true);
}
}
else
{
response = $"Adds an item to the inventory of a player. Usage: {Command} ai <user> <item>";
return(true);
}
}
else
{
response = "Invalid subcommand. Subcommands: ";
return(false);
}
}
/// <summary> /// Checks a sender's permission. /// </summary> /// <param name="sender">The sender to be checked.</param> /// <param name="permission">The permission to be checked.</param> /// <returns>Returns a value indicating whether the user has the permission or not.</returns> public static bool CheckPermission(this ICommandSender sender, string permission) => CheckPermission(sender as CommandSender, permission);
public DomainSender(ICommandSender service)
{
_service = service;
}
protected AwaiterBase(ICommandSender commandSender) => _commandSender = commandSender;
protected override bool ExecuteParent(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
response =
"Please use a valid sub-command.\nEnable - enables the gamemode.\nDisable - disables the gamemode.";
return(false);
}
public TabController(ICommandSender commandSender)
{
_commandSender = commandSender;
}
protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
{
EventHandlers.LogCommandUsed((CommandSender)sender, EventHandlers.FormatArguments(arguments, 0));
if (!((CommandSender)sender).CheckPermission("at.tp"))
{
response = "You do not have permission to use this command";
return false;
}
if (arguments.Count < 1)
{
response = response = "\nUsage:\nposition ((player id / name) or (all / *)) (set) (x position) (y position) (z position)\nposition ((player id / name) or (all / *)) (get)\nposition ((player id / name) or (all / *))(add) (x, y, or z) (value)";
return false;
}
switch (arguments.At(0))
{
case "*":
case "all":
if (!Enum.TryParse(arguments.At(1), true, out PositionModifier Mod))
{
response = $"Invalid position modifier: {arguments.At(0)}";
return false;
}
switch (Mod)
{
case PositionModifier.Set:
if (arguments.Count != 5)
{
response = "Usage: position (all / *) (set) (x position) (y position) (z position)";
return false;
}
if (!float.TryParse(arguments.At(2), out float xval))
{
response = $"Invalid value for x position: {arguments.At(2)}";
return false;
}
if (!float.TryParse(arguments.At(3), out float yval))
{
response = $"Invalid value for x position: {arguments.At(3)}";
return false;
}
if (!float.TryParse(arguments.At(4), out float zval))
{
response = $"Invalid value for x position: {arguments.At(4)}";
return false;
}
if (Player.List.Count() == 0)
{
response = "There are no players currently online";
return true;
}
foreach (Player Ply in Player.List)
{
Ply.Position = new Vector3(xval, yval, zval);
}
response = $"All player's positions have been set to {xval} {yval} {zval}";
return true;
case PositionModifier.Get:
if (arguments.Count != 2)
{
response = "Usage: position (all / *) (get)";
return false;
}
StringBuilder PositionBuilder = StringBuilderPool.Shared.Rent();
if (Player.List.Count() == 0)
{
response = "There are no players currently online";
return true;
}
PositionBuilder.Append("\n");
foreach (Player Ply in Player.List)
{
PositionBuilder.Append(Ply.Nickname);
PositionBuilder.Append("'s (");
PositionBuilder.Append(Ply.Id);
PositionBuilder.Append(")");
PositionBuilder.Append(" position: ");
PositionBuilder.Append(Ply.Position.x);
PositionBuilder.Append(" ");
PositionBuilder.Append(Ply.Position.y);
PositionBuilder.Append(" ");
PositionBuilder.AppendLine(Ply.Position.z.ToString());
}
string Message = PositionBuilder.ToString();
StringBuilderPool.Shared.Return(PositionBuilder);
response = Message;
return true;
case PositionModifier.Add:
if (arguments.Count != 4)
{
response = "Usage: position (all / *) (add) (x, y, or z) (value)";
return false;
}
if (!Enum.TryParse(arguments.At(2), true, out VectorAxis Axis))
{
response = $"Invalid value for vector axis: {arguments.At(2)}";
return false;
}
if (!float.TryParse(arguments.At(3), out float val))
{
response = $"Invalid value for position: {arguments.At(3)}";
return false;
}
switch (Axis)
{
case VectorAxis.X:
foreach (Player Ply in Player.List)
Ply.Position = new Vector3(Ply.Position.x + val, Ply.Position.y, Ply.Position.z);
response = $"Every player's x position has been added by {val}";
return true;
case VectorAxis.Y:
foreach (Player Ply in Player.List)
Ply.Position = new Vector3(Ply.Position.x, Ply.Position.y + val, Ply.Position.z);
response = $"Every player's y position has been added by {val}";
return true;
case VectorAxis.Z:
foreach (Player Ply in Player.List)
Ply.Position = new Vector3(Ply.Position.x, Ply.Position.y, Ply.Position.z + val);
response = $"Every player's z position has been added by {val}";
return true;
}
break;
default:
response = "\nUsage:\nposition (all / *) (set) (x position) (y position) (z position)\nposition (all / *) (get)\nposition (all / *) (add) (x, y, or z) (value)";
return false;
}
break;
default:
Player Pl = Player.Get(arguments.At(0));
if (Pl == null)
{
response = $"Player not found: {arguments.At(0)}";
return false;
}
if (!Enum.TryParse(arguments.At(1), true, out PositionModifier Modf))
{
response = $"Invalid position modifier: {arguments.At(1)}";
return false;
}
switch (Modf)
{
case PositionModifier.Set:
if (arguments.Count != 5)
{
response = "Usage: position (player id / name) (set) (x position) (y position) (z position)";
return false;
}
if (!float.TryParse(arguments.At(2), out float xval))
{
response = $"Invalid value for x position: {arguments.At(2)}";
return false;
}
if (!float.TryParse(arguments.At(3), out float yval))
{
response = $"Invalid value for x position: {arguments.At(3)}";
return false;
}
if (!float.TryParse(arguments.At(4), out float zval))
{
response = $"Invalid value for x position: {arguments.At(4)}";
return false;
}
Pl.Position = new Vector3(xval, yval, zval);
response = $"Player {Pl.Nickname}'s positions have been set to {xval} {yval} {zval}";
return true;
case PositionModifier.Get:
if (arguments.Count != 2)
{
response = "Usage: position (player id / name) (get)";
return false;
}
response = $"Player {Pl.Nickname}'s ({Pl.Id}) position is {Pl.Position.x} {Pl.Position.y} {Pl.Position.z}";
return true;
case PositionModifier.Add:
if (arguments.Count != 4)
{
response = "Usage: position (player id / name) (add) (x, y, or z) (value)";
return false;
}
if (!Enum.TryParse(arguments.At(2), true, out VectorAxis Axis))
{
response = $"Invalid value for vector axis: {arguments.At(2)}";
return false;
}
if (!float.TryParse(arguments.At(3), out float val))
{
response = $"Invalid value for position: {arguments.At(2)}";
return false;
}
switch (Axis)
{
case VectorAxis.X:
Pl.Position = new Vector3(Pl.Position.x + val, Pl.Position.y, Pl.Position.z);
response = $"Player {Pl.Nickname}'s x position has been added by {val}";
return true;
case VectorAxis.Y:
Pl.Position = new Vector3(Pl.Position.x, Pl.Position.y + val, Pl.Position.z);
response = $"Player {Pl.Nickname}'s y position has been added by {val}";
return true;
case VectorAxis.Z:
Pl.Position = new Vector3(Pl.Position.x, Pl.Position.y, Pl.Position.z + val);
response = $"Player {Pl.Nickname}'s z position has been added by {val}";
return true;
}
break;
default:
response = "\nUsage:\nposition (player id / name) (set) (x position) (y position) (z position)\nposition (player id / name) (get)\nposition (player id / name) (add) (x, y, or z) (value)";
return false;
}
break;
}
response = "Something did not go right, the command should not reach this point";
return false;
}
public EpisodeDataController(ICommandSender commandSender, IQuerySender querySender)
{
_commandSender = commandSender;
_querySender = querySender;
}
public VendorService(ICommandSender commandService, IVendorRepository vendorRepository, ICustomerCacheStorage customerCacheStorage)
{
_commandService = commandService;
_vendorRepository = vendorRepository;
_customerCacheStorage = customerCacheStorage;
}
/// <inheritdoc/>
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
if (!sender.CheckPermission("uiu.spawn"))
{
response = "You don't have permission to execute this command. Required permission: uiu.spawn";
return(false);
}
Player player = Player.Get((sender as PlayerCommandSender).ReferenceHub);
switch (arguments.Count)
{
case 0:
{
if (IsUiu(player) && GetUIURole(player.Role) == UiuType.Leader)
{
response = "You are already an UIU Leader.";
return(false);
}
SpawnPlayer(player, UiuType.Leader);
response = "You are now a UIU Leader";
return(true);
}
case 1:
{
if (!Enum.TryParse(arguments.At(0), false, out UiuType uiuType))
{
response = $"{arguments.At(0)} cannot be parsed to any UiuType.";
return(false);
}
else
{
SpawnPlayer(player, uiuType);
response = $"{player.Nickname} is now an UIU {uiuType}.";
return(true);
}
}
case 2:
{
player = Player.Get(arguments.At(1));
if (player == null)
{
response = "Provided player is invalid. Please give player's id or nickname.";
return(false);
}
if (!Enum.TryParse(arguments.At(0), true, out UiuType uiuType))
{
response = $"{arguments.At(0)} cannot be parsed to any UiuType.";
return(false);
}
else
{
if (IsUiu(player) && GetUIURole(player.Role) == uiuType)
{
response = $"{player.Nickname} is already a UIU";
return(false);
}
SpawnPlayer(player, uiuType);
response = $"{player.Nickname} is now an UIU {uiuType}.";
return(true);
}
}
default: response = "Invalid number of arguments."; return(false);
}
}
public HomeController(ICommandSender commandSender, IReadModelFacade readmodel)
{
_readmodel = readmodel;
_commandSender = commandSender;
}
public string[] OnCall(ICommandSender sender, string[] args)
{
if (sender.IsPermitted(CommandAliases, out string[] denied))
// You are not required to override this method, as MCore has a default
// sending message using the usage specified in the constructor
protected override void SendUsageMessage(ICommandSender sender)
{
sender.SendMessage(ColorScheme.ERROR, "Usage!", ChatColor.DARK_RED + "That is not the correct usage? Use: " + this.info.Usage);
}
public string[] OnCall(ICommandSender sender, string[] args)
{
Server server = PluginManager.Manager.Server;
bool isPlayer()
{
if (sender is Player pl)
{
if (!string.IsNullOrEmpty(pl.SteamId))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
string ColoredBools(bool input)
{
if (isPlayer() && input)
{
return("<color=green>" + input + "</color>");
}
else if (isPlayer() && !input)
{
return("<color=red>" + input + "</color>");
}
else if (input)
{
return(input.ToString() + " ");
}
else
{
return(input.ToString());
}
}
if (server.GetPlayers().Count > 0)
{
Player myPlayer = (args.Length > 0) ? GetPlayerFromString.GetPlayer(args[0]) : null;
if (args.Length == 0)
{
if (sender is Player sendingPlayer)
{
myPlayer = sendingPlayer;
}
}
if (myPlayer == null)
{
return(new string[] { "Couldn't get player: " + args[0] });;
}
AdminToolbox.AddMissingPlayerVariables(new List <Player> {
myPlayer
});
AdminToolbox.AdminToolboxLogger.PlayerStatsFileManager(new List <Player> {
myPlayer
}, LogHandlers.PlayerFile.Write);
AdminToolbox.AdminToolboxPlayerSettings playerDict = (AdminToolbox.playerdict.ContainsKey(myPlayer.SteamId)) ? AdminToolbox.playerdict[myPlayer.SteamId] : new AdminToolbox.AdminToolboxPlayerSettings();
int remainingJailTime = ((int)playerDict.JailedToTime.Subtract(DateTime.Now).TotalSeconds >= 0) ? (int)playerDict.JailedToTime.Subtract(DateTime.Now).TotalSeconds : 0;
string remoteAdmin = "Player info: \n " +
"\n Player: (" + myPlayer.PlayerId + ") " + myPlayer.Name +
"\n - SteamID: " + myPlayer.SteamId + " - IP: " + myPlayer.IpAddress.Replace("::ffff:", string.Empty) +
"\n - Role: " + myPlayer.TeamRole.Role + " - Health: " + myPlayer.GetHealth() +
"\n - Server Rank: " + "<color=" + myPlayer.GetUserGroup().Color + ">" + myPlayer.GetRankName() + "</color>" +
"\n - AdminToolbox Toggables: " +
"\n - Godmode: " + ColoredBools(playerDict.godMode) + " - NoDmg: " + ColoredBools(playerDict.dmgOff) +
"\n - SpectatorOnly: " + ColoredBools(playerDict.spectatorOnly) + " - KeepSettings: " + ColoredBools(playerDict.keepSettings) +
"\n - BreakDoors: " + ColoredBools(playerDict.destroyDoor) + " - PlayerLockDown: " + ColoredBools(playerDict.lockDown) +
"\n - InstantKill: " + ColoredBools(playerDict.instantKill) +
"\n - IsJailed: " + ColoredBools(playerDict.isJailed) + " - Released In: " + remainingJailTime +
"\n - Stats:" +
"\n - Kills: " + playerDict.Kills + " - TeamKills: " + playerDict.TeamKills + " - Deaths: " + playerDict.Deaths +
"\n - Rounds Played: " + playerDict.RoundsPlayed + " - Playtime: " + (int)playerDict.minutesPlayed + " minutes" +
"\n - Position:" +
" - X:" + (int)myPlayer.GetPosition().x +
" Y:" + (int)myPlayer.GetPosition().y +
" Z:" + (int)myPlayer.GetPosition().z;
string[] playerStrings = new string[]
{
"\n Player: (" + myPlayer.PlayerId + ") " + myPlayer.Name,
" - SteamID: " + myPlayer.SteamId,
" - IP: " + myPlayer.IpAddress,
" - Server Rank: " + "<color=" + myPlayer.GetUserGroup().Color + ">" + myPlayer.GetRankName() + "</color>",
" - Role: " + myPlayer.TeamRole.Role,
" - Health: " + myPlayer.GetHealth(),
" - AdminToolbox Toggables: ",
" - Godmode: " + ColoredBools(playerDict.godMode),
" - NoDmg: " + ColoredBools(playerDict.dmgOff),
" - SpectatorOnly: " + ColoredBools(playerDict.spectatorOnly),
" - KeepSettings: " + ColoredBools(playerDict.keepSettings),
" - BreakDoors: " + ColoredBools(playerDict.destroyDoor),
" - PlayerLockDown: " + ColoredBools(playerDict.lockDown),
" - InstantKill: " + ColoredBools(playerDict.instantKill),
" - IsJailed: " + ColoredBools(playerDict.isJailed),
" - Released In: " + remainingJailTime,
" - Stats:" +
" - Kills: " + playerDict.Kills,
" - TeamKills: " + playerDict.TeamKills,
" - Deaths: " + playerDict.Deaths,
" - Rounds Played: " + playerDict.RoundsPlayed,
" - Playtime: " + playerDict.minutesPlayed + " minutes",
" - Position:",
" - X:"+ (int)myPlayer.GetPosition().x + " Y:" + (int)myPlayer.GetPosition().y + " Z:" + (int)myPlayer.GetPosition().z
};
//foreach (string str in playerStrings)
//{
// _maxlen = Math.Max(_maxlen, str.Length);
//}
_maxlen = 29;
string BuildTwoLiner(string str1, string str2 = "")
{
return(StringToMax(str1, _maxlen) + "|" + StringToMax(str2, _maxlen).PadLeft(LeftPadding));
}
string serverConsole = "\n\nPlayer: (" + myPlayer.PlayerId + ") " + myPlayer.Name + Environment.NewLine +
BuildTwoLiner(" - SteamID: " + myPlayer.SteamId, " - IP: " + myPlayer.IpAddress) + Environment.NewLine +
BuildTwoLiner(" - Server Rank: " + "<color=" + myPlayer.GetUserGroup().Color + ">" + myPlayer.GetRankName() + "</color>") +
BuildTwoLiner(" - Role: " + myPlayer.TeamRole.Role, " - Health: " + myPlayer.GetHealth()) + Environment.NewLine +
BuildTwoLiner(" - AdminToolbox Toggables: ") + Environment.NewLine +
BuildTwoLiner(" - Godmode: " + ColoredBools(playerDict.godMode), " - NoDmg: " + ColoredBools(playerDict.dmgOff)) + Environment.NewLine +
BuildTwoLiner(" - SpectatorOnly: " + ColoredBools(playerDict.spectatorOnly), " - KeepSettings: " + ColoredBools(playerDict.keepSettings)) + Environment.NewLine +
BuildTwoLiner(" - BreakDoors: " + ColoredBools(playerDict.destroyDoor), " - PlayerLockDown: " + ColoredBools(playerDict.lockDown)) + Environment.NewLine +
BuildTwoLiner(" - InstantKill: " + ColoredBools(playerDict.instantKill)) + Environment.NewLine +
BuildTwoLiner(" - IsJailed: " + ColoredBools(playerDict.isJailed), " - Released In: " + remainingJailTime) + Environment.NewLine +
BuildTwoLiner(" - Stats:") + Environment.NewLine +
BuildTwoLiner(" - Kills: " + playerDict.Kills, " - TeamKills: " + playerDict.TeamKills) + Environment.NewLine +
BuildTwoLiner(" - Deaths: " + playerDict.Deaths) + Environment.NewLine +
BuildTwoLiner(" - Playtime: " + playerDict.minutesPlayed + " minutes", " - Rounds Played: " + playerDict.RoundsPlayed) + Environment.NewLine +
BuildTwoLiner(" - Position:") + Environment.NewLine +
BuildTwoLiner(" - X:" + (int)myPlayer.GetPosition().x + " Y:" + (int)myPlayer.GetPosition().y + " Z:" + (int)myPlayer.GetPosition().z) + Environment.NewLine;
if (!isPlayer())
{
return new string[] { serverConsole }
}
;
else
{
return new string[] { remoteAdmin }
};
}
return(new string[] { GetUsage() });
}
}
public HomeController(ICommandSender commandSender, IReadModelFacade readmodel)
{
_readmodel = readmodel;
_commandSender = commandSender;
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
string target;
int range;
if (!sender.CheckPermission("scputils.playsessions"))
{
response = "<color=red> You need a higher administration level to use this command!</color>";
return(false);
}
if (arguments.Count < 2)
{
response = $"<color=yellow>Usage: {Command} <player name/id> <number of previous sessions to print(0 prints the last one)> </color>";
return(false);
}
else
{
target = arguments.Array[1].ToString();
}
int.TryParse(arguments.Array[2], out range);
Player databasePlayer = target.GetDatabasePlayer();
if (databasePlayer == null)
{
response = "<color=yellow>Player not found on Database or Player is loading data!</color>";
return(false);
}
if (range < 0)
{
response = "<color=red>You have to specify a positive number!</color>";
return(false);
}
if (databasePlayer == null)
{
response = "<color=yellow>Player not found on Database or Player is loading data!</color>";
return(false);
}
StringBuilder message = new StringBuilder($"[{databasePlayer.Name} ({databasePlayer.Id}@{databasePlayer.Authentication})]");
message.AppendLine();
for (int i = 0; i <= range; i++)
{
if (databasePlayer.PlaytimeSessionsLog.Count() - i - 1 >= 0)
{
var session = databasePlayer.PlaytimeSessionsLog.ElementAt(databasePlayer.PlaytimeSessionsLog.Count() - i - 1);
message.AppendLine($"Session Start: [ {session.Key} ] - Session End: [ { session.Value} ] - Duration: [ {(session.Value - session.Key).ToString(@"hh\:mm\:ss")} ]");
}
else
{
message.Append($"Limit reached! No more data about this player.");
response = $"{message}";
return(true);
}
}
response = $"{message}";
return(true);
}
public FormController(IViewModelReader reader, ICommandSender sender)
{
_viewModelReader = reader;
_commandSender = sender;
}
protected override bool ExecuteParent(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
EventHandlers.LogCommandUsed((CommandSender)sender, EventHandlers.FormatArguments(arguments, 0));
if (!((CommandSender)sender).CheckPermission("at.grenade"))
{
response = "You do not have permission to use this command";
return(false);
}
if (arguments.Count < 2 || arguments.Count > 3)
{
response = "Usage: grenade ((player id / name) or (all / *)) (GrenadeType) (grenade time)";
return(false);
}
switch (arguments.At(0))
{
case "*":
case "all":
if (!Enum.TryParse(arguments.At(1), true, out GrenadeType GType))
{
response = $"Invalid value for grenade name: {arguments.At(1)}";
return(false);
}
if (GType == GrenadeType.Scp018)
{
Cassie.Message("pitch_1.5 xmas_bouncyballs", true, false);
foreach (Player Pl in Player.List)
{
if (Pl.Role == RoleType.Spectator || Pl.Role == RoleType.None)
{
continue;
}
EventHandlers.SpawnGrenadeOnPlayer(Pl, GType, 0);
}
}
else
{
if (arguments.Count != 3)
{
response = "Usage: grenade ((player id / name) or (all / *)) (GrenadeType) (grenade time)";
return(false);
}
if (!float.TryParse(arguments.At(2), out float Time))
{
response = $"Invalid value for grenade timer: {arguments.At(2)}";
return(false);
}
foreach (Player Pl in Player.List)
{
if (Pl.Role == RoleType.Spectator || Pl.Role == RoleType.None)
{
continue;
}
EventHandlers.SpawnGrenadeOnPlayer(Pl, GType, Time);
}
}
response = $"You spawned a {GType.ToString().ToLower()} on everyone";
return(true);
default:
Player Ply = Player.Get(arguments.At(0));
if (Ply == null)
{
response = $"Player not found: {arguments.At(0)}";
return(false);
}
else if (Ply.Role == RoleType.Spectator || Ply.Role == RoleType.None)
{
response = $"Player {Ply.Nickname} is not a valid class to spawn a grenade on";
return(false);
}
if (!Enum.TryParse(arguments.At(1), true, out GrenadeType Type))
{
response = $"Invalid value for grenade name: {arguments.At(1)}";
return(false);
}
if (Type == GrenadeType.Scp018)
{
EventHandlers.SpawnGrenadeOnPlayer(Ply, Type, 0);
}
else
{
if (arguments.Count != 3)
{
response = "Usage: grenade ((player id / name) or (all / *)) (GrenadeType) (grenade time)";
return(false);
}
if (!float.TryParse(arguments.At(2), out float Time))
{
response = $"Invalid value for grenade timer: {arguments.At(2)}";
return(false);
}
EventHandlers.SpawnGrenadeOnPlayer(Ply, Type, Time);
}
response = $"You spawned a {Type.ToString().ToLower()} on {Ply.Nickname}";
return(true);
}
}
public static IEnumerable<object> BuildEventProcessors(ICommandSender commandSender)
{
yield return new Processes.RegistrationProcess(commandSender);
yield break;
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_commandResponse = new CommandResponse {
Events = _events
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_domainStore = new Mock <IDomainStore>();
_domainStore
.Setup(x => x.Save(_aggregate.GetType(), _createAggregate.AggregateRootId, _createAggregate, new List <IDomainEvent>()
{
_aggregateCreated
}));
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.Validate(_createAggregate));
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_commandResponse);
_domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_domainCommandResponse);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
.Returns(_domainCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_domainStore.Object,
_validationService.Object,
_optionsMock.Object);
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
var ply = Player.Get((sender as CommandSender)?.SenderId);
if (ply.Role != RoleType.Scp079)
{
response = PluginMain.Instance.Config.NotScp079;
return(false);
}
if (arguments.Count != 1)
{
response = "Команды: \n.079 blackout - выключает свет во всём комплексе \n.079 flash - делает вспышку камерой \n.079 cancel - останавливает боеголовку\n.079 find - Находит случайного игрока на камерах";
return(false);
}
var args = arguments.Array;
switch (args[1].ToLower())
{
case "blackout":
if (ply.Level < PluginMain.Instance.Config.BlackoutLvl)
{
response = PluginMain.Instance.Config.InsufLVL;
return(false);
}
if (PluginMain.Instance.IsBlackoutOnCooldown)
{
response = PluginMain.Instance.Config.OnCooldown;
return(false);
}
PluginMain.Instance.IsBlackoutOnCooldown = true;
Timing.CallDelayed(PluginMain.Instance.Config.BlackoutCooldown, () => PluginMain.Instance.IsBlackoutOnCooldown = false);
if (ply.Energy >= PluginMain.Instance.Config.BlackoutEnergy)
{
ply.Energy -= PluginMain.Instance.Config.BlackoutEnergy;
}
else
{
response = PluginMain.Instance.Config.NoEnergyMsg;
return(false);
}
Map.TurnOffAllLights(PluginMain.Instance.Config.BlackoutTime);
response = PluginMain.Instance.Config.AbilitySuccess;
try
{
CommsHack.AudioAPI.API.PlayFileRaw($"{Paths.Configs}/CommsHackAudio/{PluginMain.Instance.Config.BlackoutSoundPath}", PluginMain.Instance.Config.BlackoutSoundVolume);
}
catch (Exception x)
{
Log.Info("CommsHack is not installed, skipping method call, playing cassie instead");
Log.Error(x);
Cassie.Message(PluginMain.Instance.Config.BlackoutCassie, true);
}
return(true);
case "help":
response = "Команды: \n.079 blackout - выключает свет во всём комплексе \n.079 flash - делает вспышку камерой \n.079 cancel - останавливает боеголовку\n.079 find - Находит случайного игрока на камерах";
return(true);
case "cancel":
if (Warhead.IsInProgress)
{
if (PluginMain.Instance.Handler.IsNukeOnCooldown)
{
response = PluginMain.Instance.Config.CancelCooldownMsg;
return(false);
}
if (ply.Level < PluginMain.Instance.Config.WarheadCancelLvl)
{
response = PluginMain.Instance.Config.InsufLVL;
return(true);
}
if (ply.Energy >= PluginMain.Instance.Config.WarheadCancelEnergy)
{
ply.Energy -= PluginMain.Instance.Config.WarheadCancelEnergy;
}
else
{
response = PluginMain.Instance.Config.NoEnergyMsg;
return(true);
}
if (Warhead.IsLocked)
{
response = PluginMain.Instance.Config.IsNotInProgressOrLocked;
return(false);
}
Timing.RunCoroutine(PluginMain.Instance.Handler.Nuke(), "nuke");
response = PluginMain.Instance.Config.AbilitySuccess;
return(true);
}
else
{
response = PluginMain.Instance.Config.IsNotInProgressOrLocked;
return(true);
}
case "flash":
if (ply.Level < PluginMain.Instance.Config.FlashLVL)
{
response = PluginMain.Instance.Config.InsufLVL;
return(true);
}
if (PluginMain.Instance.IsFlashOnCooldown)
{
response = PluginMain.Instance.Config.OnCooldown;
return(false);
}
if (ply.Energy >= PluginMain.Instance.Config.FlashEnergy)
{
ply.Energy -= PluginMain.Instance.Config.FlashEnergy;
}
else
{
response = PluginMain.Instance.Config.NoEnergyMsg;
return(true);
}
var pos = ply.ReferenceHub.scp079PlayerScript.currentCamera.transform.position;
ply.SpawnFlashGrenade(pos, 0.5f);
PluginMain.Instance.IsFlashOnCooldown = true;
Timing.CallDelayed(PluginMain.Instance.Config.FlashCooldown, () => PluginMain.Instance.IsFlashOnCooldown = false);
foreach (var player in Player.List)
{
if (player.Role == RoleType.Scp106 && Vector3.Distance(player.Position, pos) <= 75)
{
player.EnableEffect(Exiled.API.Enums.EffectType.Blinded, 2);
break;
}
}
response = PluginMain.Instance.Config.AbilitySuccess;
return(true);
case "find":
if (ply.Level < PluginMain.Instance.Config.FindLVL)
{
response = PluginMain.Instance.Config.InsufLVL;
return(false);
}
if (ply.Energy >= PluginMain.Instance.Config.FindEnergy)
{
ply.Energy -= PluginMain.Instance.Config.FindEnergy;
}
else
{
response = PluginMain.Instance.Config.NoEnergyMsg;
return(false);
}
if (Player.List.Where(x => x.Team != Team.SCP && x.Team != Team.TUT && x.Team != Team.RIP).IsEmpty())
{
response = PluginMain.Instance.Config.FindNoPlayers;
return(false);
}
Player trackingPlayer = Player.List.Where(x => x.Team != Team.SCP && x.Team != Team.TUT && x.Team != Team.RIP).ToList()[UnityEngine.Random.Range(0, Player.List.Where(x => x.Team != Team.SCP && x.Team != Team.TUT && x.Team != Team.RIP).Count() - 1)];
Camera079 nearestCamera = Scp079PlayerScript.allCameras.First();
float distance = float.MaxValue;
float ADistance;
foreach (var cam in Scp079PlayerScript.allCameras)
{
ADistance = Vector3.Distance(cam.transform.position, trackingPlayer.Position);
if (ADistance < distance)
{
nearestCamera = cam;
distance = ADistance;
}
}
ply.ReferenceHub.scp079PlayerScript.CmdSwitchCamera(nearestCamera.cameraId, false);
UnityEngine.Random.InitState((int)DateTime.Now.Ticks);
response = $"Отслеживаю: {trackingPlayer.DisplayNickname ?? trackingPlayer.Nickname} - {trackingPlayer.Role}";
return(false);
default:
response = "Команды:\n.079 blackout - выключает свет во всём комплексе \n.079 flash - делает вспышку камерой \n.079 cancel - останавливает боеголовку\n.079 find - Находит случайного игрока на камерах";
return(false);
}
}
/// <summary> /// コマンドを実行します。 /// </summary> /// <param name="source">コマンドのアクティベート元となる投稿。</param> /// <param name="args">引数。</param> /// <param name="body">コマンドに渡された、名前を除く全データ。</param> /// <returns>リプライに含まれる文字列。<c>null</c> を返した場合リプライが行われません。</returns> public abstract Task <string> OnActivatedAsync(ICommandSender sender, Server core, IShell shell, string[] args, string body);
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
var permission = false;
var perPermission = false;
if (arguments.Array == null || arguments.Array.Length < 2)
{
response = "Usage: event <event name>";
return(true);
}
var command = arguments.Array[1].Trim().ToLower().Replace(" ", "");
if (sender is PlayerCommandSender player)
{
permission = player.CheckPermission("easyevents.use");
perPermission = player.CheckPermission("easyevents.event." + command);
}
else
{
permission = true;
perPermission = true;
}
if (EasyEvents.Singleton.Config.PerEventPermissions && !perPermission)
{
response = "You do not have permission to run this event.";
return(true);
}
if (!permission)
{
response = "You do not have permission to run this command.";
return(true);
}
if (!ScriptStore.Scripts.ContainsKey(command))
{
response = "Event \"" + command + "\" does not exist!";
return(true);
}
if (!ScriptStore.Scripts.TryGetValue(command, out var text))
{
response = "Event \"" + command + "\" does not exist!";
return(true);
}
if (Exiled.API.Features.Round.IsStarted)
{
response = "Events can only be ran before the round is started.";
return(true);
}
if (ScriptActions.scriptData.eventRan)
{
response = "Only one event can be ran per round. Restart the round to run this event.";
return(true);
}
try
{
ScriptHandler.RunScript(text);
response = "Event \"" + command + "\" started successfully";
ScriptActions.scriptData.eventRan = true;
Loader.Plugins.FirstOrDefault(pl => pl.Name == "ScpStats")?.Assembly?.GetType("SCPStats.EventHandler")?.GetField("PauseRound")?.SetValue(null, true);
return(true);
}
catch (Exception e)
{
response = e.ToString();
return(true);
}
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
string target;
if (!sender.CheckPermission("scputils.playerinfo"))
{
target = Exiled.API.Features.Player.Get(((CommandSender)sender).SenderId).ToString().Split(new string[] { " " }, StringSplitOptions.None)[2];
}
else
{
if (arguments.Count < 1)
{
response = $"<color=yellow>Usage: {Command} <player name/id></color>";
return(false);
}
else
{
target = arguments.Array[1].ToString();
}
}
Player databasePlayer = target.GetDatabasePlayer();
if (databasePlayer == null)
{
response = $"<color=yellow>Player not found on Database or Player is loading data!</color>";
return(false);
}
string text = $"<color=green>\n[{databasePlayer.Name} ({databasePlayer.Id}@{databasePlayer.Authentication})]\n\n" +
$"Total SCP Suicides/Quits: [ {databasePlayer.ScpSuicideCount} ]\n" +
$"Total SCP Suicides/Quits Kicks: [ {databasePlayer.TotalScpSuicideKicks} ]\n" +
$"Total SCP Suicides/Quits Bans: [ {databasePlayer.TotalScpSuicideBans} ]\n" +
$"Total Games played as SCP: [ {databasePlayer.TotalScpGamesPlayed} ]\n" +
$"Total Suicides/Quits Percentage: [ {Math.Round(databasePlayer.SuicidePercentage, 2)}% ]\n" +
$"First Join: [ {databasePlayer.FirstJoin} ]\n" +
$"Last Seen: [ {databasePlayer.LastSeen} ]\n" +
$"Custom Color: [ {databasePlayer.ColorPreference} ]\n" +
$"Custom Name: [ {databasePlayer.CustomNickName} ]\n" +
$"Temporarily Badge: [ {databasePlayer.BadgeName} ]\n" +
$"Badge Expire: [ {databasePlayer.BadgeExpire} ]\n" +
// $"Previous Badge: [ {databasePlayer.PreviousBadge} ]\n" +
$"Hide Badge: [ {databasePlayer.HideBadge} ]\n" +
$"Asn Whitelisted: [ {databasePlayer.ASNWhitelisted} ]\n" +
$"Keep Flag: [ {databasePlayer.KeepPreferences} ]\n" +
$"Ignore DNT: [ {databasePlayer.IgnoreDNT} ]\n" +
$"Total Playtime: [ { new TimeSpan(0, 0, databasePlayer.PlayTimeRecords.Values.Sum()).ToString() } ]</color>";
if (databasePlayer.IsRestricted())
{
text += $"\n<color=red>User account is currently restricted</color>\nReason: [ {databasePlayer.Restricted.Values.Last()} ]\nExpire: [ {databasePlayer.Restricted.Keys.Last()} ]";
}
if (databasePlayer.RoundBanLeft >= 1)
{
text += $"\n<color=red>User account is currently SCP-Banned:</color>\nRound(s) left: [ {databasePlayer.RoundBanLeft} ]";
}
response = text;
return(true);
}
