internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var name = arguments.FirstOrDefault() ?? ".";
var command = "info";
if (arguments.Count() > 1)
{
command = arguments.ElementAt(1).Trim();
}
if (command.Equals("info"))
{
return(this.showInfo(sender, domain, name));
}
else if (command.Equals("setstatus"))
{
string status = null;
if (arguments.Count() > 2)
{
status = arguments.ElementAt(2).Trim();
}
return(this.status(sender, domain, name, status));
}
else
{
return(this.dispatcher.Error(domain, Strings.UNKNOWN_COMMAND, command));
}
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var hoursOnline = TimeSpan.FromSeconds(sender.User.TotalSecondsOnline).TotalHours;
var message = String.Format(Strings.YOU_HAVE_BEEN_ONLINE_FOR_HOURS, hoursOnline < 1 ? "< 1" : Convert.ToUInt32(hoursOnline).ToString());
return(this.dispatcher.Output(domain, message));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() != 1)
{
return(this.dispatcher.InvalidUsage(domain));
}
var name = arguments.First().Trim();
lock (this.manager)
{
var player = this.manager.World.FindPlayer(name);
if (player != null)
{
return(sender.Stream.Write(Responses.PrivateChatMessage(player, Strings.PLAYER_IS_ONLINE_YOU_CAN_MESSAGE_HIM)));
}
else
{
try
{
var character = this.characterService.Find(name);
return(sender.Stream.Write(Responses.ServerPrivateChatMessage(character.Name, character.Id, Strings.PLAYER_IS_OFFLINE_MESSAGES_WILL_BE_DELIVERED)));
}
catch (CharacterService.NotFoundException)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, name));
}
}
}
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (domain.IsWorld && (!this.manager.CheckWorldMessagePermission(sender) || !this.lobbyService.CheckSlowmodeTimerInWorld(sender)))
{
return(Nothing.Resolved());
}
if (domain.IsLocal && sender.CurrentLobby != null && !this.lobbyService.CheckSlowmodeTimer(sender.CurrentLobby, sender))
{
return(Nothing.Resolved());
}
var contents = tag + " " + String.Join(" ", arguments);
var messageToSend = "";
var components = contents.Split(new char[] { '\\', '/', ';' }).Select(s => s.Trim()).Where(s => s.Any());
var selfSufficient = contents.StartsWith("/me") && components.Count() == 1;
foreach (var substring in components)
{
if (substring.StartsWith("me"))
{
messageToSend += substring.Substring(2);
}
else if (substring.StartsWith("я"))
{
messageToSend += substring.Substring(1);
}
else
{
messageToSend += String.Format(" \"{0}\"", substring);
}
}
messageToSend = messageToSend.Trim();
var text = String.Format("{0}/me {1}", domain.Identifier, messageToSend);
var commands = domain.Recipients.Select(r => r.Stream.Write(Responses.Message(sender, text))).ToList();
if (!selfSufficient)
{
if (domain.IsPrivate)
{
if (domain.Recipients.Count() > 0)
{
var recipient = domain.Recipients.First();
var selfText = String.Format("{0}/me {1} {2} {3}", domain.Identifier, this.manager.Monogram, sender.Name, messageToSend);
commands.Add(sender.Stream.Write(Responses.Message(recipient, selfText)));
}
}
else
{
var selfText = String.Format("{0}/me {1} {2}", domain.Identifier, sender.Name, messageToSend);
commands.Add(sender.Stream.Write(Responses.ServerMessage(this.manager, selfText)));
}
}
return(new CombinedPromise <Nothing>(commands));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var promises = new List <IPromise <Nothing> >();
foreach (var line in Strings.SHELL_HELP_TEXT.Split('\n'))
{
promises.Add(this.dispatcher.Output(domain, line));
}
return(new CombinedPromise <Nothing>(promises));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
string query = null;
if (arguments.Count() > 0)
{
query = arguments.First();
}
var builder = new StringBuilder("Online players: ");
var output = new List <IPromise <Nothing> >();
List <PlayerHandle> players;
lock (this.manager)
{
players = this.manager.World.Players.ToList();
}
players.Sort((a, b) => a.CurrentLobbyIdentifier.CompareTo(b.CurrentLobbyIdentifier));
builder.AppendFormat("(total {0})", players.Count());
string lastLobbyIdentifier = null;
foreach (var player in players)
{
if (query != null && !player.Name.Contains(query))
{
continue;
}
if (player.CurrentLobbyIdentifier != lastLobbyIdentifier)
{
output.Add(this.dispatcher.Output(domain, builder.ToString()));
builder.Clear();
builder.AppendFormat("{0}: ", player.CurrentLobbyIdentifier);
}
lastLobbyIdentifier = player.CurrentLobbyIdentifier;
builder.AppendFormat(" {0},", player.Name);
if (builder.Length > 200)
{
output.Add(this.dispatcher.Output(domain, builder.ToString()));
builder.Clear();
}
}
if (builder.ToString().Trim().Count() > 0)
{
output.Add(this.dispatcher.Output(domain, builder.ToString()));
}
return(new CombinedPromise <Nothing>(output));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var didChange = true;
switch (arguments.FirstOrDefault())
{
case null:
didChange = false;
break;
case "reset":
sender.SexPermissions = SexPermissionMode.Default;
break;
default:
try
{
sender.SexPermissions = SexPermissionModeUtils.FromString(arguments.ElementAt(0));
}
catch (ArgumentException) { return(dispatcher.InvalidUsage(domain)); }
catch (IndexOutOfRangeException) { return(dispatcher.InvalidUsage(domain)); }
break;
}
var message = "";
if (didChange)
{
message += Strings.YOUR_MODE_HAS_BEEN_CHANGED + " ";
}
var explanation = "";
switch (sender.SexPermissions)
{
case SexPermissionMode.Default:
explanation = Strings.SEX_MODE_DESCRIPTION_DEFAULT;
break;
case SexPermissionMode.Deny:
explanation = Strings.SEX_MODE_DESCRIPTION_DENY;
break;
case SexPermissionMode.AllowPose:
explanation = Strings.SEX_MODE_DESCRIPTION_POSEAGREE;
break;
}
message += String.Format(Strings.CURRENT_SEX_MODE, sender.SexPermissions.Identifier(), explanation);
return(this.dispatcher.Output(domain, message));
}
internal static PlayerHandle GetPlayer(string input, CommandDomain domain, ChatManager manager)
{
if (input.Equals(".") && domain.IsPrivate)
{
return(domain.Recipients.FirstOrDefault());
}
else
{
lock (manager)
{
return(manager.World.FindPlayer(input.Trim()));
}
}
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
int cap = 6;
if (arguments.Count() > 0)
{
try
{
cap = Convert.ToInt32(arguments.First());
}
catch (FormatException) { }
}
if (domain.IsWorld && !this.manager.CheckWorldMessagePermission(sender))
{
return(Nothing.Resolved());
}
var value = this.random.Next(cap + 1);
var messages = new List <Message>
{
Responses.ServerMessage(this.manager, domain.Identifier + String.Format(Strings.PLAYER_ROLLED_OUT_OF, sender.Name, value, cap))
};
var promises = new List <IPromise <Nothing> >();
foreach (var msg in messages)
{
if (domain.IsPrivate)
{
if (domain.Recipients.Count() > 0)
{
var recipient = domain.Recipients.First();
promises.Add(sender.Stream.Write(Responses.PrivateChatMessage(recipient, String.Format(Strings.PLAYER_ROLLED_OUT_OF, sender.Name, value, cap))));
promises.Add(recipient.Stream.Write(Responses.PrivateChatMessage(sender, String.Format(Strings.PLAYER_ROLLED_OUT_OF_VERIFY, sender.Name, value, cap))));
}
}
else
{
promises.Add(sender.Stream.Write(msg));
}
promises.AddRange(domain.Recipients.Select(r => r.Stream.Write(msg)));
}
return(new CombinedPromise <Nothing>(promises));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() == 0 || tag.Equals("/aalert") && arguments.Count() < 2)
{
return(this.dispatcher.InvalidUsage(domain));
}
string message = "";
PlayerHandle[] players = null;
lock (this.manager)
{
if (tag.Equals("/aalert"))
{
var player = CommandUtils.GetPlayer(arguments.First(), domain, this.manager);
if (player == null)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, arguments.First()));
}
players = new PlayerHandle[] { player };
message = String.Join(" ", arguments.Skip(1));
}
else
{
players = this.manager.World.Players.ToArray();
message = String.Join(" ", arguments);
}
}
var promises = new List <IPromise <Nothing> >();
foreach (var player in players)
{
try
{
promises.Add(this.loginServer.Emit(player.Token, "alert", message));
}
catch (LoginServerListener.NotFoundException)
{
promises.Add(player.Stream.Write(Responses.MakeshiftAlert(message)));
}
}
return(new CombinedPromise <Nothing>(promises));
}
internal IPromise <Nothing> Output(CommandDomain domain, string format, params object[] arguments)
{
var text = String.Format(format, arguments);
var sender = domain.Sender;
if (domain.IsPrivate)
{
if (domain.Recipients.Count() > 0)
{
var recipient = domain.Recipients.First();
text = String.Format("{0}/me {1} {2}", domain.Identifier, this.manager.Monogram, text);
return(sender.Stream.Write(Responses.Message(recipient, text)));
}
}
return(sender.Stream.Write(Responses.ServerDirectMessage(this.manager, text)));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() < 1)
{
return(this.dispatcher.InvalidUsage(domain));
}
var name = arguments.ElementAt(0);
var reason = CommandUtils.GetText(arguments.Skip(1)) ?? Strings.REASON_NONE;
if (name.Equals("\\all"))
{
List <PlayerHandle> players;
lock (this.manager)
{
players = new List <PlayerHandle>(this.manager.World.Players);
}
foreach (var handle in players)
{
try
{
this.manager.Sink(this.manager.KickPlayer(handle, reason));
}
catch (Exception e)
{
Log.Warning("Failed to kick player during kick-all: {exception}", e);
}
}
return(Nothing.Resolved());
}
else
{
PlayerHandle player = CommandUtils.GetPlayer(arguments.FirstOrDefault() ?? ".", domain, this.manager);
if (player == null)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, arguments.First()));
}
return(this.manager.KickPlayer(player, reason)
.Then(a => this.dispatcher.Output(domain, Strings.PLAYER_HAS_BEEN_KICKED, arguments.First())));
}
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var builder = new StringBuilder(Strings.ONLINE_PLAYERS_COLON);
lock (this.manager)
{
foreach (var item in this.manager.World.Lobbies)
{
string name = item.Value.Name;
if (name != null)
{
builder.AppendFormat(" {0} ({1}),", name, item.Value.Players.Count());
}
}
}
var response = builder.ToString();
return(this.dispatcher.Output(domain, response.Substring(0, response.Length - 1)));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
#if !DEBUG
try
{
#endif
this.config.LoadConfiguration();
this.userRoomService.LoadPermanentRooms();
return(this.dispatcher.Output(domain, Strings.CONFIGURATION_FILE_RELOADED));
#if !DEBUG
}
catch (Configuration.LoadException e)
{
Log.Warning("Failed to reload config (stage {stage}): {exception}", e.Stage, e.UnderlyingException);
return(this.dispatcher.Error(domain, Strings.FAILED_TO_RELOAD_CONFIGURATION + e));
}
#endif
}
internal IPromise <Nothing> status(PlayerHandle sender, CommandDomain domain, string name, string status)
{
PlayerHandle player = CommandUtils.GetPlayer(name, domain, this.manager);
if (player != null)
{
name = player.Name;
}
Character character;
try
{
character = this.characterService.Find(name);
}
catch (CharacterService.NotFoundException)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, name));
}
User user = null;
try
{
user = this.loginService.FindUser(character.UserId);
}
catch (LoginService.NotFoundException) {
return(this.dispatcher.Error(domain, Strings.USER_HAS_NOT_BEEN_FOUND_FOR_PLAYER));
}
if (user != null && user.AdminFlags > 0)
{
return(this.dispatcher.Error(domain, Strings.FORBIDDEN));
}
this.loginService.UpdateStatus(user, status);
return(this.dispatcher.Output(domain, Strings.STATUS_FOR_PLAYER_HAS_BEEN_SET, name, status));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() < 1 || (arguments.ElementAt(0) == "priority" && arguments.Count() < 2))
{
return(this.dispatcher.InvalidUsage(domain));
}
var command = arguments.ElementAt(0);
if (command.Equals("priority"))
{
var id = arguments.ElementAt(1).Trim();
var room = this.manager.World.FindUserRoom(id);
if (room == null)
{
return(this.dispatcher.Error(domain, Strings.ROOM_HAS_NOT_BEEN_FOUND, id));
}
room.IsPrioritized = !room.IsPrioritized;
return(this.dispatcher.Output(domain, room.IsPrioritized ? Strings.ROOM_NOW_PRIORITIZED : Strings.ROOM_NOW_NOT_PRIORITIZED));
}
else if (command.Equals("close"))
{
var id = arguments.ElementAt(1).Trim();
var room = this.manager.World.FindUserRoom(id);
if (room == null)
{
return(this.dispatcher.Error(domain, Strings.ROOM_HAS_NOT_BEEN_FOUND, id));
}
return(this.userRoomService.CloseRoom(room).Then(a => this.dispatcher.Output(domain, Strings.ROOM_CLOSED)));
}
else
{
return(this.dispatcher.Error(domain, Strings.UNKNOWN_COMMAND, command));
}
}
internal IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string message)
{
Log.Debug("Shell dispatches command from {name}: {cmd}", sender.Digest, message);
string[] components = message.Split(' ');
string tag = components.First();
foreach (var command in this.registeredCommands)
{
if (command.WouldDispatch(tag, components.Skip(1)))
{
if (command.HasPermissionToExecute(sender))
{
try
{
return(command.Dispatch(sender, domain, tag, components.Skip(1)));
}
catch (Exception e)
{
#if DEBUG
throw e;
#else
Log.Error("Exception occured during shell command {cmd} dispath from {player}: {exception}", message, sender.Digest, e);
return(this.Error(domain, Strings.INTERNAL_SERVER_ERROR));
#endif
}
}
else
{
return(this.Error(domain, Strings.ADMIN_NOT_AUTHENTICATED));
}
}
}
Log.Debug("Unkown shell command from {player} - {command}", sender.Digest, message);
return(this.Error(domain, Strings.UNKNOWN_COMMAND_SEE_HELP));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
if (arguments.Count() < 1 || ((arguments.ElementAt(0).Equals("sex") || arguments.First().Equals("prompt")) && arguments.Count() < 2))
{
return(this.dispatcher.InvalidUsage(domain));
}
var userRoom = this.manager.World.FindUserRoom(sender);
if (userRoom == null)
{
return(this.dispatcher.Error(domain, Strings.YOU_DONT_CURRENTLY_OWN_A_ROOM));
}
var command = arguments.ElementAt(0);
if (command.Equals("persist"))
{
if (!this.config.DanglingRoom.Enabled)
{
return(this.dispatcher.Error(domain, Strings.THIS_FEATURE_IS_NOT_ENABLED));
}
userRoom.IsSemiPersistent = true;
var message = String.Format(Strings.ROOM_IS_NOW_PERSISTENT, this.config.DanglingRoom.Timeout.TotalMinutes);
return(this.dispatcher.Output(domain, message));
}
else if (command.Equals("close"))
{
return(this.userRoomService.CloseRoom(userRoom)
.Then((a) => this.dispatcher.Output(domain, Strings.ROOM_CLOSED)));
}
else if (command.Equals("sex"))
{
userRoom.IsSexAllowed = !arguments.ElementAtOrDefault(1).Equals("forbid");
return(this.dispatcher.Output(domain, userRoom.IsSexAllowed ? Strings.SEX_IS_NOW_ALLOWED_IN_ROOM : Strings.SEX_IS_NOW_FORBIDDEN_IN_ROOM));
}
else if (command.Equals("prompt"))
{
var contents = String.Join(" ", arguments.Skip(1));
var lines = contents.Split('\\');
if (lines.Count() > Room.PromptMaxLines)
{
return(this.dispatcher.Error(domain, Strings.MAXIMUM_LINE_COUNT_EXCEEDED, Room.PromptMaxLines));
}
var builder = new StringBuilder();
foreach (var line in contents.Split('\\'))
{
if (line.Length > Room.PromptMaxLineLength)
{
return(this.dispatcher.Error(domain, Strings.MAXIMUM_LINE_LENGTH_EXCEEDED, Room.PromptMaxLineLength));
}
builder.AppendLine(line);
}
userRoom.Prompt = builder.ToString();
return(this.dispatcher.Output(domain, Strings.ROOM_PROMPT_HAS_BEEN_SET));
}
else if (command.Equals("slowmode"))
{
string newChatMode = null;
var value = arguments.ElementAtOrDefault(1);
switch (value)
{
case "reset":
userRoom.IsMuted = false;
userRoom.SlowmodeInterval = TimeSpan.Zero;
newChatMode = Strings.CHAT_MODE_NO_RESTRICTIONS;
break;
case "mute":
userRoom.IsMuted = true;
userRoom.SlowmodeInterval = TimeSpan.Zero;
newChatMode = Strings.CHAT_MODE_MUTED;
break;
case null:
if (userRoom.IsMuted)
{
newChatMode = Strings.CHAT_MODE_MUTED;
}
else if (userRoom.SlowmodeInterval == TimeSpan.Zero)
{
newChatMode = Strings.CHAT_MODE_NO_RESTRICTIONS;
}
else
{
newChatMode = String.Format(Strings.CHAT_MODE_SLOWMODE, userRoom.SlowmodeInterval);
}
break;
default:
try
{
userRoom.IsMuted = false;
userRoom.SlowmodeInterval = TimeSpan.FromSeconds(Convert.ToDouble(value));
newChatMode = String.Format(Strings.CHAT_MODE_SLOWMODE, userRoom.SlowmodeInterval);
}
catch (FormatException)
{
return(this.dispatcher.Error(domain, Strings.INVALID_AMOUNT));
}
break;
}
return(this.dispatcher.Output(domain, Strings.CURRENT_CHAT_MODE, newChatMode));
}
else
{
return(this.dispatcher.Error(domain, Strings.UNKNOWN_COMMAND, command));
}
}
internal IPromise <Nothing> showInfo(PlayerHandle sender, CommandDomain domain, string name)
{
PlayerHandle player = CommandUtils.GetPlayer(name, domain, this.manager);
if (player != null)
{
name = player.Name;
}
Character character;
try
{
character = this.characterService.Find(name);
}
catch (CharacterService.NotFoundException)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, name));
}
User user = null;
try
{
user = this.loginService.FindUser(character.UserId);
}
catch (LoginService.NotFoundException) { }
if (user != null && (user.AdminFlags > 0 && !sender.AdminOptions.HasFlag(AdminFlags.AdminPlayerManagement)))
{
return(this.dispatcher.Error(domain, Strings.FORBIDDEN));
}
var messages = new List <string>();
messages.Add(String.Format("Player {0} ({1})", name, character.Id));
if (player == null)
{
messages.Add(String.Format("Last seen at {0}", character.LastLogin));
}
else
{
messages.Add(String.Format("Currently online ({0}) from {1}", player.CurrentLobbyIdentifier, player.Stream.ConnectionEndpoint));
}
if (user != null)
{
messages.Add(String.Format("User {0} ({1})", user.Username, user.Id));
messages.Add(String.Format("Last logged: {0}", user.LastSeenAt));
messages.Add(String.Format("Signed up: {0}", user.CreatedAt));
messages.Add(String.Format("Total time online: {0} hours", TimeSpan.FromSeconds(user.TotalSecondsOnline).TotalHours));
messages.Add(String.Format("Currency: {0}", user.Currency));
if (user.Status != null)
{
messages.Add(String.Format("Status: {0}", user.Status));
}
if (user.AdminFlags > 0)
{
messages.Add(String.Format("Is admin (flags {0})", user.AdminFlags));
}
}
return(new CombinedPromise <Nothing>(messages.Select((m) => this.dispatcher.Output(domain, m))));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
try
{
var playerName = arguments.ElementAt(0).Trim();
var amount = Convert.ToInt32(arguments.ElementAt(1).Trim());
PlayerHandle[] players;
lock (this.manager)
{
if (playerName.Equals("\\world"))
{
players = this.manager.World.Players.ToArray();
}
else if (playerName.Equals("\\lobby"))
{
if (sender.CurrentLobby == null)
{
return(this.dispatcher.Error(domain, Strings.YOU_ARE_NOT_IN_LOBBY));
}
players = sender.CurrentLobby.Players.ToArray();
}
else
{
var player = CommandUtils.GetPlayer(playerName, domain, this.manager);
if (player == null)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, playerName));
}
players = new PlayerHandle[] { player };
}
}
if (this.config.Currency.Enabled == false)
{
return(this.dispatcher.Error(domain, Strings.CURRENCY_IS_NOT_ENABLED));
}
foreach (var player in players)
{
try
{
this.giftService.ChangeCurrency(player.User, amount);
}
catch (GiftsService.NotEnoughCurrencyException e)
{
Log.Warning("Failed to gift money as admin: {exception}", e);
}
}
var message = String.Format(Strings.YOU_HAVE_BEEN_GIFTED_COINS_FROM_ADMIN, amount);
return(new CombinedPromise <Nothing>(players.Select(p => p.Stream.Write(Responses.ServerDirectMessage(this.manager, message))))
.Then(a => this.dispatcher.Output(domain, Strings.DONE)));
}
catch (Exception e)
{
if (e is FormatException || e is ArgumentOutOfRangeException)
{
return(this.dispatcher.InvalidUsage(domain));
}
else
{
throw e;
}
}
}
internal IPromise <Nothing> Error(CommandDomain domain, string format, params object[] arguments)
{
return(this.Output(domain, format, arguments));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
try
{
if (this.config.Currency.Enabled == false)
{
return(this.dispatcher.Error(domain, Strings.CURRENCY_IS_NOT_ENABLED));
}
var recipientName = ".";
bool recepientless = false;
uint amount;
try
{
// single argument - amount
amount = Convert.ToUInt32(arguments.ElementAt(0).Trim());
recepientless = true;
}
catch (FormatException)
{
// two arguments
recipientName = arguments.ElementAt(0);
amount = Convert.ToUInt32(arguments.ElementAt(1).Trim());
}
PlayerHandle recipient = CommandUtils.GetPlayer(recipientName, domain, this.manager);
if (recipient == null || recipient.User.Id == sender.User.Id)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, recipientName));
}
this.giftsService.TransferCurrency(sender.User, recipient.User, amount);
var reason = CommandUtils.GetText(arguments.Skip(recepientless ? 1 : 2));
var reasonText = reason != null ? ", \"" + reason + "\"" : "";
var senderMessage = String.Format(Strings.TRANSFERRED_COINS_TO, amount, recipient.Name, this.giftsService.GetCurrency(sender.User));
var recipientMessage = String.Format(Strings.PLAYER_SENT_YOU_COINS, sender.Name, amount, reasonText, this.giftsService.GetCurrency(recipient.User));
var localMessage = String.Format(Strings.GAVE_COINS_TO, sender.Name, amount, recipient.Name);
var promises = new List <IPromise <Nothing> >
{
this.dispatcher.Output(domain, senderMessage),
recipient.Stream.Write(Responses.ServerDirectMessage(this.manager, recipientMessage))
};
if (tag.Equals("/give"))
{
if (sender.CurrentLobby != null && this.lobbyService.CheckSlowmodeTimer(sender.CurrentLobby, sender))
{
var localMsg = Responses.ServerLocalMessage(this.manager, localMessage);
promises.Add(sender.Stream.Write(localMsg));
promises.AddRange(domain.Recipients.Select(r => r.Stream.Write(localMsg)));
}
}
return(new CombinedPromise <Nothing>(promises));
}
catch (GiftsService.NotEnoughCurrencyException)
{
return(this.dispatcher.Error(domain, Strings.NOT_ENOUGH_COINS));
}
catch (Exception e)
{
if (e is FormatException || e is ArgumentOutOfRangeException)
{
return(this.dispatcher.Error(domain, Strings.INVALID_AMOUNT));
}
else
{
throw e;
}
}
}
internal IPromise <Nothing> InvalidUsage(CommandDomain domain)
{
return(this.Error(domain, Strings.INVALID_USAGE));
}
internal abstract IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments);
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
var currentLobby = sender.CurrentLobby;
if (currentLobby == null || !currentLobby.IsUserRoom)
{
return(this.dispatcher.Error(domain, Strings.YOU_ARE_NOT_IN_ROOM));
}
if (!this.userRoomService.PlayerCanModerateRoom(sender, currentLobby.UserRoom))
{
Log.Information("Player {sender} attempted to run /expel, but didn't have permission for that", sender.Digest);
return(this.dispatcher.Error(domain, Strings.YOU_DONT_HAVE_PERMISSION_TO_MODERATE_ROOM));
}
var userRoom = currentLobby.UserRoom;
string name;
uint duration;
try
{
try
{
// single argument - duration
name = ".";
duration = UInt32.Parse(arguments.ElementAt(0).Trim());
}
catch (ArgumentOutOfRangeException)
{
// no arguments
name = ".";
duration = 0;
}
catch (FormatException)
{
// single or two arguments
name = arguments.First().Trim();
if (arguments.Count() > 1)
{
duration = UInt32.Parse(arguments.ElementAt(1).Trim());
}
else
{
duration = 0;
}
}
}
catch (ArgumentOutOfRangeException)
{
return(this.dispatcher.InvalidUsage(domain));
}
catch (FormatException)
{
return(this.dispatcher.InvalidUsage(domain));
}
if (name.Equals("\\all"))
{
Log.Information("Player {sender} expelling everyone from user room {room}", sender.Digest, userRoom.Identifier);
return(this.userRoomService.ExpellAll(userRoom));
}
PlayerHandle player = CommandUtils.GetPlayer(name, domain, this.manager);
if (player == null || player.Character.Equals(sender.Character) || player.Character.Id == userRoom.OwnerId)
{
return(this.dispatcher.Error(domain, Strings.PLAYER_NOT_FOUND, name));
}
if (duration > this.config.Expel.MaxDuration.TotalMinutes)
{
return(this.dispatcher.Error(domain, Strings.DURATION_CANT_BE_MORE_MINUTES, this.config.Expel.MaxDuration.TotalMinutes));
}
if (sender.CurrentLobby == null || !sender.CurrentLobby.IsUserRoom)
{
return(this.dispatcher.Error(domain, Strings.YOU_SHOULD_BE_IN_THE_ROOM_TO_MODERATE_IT));
}
Log.Information("Player {sender} expelling player {player} from user room {room} for {duration} m.", sender.Digest, player.Digest, userRoom.Identifier, duration);
return(this.userRoomService.ExpelPlayer(player, userRoom, TimeSpan.FromMinutes(duration))
.Then(a => this.dispatcher.Output(domain, Strings.PLAYER_HAS_BEEN_EXPELLED)));
}
internal override IPromise <Nothing> Dispatch(PlayerHandle sender, CommandDomain domain, string tag, IEnumerable <string> arguments)
{
return(this.dispatcher.Output(domain, Strings.YOU_CURRENTLY_HAVE_COINTS, this.giftService.GetCurrency(sender.User)));
}
