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 void ToggleYtOnePointEvent()
{
if (!Settings.PlaysoundsYoutubeOnePointEvent)
{
Client.SendChannelMessage(ColorCoder.SuccessDim($"YouTube playsounds 1-Point event!\n\t{ColorCoder.Bold($"- All youtube playsounds shorter than 60 seconds only cost 1 point! -")}"));
}
else
{
Client.SendChannelMessage($"1-Point event stopped.");
}
Settings.PlaysoundsYoutubeOnePointEvent = !Settings.PlaysoundsYoutubeOnePointEvent;
}
public static void HandleStatsRequest(string nameSearch, int leaderboardId, Action <string> messageCallback)
{
AoeLeaderboardResponse response = GetLeaderboardResponse(leaderboardId, nameSearch, 2);
if (response.Count == 0)
{
messageCallback.Invoke($"There were no players found on leaderboard '{leaderboardId}' with the name '{nameSearch}'");
return;
}
else if (response.Count > 1)
{
messageCallback.Invoke($"There were multiple players found on leaderboard '{leaderboardId}' with the name '{nameSearch}'");
return;
}
AoePlayer player = response.Leaderboard[0];
string clanAddition = player.Clan == null ? "" : $"[{player.Clan}]";
string leaderboardName = Leaderboards.First(kv => kv.Value == leaderboardId).Key;
int ratingDiff = player.Rating.Value - player.PreviousRating.Value;
string ratingDiffStr = ratingDiff < 0 ? ColorCoder.ErrorBright(ratingDiff) : ratingDiff > 0 ? ColorCoder.SuccessDim(ratingDiff) : $"{ratingDiff}";
double ratioPercent = (double)player.Wins.Value * 100 / player.Games.Value;
string ratioPercentStr = $"{ratioPercent:0.##}%";
ratioPercentStr = ratioPercent < 50 ? ColorCoder.ErrorBright(ratioPercentStr) : ratioPercent > 50 ? ColorCoder.SuccessDim(ratioPercentStr) : $"{ratioPercentStr}";
string toPrint = $"{ColorCoder.Bold(leaderboardName.ToUpper())} stats for {ColorCoder.Bold(player.Name+clanAddition)}:";
toPrint += $"\n\tRating: {ColorCoder.Bold(player.Rating.Value)} ({ratingDiffStr}) (#{player.Rank})";
toPrint += $"\n\tPeak Rating: {player.HighestRating}";
toPrint += $"\n\tStreak: {player.Streak} | Lowest: {player.LowestStreak} | Highest: {player.HighestStreak}";
toPrint += $"\n\tGames: {player.Games} ({ColorCoder.SuccessDim(player.Wins.Value+"W")} - {ColorCoder.ErrorBright(player.Losses.Value+"L")} | {ratioPercentStr})";
toPrint += $"\n\tCountry: {player.Country}";
messageCallback.Invoke(toPrint);
}
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)
{
TimeSpan untilTick = GetTimeSpanUntilTick();
messageCallback.Invoke($"Time until next economy tick ({ColorCoder.SuccessDim($"+{ColorCoder.Currency(Settings.EcoTickGain, Settings.EcoPointUnitName)}")}): {ColorCoder.Bold(Utils.FormatTimeSpanShort(untilTick))}");
}
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 static void HandleLastMatchRequest(string nameSearch, int leaderboardId, Action <string> messageCallback)
{
AoeLeaderboardResponse response = GetLeaderboardResponse(leaderboardId, nameSearch, 2);
AoePlayer player;
if (response.Count == 0)
{
messageCallback.Invoke($"There were no players found on leaderboard '{leaderboardId}' with the name '{nameSearch}'");
return;
}
else if (response.Count > 1)
{
messageCallback.Invoke($"There were multiple players found on leaderboard '{leaderboardId}' with the name '{nameSearch}', taking the highest rated player...");
player = response.Leaderboard[0];
}
else
{
player = response.Leaderboard[0];
}
AoeLastMatchResponse lastMatchResponse = GetLastMatchResponse(player.SteamId);
Match lastMatch = lastMatchResponse.LastMatch;
Dictionary <int, List <List <AoePlayer> > > matchTeams = new Dictionary <int, List <List <AoePlayer> > >();
foreach (AoePlayer matchPlayer in lastMatch.Players)
{
if (!matchTeams.ContainsKey(matchPlayer.Team.Value))
{
matchTeams.Add(matchPlayer.Team.Value, new List <List <AoePlayer> >());
}
List <List <AoePlayer> > team = matchTeams[matchPlayer.Team.Value];
List <AoePlayer> playerInfo = new List <AoePlayer>();
playerInfo.Add(matchPlayer);
if (matchPlayer.SteamId != player.SteamId)
{
AoeLeaderboardResponse lb = GetLeaderboardResponse(leaderboardId, matchPlayer.ProfileId.Value.ToString(), 2, isProfileId: true);
if (lb.Leaderboard.Count == 0)
{
playerInfo.Add(null);
}
else
{
playerInfo.Add(lb.Leaderboard[0]);
}
}
else
{
playerInfo.Add(player);
}
team.Add(playerInfo);
}
string toPrint = "";
toPrint += lastMatch.Finished.HasValue ? "Last Match (" + (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(lastMatch.Finished.Value).ToLocalTime()).ToString("dd.MM.yy HH:mm") + "):" : "Current Match:";
toPrint += lastMatch.Ranked.HasValue && lastMatch.Ranked.Value ? " Ranked" : " Unranked";
string mapName = GetAoeString("map_type", lastMatch.MapType.Value);
toPrint += $" on {mapName}";
bool firstTeam = true;
foreach (int teamPos in matchTeams.Keys)
{
List <List <AoePlayer> > team = matchTeams[teamPos];
string winStatusString;
if (!team[0][0].Won.HasValue)
{
winStatusString = "◯";
}
else if (team[0][0].Won.Value)
{
winStatusString = "👑";
}
else
{
winStatusString = "☠";
}
if (firstTeam)
{
firstTeam = false;
}
else
{
toPrint += "\n\t\tvs.";
}
foreach (List <AoePlayer> playerInfo in team)
{
string playerName = playerInfo[0].Name;
string civ = GetAoeString("civ", playerInfo[0].Civ.Value);
if (playerName.ToLower().Contains(nameSearch.ToLower()))
{
playerName = ColorCoder.Bold(playerName);
}
if (playerInfo[1] == null) //Player is not yet ranked in this leaderboard
{
string line = $"\n{winStatusString} [--] {playerName} (<placements>) on {civ}";
toPrint += line;
}
else
{
string country = playerInfo[1].Country;
string rating = playerInfo[1].Rating.HasValue ? $"{playerInfo[1].Rating.Value}" : "<placement>";
int games = playerInfo[1].Games.Value;
int wins = playerInfo[1].Wins.Value;
double ratioPercent = Math.Round((double)wins * 100 / games);
string ratioPercentStr = $"{ratioPercent}%";
ratioPercentStr = ratioPercent < 50 ? ColorCoder.ErrorBright(ratioPercentStr) : ratioPercent > 50 ? ColorCoder.SuccessDim(ratioPercentStr) : $"{ratioPercentStr}";
string line = $"\n{winStatusString} [{country}] {playerName} ({rating}, {games} G, {ratioPercentStr}) on {civ}";
toPrint += line;
}
}
}
messageCallback.Invoke(toPrint);
}
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);
}