public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
Random r = new Random();
int rolledHeads = 0;
int rolledTails = 0;
if (parameters.Count == 0)
{
string result = r.NextDouble() >= 0.5 ? "Heads" : "Tails";
messageCallback.Invoke($"{ColorCoder.Username(evt.InvokerName)} flipped a coin... it show {ColorCoder.Bold(result)}");
if (result == "Heads")
{
rolledHeads = 1;
}
else
{
rolledTails = 1;
}
}
else
{
if (RollCount <= 0)
{
messageCallback.Invoke($"Why would you want to flip that, {ColorCoder.Username(evt.InvokerName)}...");
return;
}
else if (RollCount > 10000000)
{
string inEuro = "" + RollCount / 100;
messageCallback.Invoke($"Even with 1-Cent coins that would be {inEuro:0.##} EUR. I doubt you will ever have that many coins to flip, {ColorCoder.Username(evt.InvokerName)} :^)");
return;
}
for (int i = 0; i < RollCount; i++)
{
if ((i % 2 == 0 && r.NextDouble() >= 0.5) || (i % 2 == 1 && r.NextDouble() <= 0.5))
{
rolledHeads++;
}
else
{
rolledTails++;
}
}
messageCallback.Invoke($"{ColorCoder.Username(evt.InvokerName)} flipped {ColorCoder.Bold(""+ RollCount)} coins... they showed {ColorCoder.Bold($"Heads {rolledHeads}")} and {ColorCoder.Bold($"Tails {rolledTails}")} times");
}
Parent.StatSettings.CoinflipHeads += rolledHeads;
Parent.StatSettings.CoinflipTails += rolledTails;
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
string action = parameters[0];
string targetUser = parameters[1];
Client target = Parent.Client.GetClientByNamePart(targetUser);
Group group = null;
if (action == "add" || action == "remove")
{
group = AccessManager.GetGroupByName(parameters[2]);
if (group == null)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"The group named '{ColorCoder.Bold(parameters[2])}' was not found"));
return;
}
}
if (action == "add")
{
bool success = AccessManager.AddUserGroup(target.UniqueId, group);
if (success)
{
messageCallback.Invoke(ColorCoder.Success($"{ColorCoder.Username(target.Nickname)} was added to the group '{ColorCoder.Bold(group.DisplayName)}'"));
}
else
{
messageCallback.Invoke(ColorCoder.ErrorBright($"{ColorCoder.Username(target.Nickname)} is already in the group '{ColorCoder.Bold(group.DisplayName)}'"));
}
}
else if (action == "remove")
{
bool success = AccessManager.RemoveUserGroup(target.UniqueId, group);
if (success)
{
messageCallback.Invoke(ColorCoder.Success($"{ColorCoder.Username(target.Nickname)} was removed from the group '{ColorCoder.Bold(group.DisplayName)}'"));
}
else
{
messageCallback.Invoke(ColorCoder.ErrorBright($"{ColorCoder.Username(target.Nickname)} was not in the group '{ColorCoder.Bold(group.DisplayName)}'"));
}
}
else if (action == "list")
{
List <Group> groups = AccessManager.GetUserGroups(target.UniqueId);
string toPrint = $"{ColorCoder.Username(target.Nickname)} has the following groups:";
foreach (Group printGroup in groups)
{
toPrint += $"\n\t- {printGroup.DisplayName}";
}
messageCallback.Invoke(toPrint);
}
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
string targetUid = evt.InvokerUniqueId;
string targetName = evt.InvokerName;
if (TargetNamePart != null)
{
Client target = Parent.Client.GetClientByNamePart(TargetNamePart);
targetUid = target.UniqueId;
targetName = target.Nickname;
}
CooldownManager.ResetCooldowns(targetUid);
messageCallback.Invoke(ColorCoder.Success($"Reset all cooldowns for {ColorCoder.Username(targetName)}"));
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
int lower = 1;
int upper = 100;
if (parameters.Count == 1)
{
upper = int.Parse(parameters[0]);
}
else if (parameters.Count == 2)
{
lower = int.Parse(parameters[0]);
upper = int.Parse(parameters[1]);
}
int range = upper - lower;
Random r = new Random();
int rolled = lower + (r.Next(range + 1));
messageCallback.Invoke($"{ColorCoder.Username(evt.InvokerName)} rolled a '{ColorCoder.Bold(rolled.ToString())}'");
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
// +----------------------+
// | Administrative Block |
// +----------------------+
if (IsAdministrativeCommand)
{
if (AdminAction == "add-file")
{
AddPlaysound(AdminPlaysoundName, AdminPlaysoundPrice, AdminPlaysoundFileName, AdminPlaysoundSource, messageCallback);
}
else if (AdminAction == "add-yt")
{
}
else if (AdminAction == "remove")
{
RemovePlaysound(AdminPlaysoundName, messageCallback);
}
else if (AdminAction == "add-modifier")
{
}
else if (AdminAction == "list-devices")
{
string devices = string.Join("\n\t", AudioHelper.GetAudioDevices());
messageCallback.Invoke($"All audio devices:\n\t{devices}");
}
else if (AdminAction == "stop-sounds")
{
int killed = 0;
foreach (Process p in AllStartedSoundProcesses)
{
if (!p.HasExited)
{
p.Kill();
killed++;
}
}
AllStartedSoundProcesses.Clear();
messageCallback.Invoke(ColorCoder.ErrorBright($"Killed {ColorCoder.Bold($"'{killed}'")} audio process(es)"));
}
return;
}
if (parameters.Count == 2 && parameters[0] == "price")
{
int price = CalculateYoutubePlaysoundCost(PriceLookupDuration);
messageCallback.Invoke($"Cost for {ColorCoder.Bold($"'{PriceLookupDuration}'")} seconds of a youtube video: {ColorCoder.Currency(price)}");
return;
}
// +----------------------+
// | Pagination |
// +----------------------+
if (HasRequestedPagination)
{
int entriesPerPage = Settings.PlaysoundsSoundsPerPage;
int maxPage = (int)Math.Ceiling((double)Settings.PlaysoundsSavedSounds.Count / entriesPerPage);
if (RequestedPage < 1 || RequestedPage > maxPage)
{
messageCallback.Invoke($"The page '{RequestedPage}' is not in the valid range of [1 to {maxPage}]!");
return;
}
int pageIndex = (int)RequestedPage - 1;
int skipValues = pageIndex * entriesPerPage;
List <Playsound> thisPage = Settings.PlaysoundsSavedSounds.OrderBy(ps => ps.BasePrice).ThenBy(ps => ps.Name).Skip(skipValues).Take(entriesPerPage).ToList();
string toPrint = "";
foreach (Playsound listSound in thisPage)
{
toPrint += $"\n'{listSound.Name}'\t({listSound.BasePrice} {Settings.EcoPointUnitName})";
}
toPrint += $"\n\t\t\t{ColorCoder.Bold($"-\tPage ({RequestedPage}/{maxPage})\t-")}";
toPrint += $"\n\nTo switch pages write '{Settings.ChatCommandPrefix}{command} <1/2/3/...>'";
messageCallback.Invoke(toPrint);
return;
}
if (evt.TargetMode != TSClient.Enums.MessageMode.Channel)
{
messageCallback.Invoke(ColorCoder.Error("Playsounds can only be used in channel chats!"));
return;
}
Client myClient = Parent.Client.GetClientById(Parent.MyClientId);
if (Parent.Client.IsClientOutputMuted(myClient))
{
messageCallback.Invoke(ColorCoder.Error("This doesn't work right now..."));
return;
}
if (Parent.Client.IsClientInputMuted(myClient))
{
messageCallback.Invoke(ColorCoder.Error("Host is muted, playsound can still be played but others won't hear it (@Panther)"));
}
CooldownManager.ThrowIfCooldown(evt.InvokerUniqueId, "command:playsounds");
// +-------------------------+
// | Playback of local files |
// +-------------------------+
if (!CheckValidModifiers(ManualModifiers, messageCallback))
{
return;
}
double speed = 1.0, pitch = 1.0, volume = 1.0;
if (SelectedModifier != null)
{
Dictionary <string, double> modifiers = Settings.PlaysoundsModifiers[SelectedModifier];
if (modifiers.ContainsKey(ModifierNameSpeed))
{
speed = modifiers[ModifierNameSpeed];
}
if (modifiers.ContainsKey(ModifierNamePitch))
{
pitch = modifiers[ModifierNamePitch];
}
if (modifiers.ContainsKey(ModifierNameVolume))
{
volume = modifiers[ModifierNameVolume];
}
}
if (ManualModifiers != null)
{
if (ManualModifiers.ContainsKey(ModifierNameSpeed))
{
speed = ManualModifiers[ModifierNameSpeed];
}
if (ManualModifiers.ContainsKey(ModifierNamePitch))
{
pitch = ManualModifiers[ModifierNamePitch];
}
if (ManualModifiers.ContainsKey(ModifierNameVolume))
{
volume = ManualModifiers[ModifierNameVolume];
}
}
Dictionary <string, double> actualModifiers = new Dictionary <string, double>()
{
[ModifierNameSpeed] = speed,
[ModifierNamePitch] = pitch,
[ModifierNameVolume] = volume,
};
double priceFactor = GetPriceFactorForModifiers(actualModifiers);
int basePrice;
string filePath;
double baseDuration;
string playingSoundStr;
if (SourceIsYoutube)
{
// +----------------------+
// | Youtube fetching |
// +----------------------+
if (SoundSource.ToLower().StartsWith("[url]"))
{
SoundSource = Utils.RemoveTag(SoundSource, "url");
}
string title = "";
string youtubeUrl = AudioHelper.IsYouTubeVideoUrl(SoundSource);
if (youtubeUrl != null)
{
lock (YoutubeDownloadLock) {
if (IsLoadingYoutubeAudio)
{
string loadingStr = LoadingPercentDone == -1 ? "download not yet started" : $"{LoadingPercentDone:0.##}%";
messageCallback.Invoke(ColorCoder.ErrorBright($"Chill, I'm still loading another clip... ({loadingStr})"));
return;
}
IsLoadingYoutubeAudio = true;
}
string videoId = youtubeUrl.Substring(youtubeUrl.IndexOf($"v=") + 2, 11);
try {
(filePath, title) = AudioHelper.LoadYoutubeVideo(videoId, (int)YoutubeStartTime, (int)(YoutubeEndTime - YoutubeStartTime) + 1, new ProgressSaver());
Parent.UpdateYoutubeFolderSize();
} catch (ArgumentException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"Error with youtube video: {ex.Message}"));
lock (YoutubeDownloadLock) {
IsLoadingYoutubeAudio = false;
LoadingPercentDone = -1;
}
return;
}
lock (YoutubeDownloadLock) {
IsLoadingYoutubeAudio = false;
LoadingPercentDone = -1;
}
}
else
{
messageCallback.Invoke(ColorCoder.ErrorBright($"The URL is not a youtube link..."));
return;
}
baseDuration = AudioHelper.GetAudioDurationInSeconds(filePath);
if (double.IsNaN(baseDuration))
{
messageCallback.Invoke(ColorCoder.ErrorBright($"Couldn't get audio duration from file '{filePath}'"));
return;
}
basePrice = CalculateYoutubePlaysoundCost(baseDuration);
if (baseDuration <= 60 && Settings.PlaysoundsYoutubeOnePointEvent)
{
basePrice = 1;
}
playingSoundStr = ColorCoder.SuccessDim($" Playing YouTube clip {ColorCoder.Bold($"'{title}'")} [{TimeSpan.FromSeconds((int)baseDuration)}].");
}
else
{
Playsound sound;
if (SoundSource == "random")
{
Random r = new Random();
sound = Settings.PlaysoundsSavedSounds.FindAll(ps => Math.Ceiling(ps.BasePrice * priceFactor) <= EconomyManager.GetBalanceForUser(evt.InvokerUniqueId)).OrderBy(ps => r.Next()).First();
}
else
{
List <Playsound> sounds = Settings.PlaysoundsSavedSounds.FindAll(ps => ps.Name.ToLower().Contains(SoundSource.ToLower()));
//Fix for matching the exact sound name
Playsound exactSound = Settings.PlaysoundsSavedSounds.Find(ps => ps.Name == SoundSource);
if (exactSound != null)
{
sounds.Clear();
sounds.Add(exactSound);
}
if (sounds.Count == 0)
{
messageCallback.Invoke(ColorCoder.Error($"A playsound with the name {ColorCoder.Bold($"'{SoundSource}'")} wasn't found!"));
return;
}
else if (sounds.Count > 1)
{
string soundsJoined = string.Join(", ", sounds.Select(ps => ColorCoder.Bold($"'{ps.Name}'")));
messageCallback.Invoke(ColorCoder.Error($"Multiple sounds with {ColorCoder.Bold($"'{SoundSource}'")} in their name were found: ({soundsJoined})"));
return;
}
else
{
sound = sounds[0];
}
}
basePrice = sound.BasePrice;
filePath = Utils.GetProjectFilePath($"{SoundsFolder}\\{sound.FileName}");
baseDuration = AudioHelper.GetAudioDurationInSeconds(filePath);
playingSoundStr = ColorCoder.SuccessDim($" Playing sound {ColorCoder.Bold($"'{sound.Name}'")}.");
}
int modifiedPrice = Math.Max(1, (int)Math.Round(basePrice * priceFactor));
double modifiedDuration = baseDuration / speed;
int balanceAfter = EconomyManager.GetUserBalanceAfterPaying(evt.InvokerUniqueId, modifiedPrice);
if (balanceAfter < 0)
{
messageCallback.Invoke(ColorCoder.Error($"You dont have enough cash for that sound, {ColorCoder.Username(evt.InvokerName)}. Price: {ColorCoder.Currency(modifiedPrice, Settings.EcoPointUnitName)}, Needed: {ColorCoder.Currency(-balanceAfter, Settings.EcoPointUnitName)}"));
return;
}
CooldownManager.SetCooldown(evt.InvokerUniqueId, "command:playsounds", CalculateCooldown(modifiedDuration));
EconomyManager.ChangeBalanceForUser(evt.InvokerUniqueId, -modifiedPrice);
string usernameStr = ColorCoder.Username(evt.InvokerName);
string priceAdditionStr = priceFactor == 1 ? "" : $" x{priceFactor:0.##} = -{modifiedPrice}";
string balanceStr = $"Your balance: {EconomyManager.GetBalanceForUser(evt.InvokerUniqueId)} {Settings.EcoPointUnitName} {ColorCoder.ErrorBright($"(-{basePrice}{priceAdditionStr})")}";
messageCallback.Invoke($"{usernameStr} {playingSoundStr} {balanceStr}");
Process audioProcess = AudioHelper.PlayAudio(filePath, volume, speed, pitch, audioDevice: Settings.PlaysoundsSoundDevice);
AllStartedSoundProcesses.Add(audioProcess);
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
Client target = null;
if (TargetName != null)
{
target = Parent.Client.GetClientByNamePart(TargetName);
}
if (target == null)
{
target = Parent.Client.GetClientById(evt.InvokerId);
}
if (IsSendingBalance)
{
if (SendParam == "all")
{
SendAmount = (uint)Math.Max(0, EconomyManager.GetBalanceForUser(evt.InvokerUniqueId));
}
else if (SendParam == "excess")
{
int tempB = EconomyManager.GetBalanceForUser(evt.InvokerUniqueId);
if (tempB > Settings.EcoSoftBalanceLimit)
{
SendAmount = (uint)(tempB - Settings.EcoSoftBalanceLimit);
}
else
{
SendAmount = 0;
}
}
if (SendAmount == 0)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"Why would you want to send {ColorCoder.Currency(0)}? What are you, stupid {ColorCoder.Username(evt.InvokerName)}"));
return;
}
else if (EconomyManager.GetUserBalanceAfterPaying(evt.InvokerUniqueId, (int)SendAmount) < 0)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You can't afford to send that much cash, {ColorCoder.Username(evt.InvokerName)}"));
return;
}
else if (EconomyManager.GetUserBalanceAfterPaying(target.UniqueId, -1 * (int)SendAmount) > Settings.EcoSoftBalanceLimit)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You can't send that much cash because {ColorCoder.Username(target.Nickname)} would have more than '{ColorCoder.Currency(Settings.EcoSoftBalanceLimit)}'"));
return;
}
EconomyManager.ChangeBalanceForUser(evt.InvokerUniqueId, (-1) * (int)SendAmount);
EconomyManager.ChangeBalanceForUser(target.UniqueId, (int)SendAmount);
messageCallback.Invoke(ColorCoder.SuccessDim($"Sent '{ColorCoder.Currency(SendAmount)}' to {ColorCoder.Username(target.Nickname)}"));
}
else if (command == "setbalance")
{
int setAmount = SetAmount;
if (SetAmountIsRelative)
{
setAmount += EconomyManager.GetBalanceForUser(target.UniqueId);
}
EconomyManager.SetBalanceForUser(target.UniqueId, setAmount);
int setTo = EconomyManager.GetBalanceForUser(target.UniqueId);
messageCallback.Invoke(ColorCoder.Success($"Set balance for {ColorCoder.Username(target.Nickname)} to {ColorCoder.Bold($"{setTo} {Settings.EcoPointUnitName}")}"));
}
else
{
int max = Settings.EcoSoftBalanceLimit;
int balance = EconomyManager.GetBalanceForUser(target.UniqueId);
messageCallback.Invoke($"Balance of {ColorCoder.Username(target.Nickname)}: {ColorCoder.Bold(balance.ToString())} / {ColorCoder.Bold($"{max} {Settings.EcoPointUnitName}")}");
}
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
if (Action == "status")
{
if (TimerInfos.ContainsKey(evt.InvokerUniqueId))
{
(Timer targetTimer, DateTime timeDue, string targetCommand, List <string> targetParameters) = TimerInfos[evt.InvokerUniqueId];
TimeSpan timeLeft = timeDue - DateTime.Now;
timeLeft = TimeSpan.FromSeconds((int)timeLeft.TotalSeconds);
messageCallback.Invoke($"{ColorCoder.Username(evt.InvokerName)}: Time left for {FormatCommandString(command, parameters)}: [{timeLeft}]");
}
else
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You don't have an active timed command, {ColorCoder.Username(evt.InvokerName)}"));
}
return;
}
else if (Action == "cancel")
{
if (TimerInfos.ContainsKey(evt.InvokerUniqueId))
{
(Timer targetTimer, DateTime timeDue, string targetCommand, List <string> targetParameters) = TimerInfos[evt.InvokerUniqueId];
targetTimer.Dispose();
TimerInfos.Remove(evt.InvokerUniqueId);
messageCallback.Invoke($"{ColorCoder.Username(evt.InvokerName)}: Your timer for {FormatCommandString(command, parameters)} was cancelled!");
}
else
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You don't have an active timed command, {ColorCoder.Username(evt.InvokerName)}"));
}
return;
}
if (TimerInfos.ContainsKey(evt.InvokerUniqueId))
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You already have an active timed command, {ColorCoder.Username(evt.InvokerName)}"));
return;
}
TimeDelta = TimeDelta.Duration();
ChatCommand commandToExecute;
try {
commandToExecute = Parent.CommandHandler.GetCommandForMessage(TargetCommand, TargetParameters.AsEnumerable().ToList(), evt.InvokerUniqueId);
} catch (Exception) {
messageCallback.Invoke(ColorCoder.ErrorBright($"Could not parse the desired command. Make sure you have access to the command and the syntax is valid!"));
return;
}
Timer timer = new Timer(new TimerCallback((state) => {
HandleDelayedCommand(evt.InvokerUniqueId, TargetCommand, TargetParameters, messageCallback);
}), null, TimeDelta, TimeSpan.FromMilliseconds(-1));
TimerInfos.Add(evt.InvokerUniqueId, Tuple.Create(timer, DateTime.Now + TimeDelta, TargetCommand, TargetParameters));
messageCallback.Invoke(ColorCoder.SuccessDim($"Invoking command {FormatCommandString(TargetCommand, TargetParameters)} in [{ColorCoder.Bold(TimeDelta)}], {ColorCoder.Username(evt.InvokerName)}"));
}
public void HandleDelayedCommand(string clientUniqueId, string command, List <string> parameters, Action <string> messageCallback)
{
TimerInfos.Remove(clientUniqueId);
Client invoker = Parent.Client.GetClientByUniqueId(clientUniqueId);
if (invoker == null)
{
string lastSeenName = Parent.Settings.LastSeenUsernames[clientUniqueId];
messageCallback.Invoke(ColorCoder.ErrorBright($"Delayed command for {FormatCommandString(command, parameters)} was not executed as invoker {ColorCoder.Username(lastSeenName)} is no longer online"));
return;
}
string commandMessage = FormatCommandStringRaw(command, parameters);
NotifyTextMessageEvent evt = new NotifyTextMessageEvent()
{
InvokerId = invoker.Id,
InvokerName = invoker.Nickname,
InvokerUniqueId = invoker.UniqueId,
Message = commandMessage,
};
messageCallback.Invoke($"Invoking command {FormatCommandString(command, parameters)} for {ColorCoder.Username(invoker.Nickname)}");
Parent.CommandHandler.HandleTextMessage(evt, messageCallback);
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
int amountToGamble = 0;
StatisticSettings stats = Parent.StatSettings;
if (RequestedStats)
{
RouletteStatistics displayStats;
string toPrint;
if (RequestedStatsName != null && RequestedStatsName == "all")
{
displayStats = stats.Roulette;
toPrint = "Global roulette stats:";
}
else
{
string userUid = evt.InvokerUniqueId;
string userName = evt.InvokerName;
if (RequestedStatsName != null)
{
Client user = Parent.Client.GetClientByNamePart(RequestedStatsName);
userUid = user.UniqueId;
userName = user.Nickname;
}
CheckHasStatisticsEntry(userUid);
displayStats = stats.RouletteIndividual[userUid];
toPrint = $"Roulette stats for {ColorCoder.Username(userName)}:";
}
int won = displayStats.GamesWon;
int lost = displayStats.GamesLost;
double ratioPercent = (double)won * 100 / (lost + won);
string ratioPercentStr;
if (double.IsNaN(ratioPercent))
{
ratioPercentStr = "-%";
}
else
{
ratioPercentStr = ColorCoder.ColorPivotPercent(ratioPercent, 50);
}
toPrint += $"\n\tGames: {won + lost} ({ColorCoder.SuccessDim($"{won}W")}, {ColorCoder.ErrorBright($"{lost}L")} | {ratioPercentStr})";
int balanceWon = displayStats.PointsWon;
int balanceLost = displayStats.PointsLost;
int balanceDiff = balanceWon - balanceLost;
string balanceDiffStr = ColorCoder.ColorPivot(balanceDiff, 0);
toPrint += $"\n\tPoints: {balanceDiffStr} ({ColorCoder.SuccessDim($"+{balanceWon} won")}, {ColorCoder.ErrorBright($"-{balanceLost} lost")})";
int jackpots = displayStats.Jackpots;
int jackpotPoints = displayStats.JackpotsPointsWon;
toPrint += $"\n\tJackpots: {jackpots} ({ColorCoder.SuccessDim($"+{jackpotPoints} bonus")})";
double rolls = displayStats.Rolls;
string rollsStr = (won + lost) == 0 ? "-" : $"{rolls / (won + lost):0.####}";
toPrint += $"\n\tAvg. Roll: {rollsStr}";
messageCallback.Invoke(toPrint);
return;
}
if (!Settings.RouletteEnabled)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"The casino is currently closed, sorry {ColorCoder.Username(evt.InvokerName)}!"));
return;
}
CooldownManager.ThrowIfCooldown(evt.InvokerUniqueId, "command:roulette");
int currentBalance = EconomyManager.GetBalanceForUser(evt.InvokerUniqueId);
if (currentBalance > Settings.EcoSoftBalanceLimit)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You can't gamble while being over {ColorCoder.Bold($"{Settings.EcoSoftBalanceLimit} {Settings.EcoPointUnitName}")}, {ColorCoder.Username(evt.InvokerName)}"));
return;
}
if (IsAll)
{
amountToGamble = EconomyManager.GetBalanceForUser(evt.InvokerUniqueId);
}
else if (IsPercent)
{
if (Amount > 100)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You can't gamble away more than you own, {ColorCoder.Username(evt.InvokerName)}"));
return;
}
amountToGamble = EconomyManager.GetBalanceForUser(evt.InvokerUniqueId);
amountToGamble = (int)Math.Ceiling(amountToGamble * ((double)Amount / 100));
}
else
{
int balanceAfterPay = EconomyManager.GetUserBalanceAfterPaying(evt.InvokerUniqueId, (int)Amount);
if (balanceAfterPay < 0)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You don't have enough to gamble away '{ColorCoder.Bold($"{Amount} {Settings.EcoPointUnitName}")}', {ColorCoder.Username(evt.InvokerName)}"));
return;
}
amountToGamble = (int)Amount;
}
if (amountToGamble <= 0)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You don't have any cash on you, get out of my casino!"));
return;
}
CooldownManager.SetCooldown(evt.InvokerUniqueId, "command:roulette", Settings.RouletteCooldown);
double winChancePercent = Settings.RouletteWinChancePercent;
double jackpotChancePercent = Settings.RouletteJackpotChancePercent;
if (amountToGamble == Settings.EcoSoftBalanceLimit)
{
winChancePercent += 1;
}
winChancePercent /= 100;
jackpotChancePercent /= 100;
Random r = new Random();
double chosenValue = r.NextDouble();
string resultLogMsg = $"({chosenValue:0.#####} | win {winChancePercent:0.#####} | jackpot {jackpotChancePercent:0.#####})";
Parent.LastRouletteResult = resultLogMsg;
Parent.LogMessage($"Roulette result: {resultLogMsg}");
int changeBalanceAmount;
string message;
string ptsUnit = Settings.EcoPointUnitName;
CheckHasStatisticsEntry(evt.InvokerUniqueId);
RouletteStatistics indivStats = stats.RouletteIndividual[evt.InvokerUniqueId];
RouletteStatistics allStats = stats.Roulette;
allStats.Rolls += chosenValue;
indivStats.Rolls += chosenValue;
if (chosenValue < winChancePercent) //User won the roulette
{
double yield = Settings.RouletteWinYieldMultiplier;
changeBalanceAmount = (int)Math.Floor(amountToGamble * (yield - 1));
if (chosenValue < jackpotChancePercent)
{
allStats.Jackpots++;
int jackpotPoints = (int)(changeBalanceAmount * Settings.RouletteJackpotMultiplier);
allStats.JackpotsPointsWon += jackpotPoints - changeBalanceAmount;
indivStats.JackpotsPointsWon += jackpotPoints - changeBalanceAmount;
changeBalanceAmount = jackpotPoints;
messageCallback.Invoke(ColorCoder.Success($"\t-\t JACKPOT! Your reward has just been tripled!\t-\t"));
}
allStats.GamesWon++;
indivStats.GamesWon++;
allStats.PointsWon += changeBalanceAmount;
indivStats.PointsWon += changeBalanceAmount;
message = ColorCoder.ColorText(Color.DarkGreen, ColorCoder.Username(evt.InvokerName) + $" won {ColorCoder.Bold(changeBalanceAmount.ToString())} {ptsUnit} in roulette and now has {ColorCoder.Bold((currentBalance + changeBalanceAmount).ToString())} {ptsUnit} forsenPls ({chosenValue:0.####})");
}
else
{
changeBalanceAmount = -amountToGamble;
allStats.GamesLost++;
indivStats.GamesLost++;
allStats.PointsLost += amountToGamble;
indivStats.PointsLost += amountToGamble;
message = ColorCoder.ErrorBright(ColorCoder.Username(evt.InvokerName) + $" lost {ColorCoder.Bold(amountToGamble.ToString())} {ptsUnit} in roulette and now has {ColorCoder.Bold((currentBalance + changeBalanceAmount).ToString())} {ptsUnit} FeelsBadMan ({chosenValue:0.####})");
}
stats.DelayedSave();
EconomyManager.ChangeBalanceForUser(evt.InvokerUniqueId, changeBalanceAmount);
messageCallback.Invoke(message);
}
public override void HandleCommand(NotifyTextMessageEvent evt, string command, List <string> parameters, Action <string> messageCallback)
{
CooldownManager.ThrowIfCooldown(evt.InvokerUniqueId, "command:daily");
int currentBalance = EconomyManager.GetBalanceForUser(evt.InvokerUniqueId);
if (currentBalance + Settings.DailyReward > Settings.EcoSoftBalanceLimit)
{
messageCallback.Invoke(ColorCoder.ErrorBright($"You would have more than {ColorCoder.Currency(Settings.EcoSoftBalanceLimit, Settings.EcoPointUnitName)}, {ColorCoder.Username(evt.InvokerName)}. Your balance: {ColorCoder.Currency(currentBalance, Settings.EcoPointUnitName)} | Daily reward: {ColorCoder.Currency(Settings.DailyReward, Settings.EcoPointUnitName)}"));
return;
}
DateTime cooldownDue = DateTime.Today.AddDays(1).AddHours(7);
DateTime todayCheck = DateTime.Today.AddHours(7);
if (todayCheck > DateTime.Now)
{
cooldownDue = todayCheck;
}
CooldownManager.SetCooldown(evt.InvokerUniqueId, "command:daily", cooldownDue);
EconomyManager.ChangeBalanceForUser(evt.InvokerUniqueId, Settings.DailyReward);
messageCallback.Invoke(ColorCoder.SuccessDim($"{ColorCoder.Currency(Settings.DailyReward, Settings.EcoPointUnitName)} have been added to your balance as daily reward, {ColorCoder.Username(evt.InvokerName)}"));
}
public bool HandleTextMessage(NotifyTextMessageEvent evt, Action <string> messageCallback)
{
if (!Settings.ChatCommandsEnabled || string.IsNullOrEmpty(evt.Message) || !evt.Message.StartsWith(Settings.ChatCommandPrefix))
{
return(false);
}
Parent.LogMessage($"{evt.InvokerName} requested command: \"{evt.Message}\"");
//Copy event as to not mess up other event handlers
NotifyTextMessageEvent tempEvt = new NotifyTextMessageEvent();
evt.CopyProperties(tempEvt);
evt = tempEvt;
evt.Message = evt.Message.Substring(Settings.ChatCommandPrefix.Length);
bool hasAdmin = Settings.AdminUniqueIds.Contains(evt.InvokerUniqueId);
if (Parent.RateLimiter.CheckRateLimit("chat_command", evt.InvokerUniqueId, hasAdmin) == false)
{
messageCallback.Invoke(ColorCoder.ErrorBright("Slow down a little, you are sending too many commands!"));
return(true);
}
string[] messageSplit = evt.Message.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
string command = messageSplit[0].ToLower();
List <string> parameters = messageSplit.Skip(1).ToList();
parameters = ParseParameterEscapes(parameters);
ChatCommand commandToExecute = null;
//Handle exceptions that occur during the parsing of the parameters
try {
commandToExecute = GetCommandForMessage(command, parameters, evt.InvokerUniqueId);
} catch (ChatCommandNotFoundException) {
messageCallback.Invoke(ColorCoder.ErrorBright("Command was not found"));
return(true);
} catch (ChatCommandInvalidSyntaxException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"Invalid syntax. Usage of command:\n{Settings.ChatCommandPrefix}{ex.Message}"));
return(true);
} catch (NoPermissionException) {
messageCallback.Invoke(ColorCoder.ErrorBright($"You don't have access to this command, {ColorCoder.Username(evt.InvokerName)}"));
return(true);
} catch (CommandParameterInvalidFormatException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"The {ex.GetParameterPosition()} parameter's format was invalid ({ex.ParameterName} = '{ex.ParameterValue}'). It has to be {ColorCoder.Bold(ex.GetNeededType())}!\nUsage: {Settings.ChatCommandPrefix}{ex.UsageHelp}"));
return(true);
} catch (TimeStringParseException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"The provided time value '{ex.Input}' had invalid syntax: {ex.Message}"));
return(true);
}
//Handle exceptions that occur during execution of the command
try {
commandToExecute.HandleCommand(evt, command, parameters, messageCallback);
} catch (MultipleTargetsFoundException ex) {
string joined = string.Join(", ", ex.AllFoundTargets.Select(client => ColorCoder.Bold($"'{client.Nickname}'")));
messageCallback.Invoke(ColorCoder.ErrorBright($"Too many targets were found with {ColorCoder.Bold($"'{ex.Message}'")} in their name ({joined})"));
} catch (CooldownNotExpiredException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"That command is still on cooldown. ({ColorCoder.Bold($"{CooldownManager.FormatCooldownTime(ex.Duration)}")} cooldown)"));
} catch (NoTargetsFoundException ex) {
messageCallback.Invoke(ColorCoder.ErrorBright($"No targets were found with {ColorCoder.Bold($"'{ex.Message}'")} in their name..."));
} catch (Exception ex) {
Parent.LogMessage($"Encountered exception in command '{commandToExecute.GetType().Name}': {ex}");
}
return(true);
}
