public void DoJoin(TwitchClient sender, TwitchMessage message)
{
if (message.UserType < TwitchUserTypes.Developper)
{
sender.SendWhisper(message.SenderName, "Sorry {0}, but that command is currently restricted to Bot Admins", message.SenderDisplayName);
}
else
{
if (message.Args.Length > 1)
{
if (message.Args[1].StartsWith("#"))
{
sender.Join(message.Args[1]);
sender.SendMessage("#citillara", "Joining {0} on behalf of {1}", message.Args[1], message.SenderDisplayName);
}
else
{
sender.SendMessage(message.Channel, "Please specify a correct channel");
}
}
else
{
sender.Join("#" + message.SenderName);
sender.SendMessage("#citillara", "Joining {0} on behalf of {1}", "#" + message.SenderName, message.SenderDisplayName);
}
}
}
public TwitchMessage ParseTwitchMessageFromIrc(IrcClientOnPrivateMessageEventArgs args)
{
TwitchMessage retval = new TwitchMessage();
string key = string.Concat(args.Channel, args.Name);
TwitchExtra extra = new TwitchExtra(args.Tags);
retval.Channel = args.Channel;
retval.Message = args.Message;
retval.SenderName = args.Name;
retval.UserType = extra.UserType;
retval.IsSubscriber = extra.IsSubscriber;
retval.SubscriberLevel = extra.SubscriberLevel;
retval.IsTurbo = extra.IsTurbo;
retval.UserId = extra.UserId;
retval.IsBits = extra.IsBits;
retval.BitsLevel = extra.BitsLevel;
retval.BitsSent = extra.BitsSent;
if (!args.Channel.StartsWith("#"))
{
retval.IsWhisper = true;
retval.Channel = args.Name;
retval.WhisperChannel = args.Channel;
}
if (!string.IsNullOrEmpty(extra.DisplayName))
retval.SenderDisplayName = extra.DisplayName;
else
retval.SenderDisplayName = args.Name;
if(opslist.Contains(key))
{
retval.UserType |= TwitchUserTypes.Mod;
}
if (extra.IsSubscriber)
{
retval.UserType |= TwitchUserTypes.Subscriber;
}
if (args.Name.Equals(args.Channel.Substring(1)))
{
retval.UserType |= TwitchUserTypes.Broadcaster;
}
if (botmasters.Contains(args.Name))
{
retval.UserType |= TwitchUserTypes.Developper;
}
if (args.Name.Equals("citillara"))
{
retval.UserType |= TwitchUserTypes.Citillara;
}
return retval;
}
public void DoPart(TwitchClient sender, TwitchMessage message)
{
if (message.UserType < TwitchUserTypes.Broadcaster)
{
sender.SendWhisper(message.SenderName, "Sorry {0}, but this command is rectricted to Broadcaster and above", message.SenderDisplayName);
}
else
{
sender.Part(message.Channel);
sender.SendMessage("#citillara", "Parting {0} on behalf of {1}", message.Channel, message.SenderDisplayName);
}
}
private void Dig(TwitchClient client, TwitchMessage message)
{
if (message.IsWhisper)
{
client.SendWhisper(message.Channel, "Sorry by that command is not supported over whisper");
return;
}
var user = DogUser.GetUser(message.Channel, message.SenderName);
if (user != null && user.LastReceived.HasValue)
{
if (message.UserType < TwitchUserTypes.Broadcaster && user.LastReceived.Value.AddMinutes(5) > DateTime.Now)
{
client.SendWhisper(message.SenderName,
"Sorry {0}, but you can use that command only every 5 minutes.",
message.SenderDisplayName);
return;
}
}
int found_bones = m_Random.Next(0, 100);
if (found_bones > 50)
{
client.SendMessage(message.Channel, "{0} digs but founds nothing.", message.SenderDisplayName);
return;
}
if (user == null)
{
user = new DogUser()
{
BonesReceived = 0,
Channel = message.Channel,
LastReceived = DateTime.Now,
TopBonesCount = 0,
Username = message.SenderName
};
}
int bones_found = m_Random.Next (1, 21);
user.BonesReceived += bones_found;
client.SendMessage(message.Channel, "{0} digs and finds {1} bones ! (Total : {2})",
message.SenderDisplayName, bones_found, user.BonesReceived);
user.Save();
}
public void DoPyramid(TwitchClient sender, TwitchMessage message)
{
if (message.UserType < TwitchUserTypes.Citillara)
{
//sender.SendMessage(message.Channel, "Sorry {0}, but this command is rectricted to Citillara", message.SenderDisplayName);
}
else
{
var icon = message.Args[1] + " ";
sender.SendMessage(message.Channel, icon);
sender.SendMessage(message.Channel, icon + icon);
sender.SendMessage(message.Channel, icon + icon + icon);
sender.SendMessage(message.Channel, icon + icon + icon + icon);
sender.SendMessage(message.Channel, icon + icon + icon);
sender.SendMessage(message.Channel, icon + icon);
sender.SendMessage(message.Channel, icon);
}
}
public void OnMessage(TwitchClient client, TwitchMessage message)
{
if (!message.Message.StartsWith("!"))
return;
var split = message.Message.Split(' ');
string msg = split[0];
try
{
Action<TwitchClient, TwitchMessage> action;
if (m_commands.TryGetValue(msg, out action))
action.Invoke(client, message);
}
catch(Exception e)
{
Console.WriteLine(DateTime.Now.ToString());
Console.WriteLine(message);
Console.WriteLine(e.ToString());
}
}
private void SendCookies(TwitchClient client, TwitchMessage message)
{
int amount = 0;
if (message.Args.Length < 3 || !int.TryParse(message.Args[2], out amount) || amount <= 0)
{
client.SendMessage(message.Channel, "Usage : !sendcookie <target> <amount>");
return;
}
var sender = CookieUser.GetUser(message.Channel, message.SenderName, message.UserId, message.SenderDisplayName);
var target = CookieUser.GetUser(message.Channel, message.Args[1]);
if (sender == null || sender.CookieReceived < amount)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you don't have enough cookies", message.SenderDisplayName);
return;
}
target.CookieReceived += amount;
target.Save();
sender.CookieReceived -= amount;
sender.Save();
client.SendMessage(message.Channel, "{0} gave {1} cookies to {2}", message.SenderDisplayName, amount, message.Args[1]);
}
private void DisplayTop10(TwitchClient client, TwitchMessage message)
{
DisplayTop(client, message, 10);
}
private void GiveCookie(TwitchClient client, TwitchMessage message)
{
int forcedCookies = -1;
bool targetIsNotSender = false;
bool allowedThroughWhisper = false;
string target = message.SenderDisplayName;
string channel = message.Channel;
string[] split = message.Message.Split(' ');
if (split.Length > 1)
{
// Sends the cookie to someone else. Usage : !cookie <target>
target = split[1].Trim().Replace("@", "");
targetIsNotSender = true;
}
if (split.Length > 2)
{
// Sends the cookies on another channel. Usage : !cookie <target> <channel>
if (message.UserType >= TwitchUserTypes.Developper && split[2].StartsWith("#"))
{
channel = split[2];
allowedThroughWhisper = true;
}
// Sends defined amount of cookies to a target in the channel. Usage !cookie <target> <amount>
else if (message.UserType >= TwitchUserTypes.Citillara && int.TryParse(split[2], out forcedCookies))
{
allowedThroughWhisper = false;
}
}
if (split.Length == 4)
{
// Sends the cookies on another channel. Usage : !cookie <target> <channel> <amount>
if (message.UserType >= TwitchUserTypes.Citillara)
{
int.TryParse(split[3], out forcedCookies);
allowedThroughWhisper = true;
}
}
if (message.IsWhisper && !allowedThroughWhisper)
{
client.SendWhisper(message.Channel, "Sorry but that command is not supported over whisper");
return;
}
// Sets the target depending if it's the sender or not
string targetDatabaseKey = targetIsNotSender ? target.ToLowerInvariant() : message.SenderName;
string senderDatabaseKey = message.SenderName;
var sender_user_database = CookieUser.GetUser(channel, senderDatabaseKey, message.UserId, message.SenderDisplayName);
// Ignores checks if sender is Developper or above
if (message.UserType < TwitchUserTypes.Developper)
{
// Sender is in database
if (sender_user_database != null)
{
int delay_in_seconds = 60; // default;
// Channel may have custom delay
int delay = CookieChannel.GetChannel(message.Channel).CookieDelay;
if (delay > 0)
delay_in_seconds = delay;
// Sender is sending before the delay
var next_allowance_date = sender_user_database.LastSend.AddSeconds(delay_in_seconds);
if (next_allowance_date > DateTime.Now)
{
var next_allowance_seconds = (int)(next_allowance_date - DateTime.Now).TotalSeconds;
client.SendWhisper(message.SenderName, "Sorry {0} but you can get/send cookies only every {1} seconds (next in {2} seconds)", message.SenderDisplayName, delay_in_seconds, next_allowance_seconds);
return; // Prevent him from sending
}
}
}
// Sender is in database
sender_user_database.LastSend = DateTime.Now;
sender_user_database.Save();
// Select a cookie
IEnumerable<Int32> m_list_of_cookies_ids;
if (m_random.Next(0, 100) > 75)
{
m_list_of_cookies_ids = CookieFlavour.GetCommonCookies();
}
else
{
m_list_of_cookies_ids = CookieFlavour.GetChannelCookies(message.Channel);
if (m_list_of_cookies_ids.Count() == 0)
m_list_of_cookies_ids = CookieFlavour.GetCommonCookies();
}
int next = m_random.Next(0, m_list_of_cookies_ids.Count());
// Select a quantity
int quantity = 0;
int picker = m_random.Next(1, 100);
if (picker < 50)
quantity = m_random.Next(1, 10);
else if (picker < 70)
quantity = m_random.Next(10, 20);
else if (picker < 90)
quantity = m_random.Next(20, 40);
else
quantity = m_random.Next(40, 80);
if (forcedCookies != -1)
quantity = forcedCookies;
var target_user_database = CookieUser.GetUser(channel, targetDatabaseKey);
// User is in the database
target_user_database.LastReceived = DateTime.Now;
target_user_database.CookieReceived += quantity;
target_user_database.Save();
string modifier = "";
if (quantity > 40)
modifier = ". Incredible !";
else if (quantity > 20)
modifier = ". Awesome !";
else if (quantity > 10)
modifier = ". Not bad !";
int cookie_id_selected = m_list_of_cookies_ids.ToArray()[next];
string flavor = CookieFlavour.GetCookie(cookie_id_selected).Text.ToLowerInvariant();
if (split[0].Contains("welcomecookie"))
flavor = "welcome cookie";
else if (split[0].Contains("wrcookie"))
flavor = "World Record cookie";
else if (split[0].Contains("lovecookie"))
flavor = "cookie of Love";
else if (split[0].Contains("crashcookie"))
flavor = "crashing cookie";
string msg = string.Format("gives {0} {1} to {2} NomNom {3}", NumberToWords(quantity), flavor, target, modifier);
if (quantity > 1)
msg = msg.Replace("cookie", "cookies");
client.SendAction(channel, msg);
}
private void DisplayDatabaseCookieCount(TwitchClient client, TwitchMessage message)
{
client.SendMessage(message.Channel, "Database contains {0} cookies", CookieFlavour.GetCookieCount());
}
private void DisplayTop(TwitchClient client, TwitchMessage message, int count)
{
if (lastDisplayTop.AddMinutes(1) > DateTime.Now)
return;
lastDisplayTop = DateTime.Now;
var top_10 = CookieUser.GetChannelTopUsers(message.Channel, count);
var sorted = from db in top_10
orderby db.CookieReceived descending
select new
{
Key = db.DisplayName,
Rank = (from dbb in top_10
where dbb.CookieReceived > db.CookieReceived
select dbb).Count() + 1,
CookieReceived = db.CookieReceived
};
var sorted_ordered = from sr in sorted
orderby sr.Rank ascending
select sr;
StringBuilder sb = new StringBuilder();
foreach (var el in sorted_ordered)
sb.AppendFormat("{0}. {1} ({2}) - ", el.Rank, el.Key, el.CookieReceived);
client.SendMessage(message.Channel, sb.ToString());
}
private void DisplayCookieCount(TwitchClient client, TwitchMessage message)
{
string channel = message.Channel;
string username = message.SenderName;
var user = CookieUser.GetUser(channel, username);
if (user != null && user.CookieReceived > 0)
{
var ranking = CookieUser.GetUserRankingInChannel(channel, username);
var number_of_users = CookieUser.GetChannelUserCount(channel);
int cookies = user.CookieReceived;
client.SendWhisper(message.SenderName, "{0}, you received {1} cookies so far which places you {2} out of {3}. It represents {4} which you can burn by doing {5}",
message.SenderDisplayName,
user.CookieReceived,
Ranking(ranking),
number_of_users,
Calories(cookies),
GetActivity(cookies)
);
}
else
{
client.SendMessage(message.Channel, "Sorry {0}, but you havn't received any cookies so far. Type !cookies to get some", message.SenderDisplayName);
}
}
private void DisplayCookieFlavours(TwitchClient client, TwitchMessage message)
{
if (message.IsWhisper)
{
client.SendWhisper(message.Channel, "Sorry but that command is not supported over whisper");
return;
}
client.SendMessage(message.Channel, "https://www.citillara.fr/citibot/{0}/cookies/flavours", message.Channel.ToLowerInvariant().Replace("#", ""));
}
private void AddCookieFlavor(TwitchClient client, TwitchMessage message)
{
if (message.IsWhisper)
{
client.SendWhisper(message.Channel, "Sorry by that command is not supported over whisper");
return;
}
if (message.UserType < TwitchUserTypes.Mod)
{
client.SendWhisper(message.SenderName, "Sorry {0}, this command is only for mods and above.", message.SenderDisplayName);
return;
}
string msg = message.Message.Replace("\"", "").Trim();
if (msg.IndexOf(' ') == -1)
{
client.SendWhisper(message.SenderName, "Please specify what you want to add to the cookie database");
return;
}
string sub = msg.Substring(msg.IndexOf(' '));
if (!sub.ToLowerInvariant().Contains("cookie"))
{
client.SendWhisper(message.SenderName, "Sorry {0}, but the new flavor must contain the word \"cookie\" (singular)", message.SenderDisplayName);
return;
}
if (!CheckAllowedCookie(sub))
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you're not allowed to add this.", message.SenderDisplayName);
return;
}
CookieFlavour.AddNewCookieFlavor(message.Channel, sub, message.SenderName);
client.SendMessage(message.Channel, "\"{0}\" have been added to the cookie database", sub);
}
private void ChangeDelays(TwitchClient client, TwitchMessage message)
{
var channel = message.Channel;
if (message.UserType >= TwitchUserTypes.Broadcaster)
{
string[] split = message.Message.Split(' ');
int time = 0;
if (split.Length > 1 && int.TryParse(split[1], out time))
{
if (time > 0)
{
var channelp = CookieChannel.GetChannel(channel);
switch (message.Command)
{
case "!cookiedelay":
channelp.CookieDelay = time;
client.SendMessage(message.Channel, "Cookie delay has been set to {0} seconds", time);
break;
case "!stealdelay":
channelp.StealDelay = time;
client.SendMessage(message.Channel, "Steal delay has been set to {0} seconds", time);
break;
case "!bribedelay":
channelp.BribeDelay = time;
client.SendMessage(message.Channel, "Bribe delay has been set to {0} seconds", time);
break;
default: break;
}
channelp.Save();
}
}
}
else
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you are not the broadcaster", message.SenderDisplayName);
}
}
private void SendYoshi(TwitchClient client, TwitchMessage message)
{
int bribe_amount = -1;
var briber = CookieUser.GetUser(message.Channel, message.SenderName, message.UserId, message.SenderDisplayName);
if (message.IsWhisper)
{
client.SendWhisper(message.Channel, "Sorry but that command is not supported over whisper");
}
if (message.Args.Length < 3)
{
client.SendMessage(message.Channel, "Usage : !yoshi <target> <bribe_amount>");
return;
}
if (!int.TryParse(message.Args[2], out bribe_amount) || bribe_amount <= 0)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you must specify a non negative number of cookies", message.SenderDisplayName);
return;
}
if (briber == null)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you don't have any cookies to bribe Yoshi with", message.SenderDisplayName);
return;
}
if (bribe_amount > briber.CookieReceived)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you don't have enough cookies to bribe Yoshi with", message.SenderDisplayName);
return;
}
var channel = CookieChannel.GetChannel(message.Channel);
var nextbribe = briber.LastYoshiBribe.AddSeconds(channel.BribeDelay);
if (nextbribe > DateTime.Now)
{
var sec = (int)(nextbribe - DateTime.Now).TotalSeconds;
client.SendWhisper(message.SenderName, "Sorry {0}, but you can only bribe Yoshi every {1} seconds (next attempt in {2} seconds)", message.SenderDisplayName, channel.BribeDelay, sec);
return;
}
var target = CookieUser.GetUser(message.Channel, message.Args[1].ToLowerInvariant());
if (target == null || target.CookieReceived <= 0)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but {1} doesn't have any cookies", message.SenderDisplayName, message.Args[1]);
return;
}
int quantity = 0;
quantity = m_random.Next(1, 3 * bribe_amount);
if (target.Id == briber.Id)
{
briber.CookieReceived -= bribe_amount;
briber.CookieReceived -= quantity;
if (briber.CookieReceived < 0)
briber.CookieReceived = 0;
client.SendMessage(message.Channel, "{0} bribed Yoshi, who devoured {1} cookies of {2} ! ({3} cookies left)",
message.SenderDisplayName,
quantity,
briber.TwitchUser.BusinessDisplayName,
briber.CookieReceived);
briber.LastYoshiBribe = DateTime.Now;
briber.Save();
}
else
{
target.CookieReceived -= quantity;
briber.CookieReceived -= bribe_amount;
if (target.CookieReceived < 0)
target.CookieReceived = 0;
client.SendMessage(message.Channel, "{0} bribed Yoshi, who devoured {1} cookies of {2} ! ({3} cookies left)",
message.SenderDisplayName,
quantity,
target.TwitchUser.BusinessDisplayName,
target.CookieReceived);
briber.LastYoshiBribe = DateTime.Now;
briber.Save();
target.Save();
}
}
public void DoRoll(TwitchClient sender, TwitchMessage message)
{
int roll = 0;
switch (message.Command) {
case "!d2": roll = 2; break;
case "!d3": roll = 3; break;
case "!d4": roll = 4; break;
case "!d6": roll = 6; break;
case "!d8": roll = 8; break;
case "!d10": roll = 10; break;
case "!d12": roll = 12; break;
case "!d20": roll = 20; break;
case "!d100": roll = 100; break;
case "!roll":
if (message.Args.Length < 2 || !int.TryParse(message.Args[1], out roll) || roll <= 0)
return;
else break;
default: return;
}
sender.AutoDetectSendWhispers = true;
sender.SendMessage(message.Channel, string.Format("{0} rolls a {1}", message.SenderDisplayName, m_random.Next(1, roll + 1)));
}
public void DoTimeDiff(TwitchClient sender, TwitchMessage message)
{
if (message.Args.Length != 3)
{
return;
}
TimeSpan ts1, ts2;
bool bts1 = TimeSpan.TryParse(message.Args[1], out ts1);
bool bts2 = TimeSpan.TryParse(message.Args[2], out ts2);
if (!bts1 || !bts2)
{
return;
}
var tsr = new TimeSpan(Math.Abs(ts1.Ticks - ts2.Ticks));
sender.SendMessage(message.Channel, tsr.ToString());
}
public void DoRaid(TwitchClient sender, TwitchMessage message)
{
if (message.UserType >= TwitchUserTypes.Broadcaster)
{
if (message.Args.Length > 1)
{
if (m_raidMessages.ContainsKey(message.Channel) && !String.IsNullOrEmpty(m_raidMessages[message.Channel]))
{
RepeatAction(RAID_REPEAT, () => sender.SendMessage(message.Channel, m_raidMessages[message.Channel]));
}
RepeatAction(RAID_REPEAT, () => sender.SendMessage(message.Channel, TWITCH_URL + message.Args[1].ToLowerInvariant()));
}
}
}
public void DoUptime(TwitchClient sender, TwitchMessage message)
{
var d = new TimeSpan(DateTime.Now.Ticks - m_startTime.Ticks);
sender.SendMessage(message.Channel, "Bot uptime : {0}d {1}h {2}m {3}s", d.Days, d.Hours, d.Minutes, d.Seconds);
}
public void DoVersion(TwitchClient sender, TwitchMessage message)
{
sender.SendMessage(message.Channel, "IRC {0}, Twitch {1}, CitiBot {2}", Irc.IrcClient.Version, TwitchClient.Version, Program.Version);
}
public void DoBug(TwitchClient sender, TwitchMessage message)
{
sender.SendMessage(message.Channel, "Please report any bugs/suggestion at https://github.com/Citillara/CitiBot/issues");
}
private void StealCookies(TwitchClient client, TwitchMessage message)
{
if (message.IsWhisper)
{
client.SendWhisper(message.Channel, "Sorry but that command is not supported over whisper");
}
if (message.Args.Length < 2)
{
client.SendMessage(message.Channel, "Usage : !stealcookies <target>");
return;
}
var stealer = CookieUser.GetUser(message.Channel, message.SenderName, message.UserId, message.SenderDisplayName);
var channel = CookieChannel.GetChannel(message.Channel);
if (stealer.LastSteal.AddSeconds(channel.StealDelay) > DateTime.Now && message.UserType < TwitchUserTypes.Developper)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but you can only steal every {1} seconds", message.SenderDisplayName, channel.StealDelay);
return;
}
var target = CookieUser.GetUser(message.Channel, message.Args[1]);
if (target.CookieReceived == 0)
{
client.SendWhisper(message.SenderName, "Sorry {0}, but {1} doesn't have any cookies", message.SenderDisplayName, message.Args[1]);
return;
}
decimal scookies = (decimal)stealer.CookieReceived;
decimal tcookies = (decimal)target.CookieReceived;
decimal chance = 500m;
if (scookies > tcookies)
{
chance -= ((scookies - tcookies) / scookies) * 500m;
}
else
{
chance += ((tcookies - scookies) / tcookies) * 500m;
}
chance *= 0.80m;
stealer.LastSteal = DateTime.Now;
decimal failchance = 1000m - chance;
decimal critfailchance = failchance * 0.30m;
int rand = m_random.Next(1, 1000);
if (rand > failchance)
{
// success
int amount = GetPercentageOfCookies(target.CookieReceived, m_random.Next(1, 5));
stealer.CookieReceived += amount;
target.CookieReceived -= amount;
stealer.Save();
target.Save();
client.SendMessage(message.Channel, "{0} managed to steal {1} cookies to {2} !", stealer.TwitchUser.BusinessDisplayName, amount,
target.TwitchUser.BusinessDisplayName ?? message.Args[1]);
}
else if (rand > critfailchance || stealer.CookieReceived == 0)
{
// fail
client.SendMessage(message.Channel, "{0} didn't managed to steal any cookies this time", stealer.TwitchUser.BusinessDisplayName);
}
else
{
// critical fail;
int yrand = m_random.Next(1, 100);
int amount = GetPercentageOfCookies(stealer.CookieReceived, m_random.Next(1, 5));
bool doYoshi = true;
if (yrand > 50)
{
var list = CookieUser.GetChannelUserIdsWithExclusion(message.Channel, new List<Int32>() { target.Id, stealer.Id });
if (list.Count() > 0)
{
doYoshi = false;
int rnd = m_random.Next(0, list.Count());
var newtarget = CookieUser.GetUser(list.Skip(rnd).Take(1).First());
client.SendMessage(message.Channel, "Critical fail ! {0} tumbles and lose his/her cookie purse near {1} who steals {2} of them before running away", stealer.TwitchUser.BusinessDisplayName, newtarget.TwitchUser.BusinessDisplayName, amount);
newtarget.CookieReceived += amount;
stealer.CookieReceived -= amount;
newtarget.Save();
stealer.Save();
}
}
if(doYoshi)
{
client.SendMessage(message.Channel, "Critical fail ! {0} tumbles and lose his/her cookie purse near a yoshi who eats {1} of them before running away", stealer.TwitchUser.BusinessDisplayName, amount);
stealer.CookieReceived -= amount;
stealer.Save();
}
}
}
public void DoRaidMessage(TwitchClient sender, TwitchMessage message)
{
if (message.UserType >= TwitchUserTypes.Broadcaster)
{
if (message.Args.Length > 1)
{
string msg = message.Message.Substring(message.Args[0].Length + 1).Trim();
m_raidMessages[message.Channel] = msg;
sender.SendMessage(message.Channel, "Raid message has been set to : " + msg);
}
}
}
