private static MessageFlags UpdateMessageFlags(IPropertyBag propertyBag, MessageFlags flagsFromSource)
{
MessageFlags messageFlags = MessageFlags.None;
AnnotatedPropertyValue annotatedProperty = propertyBag.GetAnnotatedProperty(PropertyTag.MessageFlags);
if (!annotatedProperty.PropertyValue.IsError)
{
messageFlags = (MessageFlags)((int)annotatedProperty.PropertyValue.Value);
}
if (flagsFromSource.HasFlag(MessageFlags.Read))
{
messageFlags |= MessageFlags.Read;
}
else
{
messageFlags &= ~MessageFlags.Read;
}
if (flagsFromSource.HasFlag(MessageFlags.Unsent))
{
messageFlags |= MessageFlags.Unsent;
}
else
{
messageFlags &= ~MessageFlags.Unsent;
}
return(messageFlags);
}
protected virtual void HandleQueryMessage(object sender, IPrivateMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (!string.Equals(args.SenderNickname, Config.GameMasterNickname, StringComparison.OrdinalIgnoreCase))
{
return;
}
JObject eventObject;
try
{
eventObject = JObject.Parse(args.Message);
}
catch (JsonReaderException)
{
return;
}
Dispatcher.DispatchEvent(this, eventObject);
}
protected virtual void HandleQueryNotice(object sender, IPrivateMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (!string.Equals(args.SenderNickname, Config.GameMasterNickname, StringComparison.OrdinalIgnoreCase))
{
return;
}
Match decksInShoeMatch = DecksInShoeRegex.Match(args.Message);
if (decksInShoeMatch.Success)
{
int decksInShoe;
if (int.TryParse(
decksInShoeMatch.Groups["deckCount"].Value, NumberStyles.None, CultureInfo.InvariantCulture,
out decksInShoe
))
{
CardCounter.TotalDecks = decksInShoe;
}
}
if (args.Message.Contains("Dealer stands on soft 17."))
{
State.BasicStrat = BasicStrategy.StandOnSoft17;
}
else if (args.Message.Contains("Dealer hits on soft 17."))
{
State.BasicStrat = BasicStrategy.HitOnSoft17;
}
}
private void DecompressPayload()
{
if (_payload_compressed.Length == 0)
{
return;
}
byte[] decompressed = Flags.HasFlag(MessageFlags.Compressed)
? _payload_compressed.DecompressLz4(PayloadMaxSize)
: _payload_compressed;
switch (Command)
{
case MessageCommand.Version:
Payload = decompressed.AsSerializable <VersionPayload>();
break;
case MessageCommand.Addr:
Payload = decompressed.AsSerializable <AddrPayload>();
break;
case MessageCommand.Ping:
case MessageCommand.Pong:
Payload = decompressed.AsSerializable <PingPayload>();
break;
case MessageCommand.GetHeaders:
//case MessageCommand.GetBlocks:
// Payload = decompressed.AsSerializable<GetBlocksPayload>();
// break;
//case MessageCommand.Headers:
// Payload = decompressed.AsSerializable<HeadersPayload>();
break;
case MessageCommand.Inv:
case MessageCommand.GetData:
Payload = decompressed.AsSerializable <InvPayload>();
break;
//case MessageCommand.Transaction:
// Payload = decompressed.AsSerializable<Transaction>();
// break;
//case MessageCommand.Block:
// Payload = decompressed.AsSerializable<Block>();
// break;
case MessageCommand.Consensus:
Payload = DecodeSignedMessage(decompressed);
break;
//case MessageCommand.FilterLoad:
// Payload = decompressed.AsSerializable<FilterLoadPayload>();
// break;
//case MessageCommand.FilterAdd:
// Payload = decompressed.AsSerializable<FilterAddPayload>();
// break;
//case MessageCommand.MerkleBlock:
// Payload = decompressed.AsSerializable<MerkleBlockPayload>();
// break;
}
}
protected virtual void HandleChannelAction(object sender, IChannelMessageEventArgs e, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
// remember
RememberMessage(e.Channel, new LastMessage(LastMessageType.ChannelAction, e.SenderNickname, e.Message));
}
private void DecompressPayload()
{
if (_payload_compressed.Length == 0)
{
return;
}
byte[] decompressed = Flags.HasFlag(MessageFlags.Compressed)
? _payload_compressed.DecompressLz4(PayloadMaxSize)
: _payload_compressed;
Payload = ReflectionCache <MessageCommand> .CreateSerializable(Command, decompressed);
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (args.Channel != Config.CasinoChannel)
{
return;
}
bool botJoin = false;
if (args.Message.Trim() == "?join")
{
// "?join"
botJoin = true;
}
else
{
string[] bits = args.Message.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (
bits.Length >= 2 &&
bits[0] == "?join" &&
bits.Skip(1).Any(b => b.Equals(ConnectionManager.MyNickname, StringComparison.OrdinalIgnoreCase))
)
{
// "?join MyBot" or "?join ThisBot ThatBot MyBot"
botJoin = true;
}
}
if (botJoin)
{
ConnectionManager.SendChannelMessage(args.Channel, ".botjoin");
ConnectionManager.SendChannelMessage(args.Channel, ".grules");
}
// FIXME: these should be JSON events
if (string.Equals(args.SenderNickname, Config.GameMasterNickname, StringComparison.OrdinalIgnoreCase))
{
if (
args.Message == "Merging the discards back into the shoe and shuffling..." ||
args.Message == "The dealer's shoe has been shuffled."
)
{
CardCounter.ShoeShuffled();
DispatchStratDebugMessage($"shoe shuffled -> {CardCounter}");
}
}
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs e, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (HandleReplacementCommand(e))
{
return;
}
RememberMessage(e.Channel, new LastMessage(LastMessageType.ChannelMessage, e.SenderNickname, e.Message));
}
public T DecodeMessage <T>(MessageFlags messageFlags, Func <T> decode) where T : Message
{
// H5OShared.h (H5O_SHARED_DECODE)
if (messageFlags.HasFlag(MessageFlags.Shared))
{
var sharedMessage = new SharedMessage(_context.Reader, _context.Superblock);
return(this.DecodeSharedMessage <T>(sharedMessage));
}
else
{
return(decode());
}
}
protected virtual void HandleQueryMessage(object sender, IPrivateMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (!string.Equals(args.SenderNickname, Config.GameMasterNickname, StringComparison.OrdinalIgnoreCase))
{
return;
}
var messageBody = args.Message;
if (LinesLeftInMessage > 0)
{
// add this
CurrentMessageJson.Append(messageBody);
--LinesLeftInMessage;
}
else
{
var match = UnoBotFirstMessage.Match(messageBody);
if (!match.Success)
{
// nope
return;
}
LinesLeftInMessage = int.Parse(match.Groups[1].Value);
CurrentMessageJson.Append(match.Groups[2].Value);
--LinesLeftInMessage;
}
if (LinesLeftInMessage > 0)
{
// wait for more
return;
}
// ready to parse
var parseMe = CurrentMessageJson.ToString();
CurrentMessageJson.Clear();
var evt = JObject.Parse(parseMe);
ProcessJsonEvent(evt);
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
if (!flags.HasFlag(MessageFlags.UserBanned))
{
HandlePotentialDemoderation(args.Channel, args.SenderNickname, args.Message);
}
if (args.Message.StartsWith(ConnectionManager.CommandManager.Config.CommandPrefix))
{
if (args.Message.TrimEnd().IndexOf(' ') == -1)
{
// starts with a command character and has no spaces
// do not consider this message relevant
return;
}
}
using (var ctx = GetNewContext())
{
if (IsImmune(ctx, args.Channel, args.SenderNickname))
{
return;
}
}
RingBuffer <ChannelMessage> messages = GetOrCreateValue(
ChannelsMessages, args.Channel, chan => new RingBuffer <ChannelMessage>(Config.BacklogSize)
);
messages.Add(new ChannelMessage
{
Nickname = args.SenderNickname,
Username = ConnectionManager.RegisteredNameForNick(args.SenderNickname),
Body = args.Message,
Sanctioned = false
});
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs e, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (e.Channel != Config.TriviaChannel)
{
return;
}
if (GameState != null)
{
lock (GameState.Lock)
{
CheckForCorrectAnswer(e.SenderNickname, e.Message);
}
}
}
protected void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
string body = args.Message;
// find all the links
IList <Uri> links = FindLinks(body);
// store the new "last link"
if (links.Count > 0)
{
LastLinkAndInfo = LinkAndInfo.CreateUnfetched(links[links.Count - 1]);
}
// do something with the links
LinksAction(args, flags, links);
}
protected virtual void HandleChannelAction(object sender, IChannelMessageEventArgs e, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
// put into backlog
var normalizedNick = ConnectionManager.RegisteredNameForNick(e.SenderNickname) ?? e.SenderNickname;
var quote = new Quote
{
Timestamp = DateTime.Now.ToUniversalTimeForDatabase(),
Channel = e.Channel,
Author = normalizedNick,
MessageType = "A",
Body = e.Message
};
AddPotentialQuote(quote, e.Channel);
CleanOutPotentialQuotes(e.Channel);
}
internal static ImapFolderState Create(List <MessageRec> messages, int seqNumCrawl, uint uidNext, uint uidValidity)
{
if (messages.Count == 0)
{
return(new ImapFolderState
{
SeqNumCrawl = seqNumCrawl,
UidNext = uidNext,
UidValidity = uidValidity
});
}
Dictionary <uint, MessageRec> dictionary = new Dictionary <uint, MessageRec>();
foreach (MessageRec messageRec in messages)
{
uint key = ImapEntryId.ParseUid(messageRec.EntryId);
dictionary.Add(key, messageRec);
}
GlobCountSet globCountSet = new GlobCountSet();
GlobCountSet globCountSet2 = new GlobCountSet();
for (uint num = uidNext - 1U; num > 0U; num -= 1U)
{
MessageRec messageRec2 = null;
if (!dictionary.TryGetValue(num, out messageRec2))
{
globCountSet2.Insert((ulong)num);
}
else
{
MessageFlags messageFlags = (MessageFlags)((int)messageRec2[PropTag.MessageFlags]);
if (messageFlags.HasFlag(MessageFlags.Read))
{
globCountSet.Insert((ulong)num);
}
}
}
return(new ImapFolderState(seqNumCrawl, uidNext, uidValidity, globCountSet, globCountSet2));
}
public byte[] GetBytes()
{
var memoryStream = new MemoryStream();
var writer = new BigEndianBinaryWriter(memoryStream);
writer.Write((byte)((int)MessageFlags << 5 | (int)MessageType));
if (MessageFlags.HasFlag(MessageFlags.IsRedirected))
{
writer.Write(RealSourceId);
}
writer.Write(SourceId);
writer.Write(DestinationId);
if (MessageType.IsReliable())
{
writer.Write(Guid.ToByteArray());
writer.Write(RealHash);
}
writer.Write(Payload.Length);
writer.Write(Payload);
return(memoryStream.ToArray());
}
/// <summary>Used internally by the netcode to create a new sent message.</summary>
internal MessageSent(
Peer peer,
IMessageListener listener,
IWritable payload,
MessageType type,
MessageFlags flags,
ushort sequence,
byte channel
)
{
Peer = peer;
Listener = listener;
Payload = payload;
Type = type;
Flags = flags;
Sequence = sequence;
Channel = channel;
Attempts = 0;
TimeCreated = peer.Host.Timestamp;
TimeSent = peer.Host.Timestamp;
Acknowledged = false;
Token = flags.HasFlag(MessageFlags.Reliable) ? new CancellationTokenSource() : null;
}
public BaseMessage(byte[] messageData)
{
var reader = new BigEndianBinaryReader(new MemoryStream(messageData));
var messageInfo = reader.ReadByte();
MessageFlags = (MessageFlags)(messageInfo >> 5);
MessageType = (MessageType)(messageInfo & 0x1F);
if (MessageFlags.HasFlag(MessageFlags.IsRedirected))
{
RealSourceId = reader.ReadUInt16();
}
SourceId = reader.ReadUInt16();
DestinationId = reader.ReadUInt16();
if (MessageType.IsReliable())
{
Guid = new Guid(reader.ReadBytes(16));
Hash = reader.ReadBytes(HashUtil.GetHashSize());
}
var payloadLength = reader.ReadInt32();
if (payloadLength < 0)
{
throw new DnmpException($"Payload length < 0: {payloadLength}");
}
if (payloadLength > 128 * 1024 * 1024)
{
throw new DnmpException("tLen is larger than 20MiB");
}
Payload = reader.ReadBytes(payloadLength);
RealHash = HashUtil.ComputeChecksum(Payload);
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
var originalBody = args.Message;
var channel = args.Channel;
if (Config.ChannelBlacklist.Contains(channel))
{
return;
}
if (!CooldownsPerChannel.ContainsKey(channel))
{
CooldownsPerChannel[channel] = new List <int>(Enumerable.Repeat(0, Config.Replacements.Count));
}
var lookups = new Dictionary <string, string>
{
["username"] = args.SenderNickname
};
var chunks = ConnectionManager.SplitMessageToChunks(args.Message);
var newBody = new StringBuilder();
var newCooldowns = new List <int>(CooldownsPerChannel[channel]);
foreach (var chunk in chunks)
{
var textChunk = chunk as TextMessageChunk;
if (textChunk == null)
{
// don't touch this
newBody.Append(chunk);
continue;
}
bool somethingHit = false;
bool fullReplacement = false;
int i = -1;
var newChunk = textChunk.Text;
foreach (var repl in Config.Replacements)
{
++i;
if (repl.OnlyIfPrecedingHit && !somethingHit)
{
// no preceding rule hit; don't apply this one
continue;
}
if (repl.AdditionalProbabilityPercent > 0.0)
{
var replProbabilityValue = Random.NextDouble() * 100.0;
if (replProbabilityValue >= repl.AdditionalProbabilityPercent)
{
// next!
continue;
}
}
// perform the replacement
string nextNewChunk = ReplacerRegexes[i].Replace(newChunk, lookups);
if (Config.CooldownIncreasePerHit >= 0 || repl.CustomCooldownIncreasePerHit >= 0)
{
if (!string.Equals(newChunk, nextNewChunk, StringComparison.Ordinal))
{
// this rule changed something!
if (newCooldowns[i] == 0)
{
// warm, apply it!
newChunk = nextNewChunk;
somethingHit = true;
}
// cool down
newCooldowns[i] += (repl.CustomCooldownIncreasePerHit >= 0)
? repl.CustomCooldownIncreasePerHit
: Config.CooldownIncreasePerHit;
if (repl.ReplaceFullMessage)
{
// the replacement shall become the whole new body
newBody.Clear();
newBody.Append(newChunk);
// stop looping here
fullReplacement = true;
break;
}
}
else if (newCooldowns[i] > 0)
{
// this rule didn't change anything; warm up!
--newCooldowns[i];
}
}
else
{
// no cooldowns
newChunk = nextNewChunk;
if (repl.ReplaceFullMessage && !string.Equals(newChunk, nextNewChunk, StringComparison.Ordinal))
{
// the replacement shall become the whole new body
newBody.Clear();
newBody.Append(newChunk);
// stop looping here
fullReplacement = true;
break;
}
}
}
if (Config.CooldownIncreasePerHit >= 0)
{
// update cooldowns
CooldownsPerChannel[channel].Clear();
CooldownsPerChannel[channel].AddRange(newCooldowns);
Logger.LogDebug("cooldowns are now: {Cooldowns}", newCooldowns.Select(c => c.ToString()).StringJoin(", "));
}
if (fullReplacement)
{
// the body has been fully replaced
break;
}
newBody.Append(newChunk);
}
if (string.Equals(newBody.ToString(), originalBody, StringComparison.Ordinal))
{
return;
}
var thisProbabilityValue = Random.NextDouble() * 100.0;
if (thisProbabilityValue < Config.ProbabilityPercent)
{
Logger.LogDebug("{RandomProbability} < {ConfigProbability}; posting {Body}", thisProbabilityValue, Config.ProbabilityPercent, newBody);
ConnectionManager.SendChannelMessage(args.Channel, newBody.ToString());
}
else
{
Logger.LogDebug("{RandomProbability} >= {ConfigProbability}; not posting {Body}", thisProbabilityValue, Config.ProbabilityPercent, newBody);
}
}
private void ActuallyHandleChannelMessageOrAction(object sender, IChannelMessageEventArgs e, MessageFlags flags, bool action)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
var body = e.Message;
if (body.Length == 0)
{
return;
}
if (!Config.Channels.Contains(e.Channel))
{
return;
}
// clean out the backlog
while (Backlog.Count > Config.BacklogSize)
{
Backlog.Dequeue();
}
var normalizedSender = Connection.RegisteredNameForNick(e.SenderNickname) ?? e.SenderNickname;
// append the message
Backlog.Enqueue(new BacklogMessage
{
Sender = normalizedSender,
Body = body,
Action = action
});
// perform accounting
var messageToSenders = new Dictionary <string, HashSet <string> >();
foreach (var backMessage in Backlog)
{
var actualBody = (backMessage.Action ? 'A' : 'M') + backMessage.Body;
if (backMessage.Sender == Connection.MyNickname)
{
// this is my message -- start counting from zero, so to speak
messageToSenders[actualBody] = new HashSet <string>();
}
else
{
if (!messageToSenders.ContainsKey(actualBody))
{
messageToSenders[actualBody] = new HashSet <string>();
}
messageToSenders[actualBody].Add(backMessage.Sender);
}
}
foreach (var messageAndSenders in messageToSenders)
{
var msg = messageAndSenders.Key;
var senders = messageAndSenders.Value;
if (senders.Count < Config.TriggerCount)
{
continue;
}
Logger.LogDebug(
"bowing to the group pressure of ({Senders}) sending {Message}",
senders.Select(s => StringUtil.LiteralString(s)).StringJoin(", "),
StringUtil.LiteralString(msg)
);
// submit to group pressure
bool lastAction;
if (msg[0] == 'A')
{
Connection.SendChannelAction(e.Channel, msg.Substring(1));
lastAction = true;
}
else
{
Connection.SendChannelMessage(e.Channel, msg.Substring(1));
lastAction = false;
}
// fake this message into the backlog to prevent duplicates
Backlog.Enqueue(new BacklogMessage
{
Sender = Connection.MyUsername,
Body = body,
Action = lastAction
});
}
}
protected void ActuallyHandleMessage(Action <string> respond, IUserMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
var lowerBody = args.Message.ToLowerInvariant();
ResponseManager commandResponseManager;
if (CommandsResponses.TryGetValue(lowerBody, out commandResponseManager))
{
Output(respond, args, lowerBody, commandResponseManager, args.SenderNickname);
return;
}
var channelNicks = new HashSet <string>();
var channelMessage = args as IChannelMessageEventArgs;
if (channelMessage != null)
{
var nicknamesInChannel = ConnectionManager.NicknamesInChannel(channelMessage.Channel);
if (nicknamesInChannel != null)
{
channelNicks.UnionWith(nicknamesInChannel);
}
}
foreach (var nickCommandResponse in NicknamableCommandsResponses)
{
if (!lowerBody.StartsWith(nickCommandResponse.Key))
{
// not this command
continue;
}
if (lowerBody.TrimEnd() == nickCommandResponse.Key)
{
// command on its own; trigger for self
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, args.SenderNickname);
return;
}
// trigger for someone else?
string targetedNickCased = args.Message.Substring(nickCommandResponse.Key.Length).Trim();
string targetedNick = lowerBody.Substring(nickCommandResponse.Key.Length).Trim();
if (targetedNickCased == "-r" || targetedNickCased == "--random")
{
// random pick, biased towards active users
if (channelNicks.Count == 0)
{
// emergency trick: target the sender
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, args.SenderNickname);
return;
}
Debug.Assert(channelMessage != null);
// each message in the last n messages leads to an entry in the pick list
// this increases the chances of being picked
var pickList = new List <string>();
LinkedList <string> lastMessageAuthors;
if (ChannelsToLastMessageAuthors.TryGetValue(channelMessage.Channel, out lastMessageAuthors))
{
foreach (string author in lastMessageAuthors)
{
if (channelNicks.Contains(author))
{
pickList.Add(author);
}
}
}
pickList.AddRange(channelNicks);
int index = RNG.Next(channelNicks.Count);
string target = pickList[index];
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, target);
return;
}
else if (targetedNickCased == "-R" || targetedNickCased == "--really-random")
{
// random pick of any user in the channel
if (channelNicks.Count == 0)
{
// emergency trick: target the sender
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, args.SenderNickname);
return;
}
Debug.Assert(channelMessage != null);
int index = RNG.Next(channelNicks.Count);
string target = channelNicks.ElementAt(index);
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, target);
return;
}
foreach (string channelNick in channelNicks)
{
if (channelNick.ToLowerInvariant() == targetedNick)
{
// nickname directly from user list
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, channelNick);
return;
}
}
// registered nickname?
var registeredTargetNick = ConnectionManager.RegisteredNameForNick(targetedNick);
if (registeredTargetNick == null)
{
// nope, targeted nick is not registered
return;
}
foreach (string channelNick in channelNicks)
{
var registeredChannelNick = ConnectionManager.RegisteredNameForNick(channelNick);
if (registeredChannelNick == null)
{
// this channel nickname is not registered
continue;
}
if (registeredTargetNick == registeredChannelNick)
{
// registered nicknames match
Output(respond, args, nickCommandResponse.Key, nickCommandResponse.Value, channelNick);
return;
}
}
}
}
public bool HasFlag(Enum flag)
{
return(Flag.HasFlag((MessageFlags)flag));
}
protected virtual void HandleChannelMessage(object sender, IChannelMessageEventArgs args, MessageFlags flags)
{
if (flags.HasFlag(MessageFlags.UserBanned))
{
return;
}
if (args.SenderNickname == ConnectionManager.MyNickname)
{
return;
}
if (Config.UnoChannel != args.Channel)
{
return;
}
if (IsBotCommand(args.Message, "?join"))
{
ConnectionManager.SendChannelMessage(args.Channel, "!botjoin");
// don't curse if the number of cards jumps up from 1 to 7 ;)
LastHandCount = 0;
return;
}
if (IsBotCommand(args.Message, "?leave"))
{
ConnectionManager.SendChannelMessage(args.Channel, "!leave");
return;
}
if (args.Message.StartsWith("??color "))
{
var denyColor = false;
if (!CurrentPlayers.Contains(args.SenderNickname))
{
// player is not taking part
StrategyLogger.LogDebug("denying {Nickname}'s color request because they are a spectator", args.SenderNickname);
denyColor = true;
}
if (CurrentCardCounts.Values.All(v => v > Config.PlayToWinThreshold))
{
// everybody has more than two cards
StrategyLogger.LogDebug("denying {Nickname}'s color request because everybody has more than {CardCount} cards", args.SenderNickname, Config.PlayToWinThreshold);
denyColor = true;
}
if (CurrentCardCounts.ContainsKey(args.SenderNickname) && CurrentCardCounts[args.SenderNickname] <= Config.PlayToWinThreshold)
{
// the person who is asking has two cards or less
StrategyLogger.LogDebug("denying {Nickname}'s color request because they have {CardThreshold} cards or fewer ({CardCount})", args.SenderNickname, Config.PlayToWinThreshold, CurrentCardCounts[args.SenderNickname]);
denyColor = true;
}
if (CurrentHand.Count <= Config.PlayToWinThreshold)
{
// I have two cards or less
StrategyLogger.LogDebug("denying {Nickname}'s color request because I have {CardThreshold} cards or fewer ({CardCount})", args.SenderNickname, Config.PlayToWinThreshold, CurrentHand.Count);
denyColor = true;
}
if (denyColor)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Sorry, {0}, no can do.", args.SenderNickname);
return;
}
var colorString = args.Message.Substring(("??color ").Length);
var color = CardUtils.ParseColor(colorString);
if (!color.HasValue || color == CardColor.Wild)
{
ConnectionManager.SendChannelMessage(args.Channel, "Uhh, what color is that?");
return;
}
ColorRequest = color;
// can I change the color?
if (CurrentHand.Any(c => c.Color == CardColor.Wild))
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Yeah, I think that's doable, {0}.", args.SenderNickname);
}
else if (CurrentHand.Any(c => c.Color == color))
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "No color changers, but I'll try, {0}.", args.SenderNickname);
}
else
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Ain't got the cards, {0}, but I'll try...", args.SenderNickname);
}
return;
}
var runtimeTweakMatch = RuntimeTweakPattern.Match(args.Message);
if (runtimeTweakMatch.Success)
{
if (!Config.RuntimeTweakable)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "Sorry, {0}, I'm not allowed to do that.", args.SenderNickname);
return;
}
try
{
ConfigTweaking.TweakConfig(Config, runtimeTweakMatch.Groups["property"].Value, runtimeTweakMatch.Groups["value"].Value);
}
catch (ArgumentException ae)
{
ConnectionManager.SendChannelMessageFormat(args.Channel, "That didn't work out, {0}: {1}", args.SenderNickname, ae.Message);
return;
}
ConnectionManager.SendChannelMessageFormat(args.Channel, "{0}: Done.", args.SenderNickname);
return;
}
}
