public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var text = Uri.EscapeUriString(match.Groups[3].Value);
var client = new HttpClient();
client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("en-us"));
client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
client.GetAsync(String.Format(Url, text)).ContinueWith(task =>
{
if (task.Result.IsSuccessStatusCode)
{
task.Result.Content.ReadAsStringAsync().ContinueWith(readTask =>
{
jabbrClient.SayToRoom(message.Room, readTask.Result);
});
}
else
{
jabbrClient.PrivateReply(message.From, "Error ascii'ing that for you.");
}
});
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = PrivateMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var url = string.Format("http://www.google.com/ig/calculator?hl=en&q={0}", Uri.EscapeDataString(match.Groups[3].Value));
var client = new HttpClient();
client.Timeout = new TimeSpan(0, 0, 2);
client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("en-us"));
client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
var request = client.GetAsync(url).ContinueWith(requestTask =>
{
if (requestTask.Result.IsSuccessStatusCode)
{
requestTask.Result.Content.ReadAsStringAsync().ContinueWith(readTask =>
{
dynamic json = JsonConvert.DeserializeObject(readTask.Result);
string solution = json.rhs;
jabbrClient.SayToRoom(message.Room, solution ?? "Does not compute.");
});
}
else
{
jabbrClient.SayToRoom(message.Room, "Does not compute.");
}
});
}
}
public override bool CanHandle(IRoomMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
return RoomMessagePatterns.Any(p => p.Match(message.Content).Success);
}
public virtual bool CanHandle(IRoomMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
return(false);
}
public override bool CanHandle(IRoomMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
return(RoomMessagePatterns.Any(p => p.Match(message.Content).Success));
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
jabbrClient.SayToRoom(message.Room, Carltons.RandomElement());
}
}
public virtual bool CanHandle(IRoomMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
return false;
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var formattedInformation = GetFormattedInformation();
jabbrClient.SayToRoom(message.Room, formattedInformation);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var formattedInformation = GetFormattedInformation();
jabbrClient.SayToRoom(message.Room, formattedInformation);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = PrivateMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var choices = match.Groups[1].Value.Split(new string[] { "\"" }, StringSplitOptions.None).Where(s => !string.IsNullOrWhiteSpace(s));
jabbrClient.SayToRoom(message.Room, choices.RandomElement());
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var id = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content).Groups[2].Value;
var url = string.IsNullOrWhiteSpace(id) ? GetRandomUrl() : GetComicUrl(id);
jabbrClient.SayToRoom(message.Room, url);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var location = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content).Groups[3].Value;
var formattedInformation = GetWeather(location);
jabbrClient.SayToRoom(message.Room, formattedInformation);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
foreach (var rule in Rules)
{
jabbrClient.SayToRoom(message.Room, rule);
}
}
}
public virtual void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (jabbrClient == null)
{
throw new ArgumentNullException("jabbrClient");
}
}
public virtual void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (jabbrClient == null)
{
throw new ArgumentNullException("jabbrClient");
}
}
private async void AddMessage(IRoom room, IRoomMessage roomMessage)
{
List <ChatBox> chatBoxLinkedToRoomList = _chatBoxList.Where(x => x.ID == room.ID).ToList();
var addedChatBoxMessageList = new List <ChatBoxMessage>();
ChatBoxMessage chatBoxMessage;
chatBoxLinkedToRoomList.ForEach(y =>
{
chatBoxMessage = CreateChatBoxMessage(roomMessage.Author, roomMessage.Message);
y.RoomMessageList.Add(chatBoxMessage);
MessageAdded?.Invoke(y, chatBoxMessage);
});
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
Task.Factory.StartNew(() =>
{
var match = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var imageUrl = match.Groups[2].Value;
var stachedImageUrl = String.Format("http://faceup.me/img.jpg?overlay={0}&src={1}", Accessories.RandomElement(), Uri.EscapeDataString(imageUrl));
jabbrClient.SayToRoom(message.Room, stachedImageUrl);
}).ContinueWith(task =>
{
var result = task.Exception;
},
TaskContinuationOptions.OnlyOnFaulted);
}
}
public void ReceiveMessage(IRoomMessage message)
{
if (message == null || string.IsNullOrEmpty(message.Action) || message.PlayerId == 0)
{
throw new ArgumentNullException(nameof(message));
}
if (message.Action.ToUpperInvariant() == "MSG")
{
Message(Players.Single(a => a.PlayerId == message.PlayerId), message.Args[0].ToString());
}
else if (message.Action.ToUpperInvariant() == "WHISPER")
{
if (long.TryParse(message.Args[0].ToString(), out long toPlayerId))
{
Whisper(Players.Single(a => a.PlayerId == message.PlayerId),
Players.Single(a => a.PlayerId == toPlayerId),
message.Args[0].ToString());
}
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var achievement = Uri.EscapeUriString(match.Groups[2].Value);
var email = Uri.EscapeUriString(match.Groups[5].Value);
var url = String.Format(Url, achievement);
if (!String.IsNullOrWhiteSpace(email))
{
url += String.Format("?email={0}.png", email);
}
jabbrClient.SayToRoom(message.Room, url);
}
}
public virtual async void ReceiveMessage(IRoomMessage message)
{
if (message == null || string.IsNullOrEmpty(message.Action))
{
return;
}
if (Players.TryGetValue(new Player(message.PlayerId), out IPlayer p))
{
if (message.Action == "READY")
{
if (PlayerReadyState.ContainsKey(p))
{
SetPlayerReadyState(p);
}
await SendMessageAsync().ConfigureAwait(false);
}
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
if (RoomMessagePatterns.ElementAt(0).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, new string[] { "(ノಠ益ಠ)ノ︵┻━┻", "（╯°□°）╯︵ ┻━┻" }.RandomElement());
}
else if (RoomMessagePatterns.ElementAt(1).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "┬──┬◡ﾉ(° -°ﾉ)");
}
else if (RoomMessagePatterns.ElementAt(2).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "(ケ¬◟¬)ケ");
}
else if (RoomMessagePatterns.ElementAt(3).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "ლ(ಠ益ಠლ)");
}
else if (RoomMessagePatterns.ElementAt(4).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, new string[] { "♪┏(・o･)┛♪", "♪┗ ( ･o･) ┓♪", "♪┏ (･o･) ┛♪", "♪┗ (･o･ ) ┓♪", "♪┏(･o･)┛♪" }.RandomElement());
}
else if (RoomMessagePatterns.ElementAt(5).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "ಠ_ಠ");
}
else if (RoomMessagePatterns.ElementAt(6).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, @"¯\_(ツ)_/¯");
}
}
}
public async void ReceiveMessage(IRoomMessage message)
{
//Check parameters
if (message == null || string.IsNullOrEmpty(message.Action) || message.PlayerId == 0 ||
message.Args == null)
{
return;
}
//Check who's turn it's currently is
if (CurrentPlayerTurn == message.PlayerId)
{
var action = message.Action.ToUpperInvariant();
object[] args;
switch (action)
{
case "ROLL":
//Check if player already have roled
if (Roll == 0)
{
//Check have many rolls the player have
short totalRollAmount = RollAmount(message.PlayerId);
//Check if the player have any tries left
if (RollAttempts < totalRollAmount)
{
RollAttempts += 1;
//All pieces in start zone
if (totalRollAmount > 1)
{
var RollAmount = RollDie();
//Need to role a 6 to get a piece out of starting zone
if (RollAmount == 6)
{
//Move a random piece from bench to board
var pawn = pawns[message.PlayerId].FirstOrDefault(a => a.Position == -1);
if (pawn != null)
{
pawn.Position = playerHomePads[message.PlayerId];
await SendMessageAsync(new GameMessageUnity(RoomID, "MOVE",
pawn.Id + "|" + pawn.Position))
.ConfigureAwait(false);
var pawnsOnPosition = PawnsOnPosition(pawn.Position).ToList();
foreach (var ludoPawn in pawnsOnPosition.Where(a =>
a.Owner != message.PlayerId))
{
await SendMessageAsync(new GameMessageUnity(RoomID, "MOVE",
ludoPawn.Id + "|-1"))
.ConfigureAwait(false);
}
}
AdvanceTurn();
return;
}
if (RollAttempts == 3)
{
//No roll left
AdvanceTurn();
}
await SendMessageAsync(new GameMessageUnity(RoomID, "ROLL",
RollAmount.ToString()))
.ConfigureAwait(false);
}
else
{
//Normal roll
Roll = RollDie();
await SendMessageAsync(new GameMessageUnity(RoomID, action, Roll.ToString()))
.ConfigureAwait(false);
}
}
else
{
//TODO should not be possible to hit this
throw new NotImplementedException();
}
}
break;
case "MOVE":
if (Roll == 0)
{
return;
}
RollAttempts = 0;
//Check parameters
if (int.TryParse(message.Args[0].ToString(), out int pawnId) && Roll != 0)
{
//Find the pawn the player is trying to move
var playerPawn = pawns[message.PlayerId].Single(a => a.Id == pawnId);
//Check if pawn is done
if (playerPawn.Position == -2)
{
return;
}
//Check if pawn is in start position and roll a 6
if (playerPawn.Position == -1)
{
if (Roll == 6)
{
playerPawn.Position = playerHomePads[message.PlayerId];
await SendMessageAsync(new GameMessageUnity(RoomID, action,
playerPawn.Id + "|" + playerPawn.Position)).ConfigureAwait(false);
AdvanceTurn();
return;
}
else
{
//Need to role a 6 before getting 1 more pawn out of start
return;
}
}
var playerGoalEntrance = goalEntrances[message.PlayerId];
var playerGoal = 57 + (playerPawn.TeamId * 5);
var playerPosition = playerPawn.Position;
var newPositionRaw = playerPawn.Position + Roll;
if (playerPawn.Position > 51)
{
//Inside goal row
if (newPositionRaw == playerGoal)
{
await PawnToGoal(playerPawn).ConfigureAwait(false);
}
else
{
//Check if higher
if (newPositionRaw > playerGoal)
{
var difference = newPositionRaw - playerGoal;
playerPawn.Position = playerGoal - difference;
//playerPawn.Position = newPositionRaw - playerGoal;
}
else
{
playerPawn.Position = newPositionRaw;
}
await SendMessageAsync(new GameMessageUnity(RoomID, action,
playerPawn.Id + "|" + playerPawn.Position)).ConfigureAwait(false);
AdvanceTurn();
}
return;
}
else
{
if (newPositionRaw > 51)
{
playerPosition = 0;
newPositionRaw = playerPawn.Position + Roll - 52;
}
if ((newPositionRaw >= playerGoalEntrance && playerGoalEntrance >= playerPosition))
{
//Check if land on start
if (newPositionRaw == playerGoalEntrance)
{
await PawnToGoal(playerPawn).ConfigureAwait(false);
return;
}
if (playerPosition == 0)
{
playerPawn.Position = (playerGoal - 6) + newPositionRaw;
}
else
{
playerPawn.Position =
(playerGoal - 6) +
(Roll - (playerGoalEntrance - playerPawn.Position));
}
if (playerPawn.Position == playerGoal)
{
await PawnToGoal(playerPawn).ConfigureAwait(false);
return;
}
await SendMessageAsync(new GameMessageUnity(RoomID, action,
playerPawn.Id + "|" + playerPawn.Position)).ConfigureAwait(false);
AdvanceTurn();
return;
}
}
//Calculate new position for pawn
int newPosition = CalculateNewPosition(playerPawn.Position + Roll);
//Check if pawn lands on star then jump to next star
if ((tileMap[newPosition].Type & (int)TileType.STAR) == (int)TileType.STAR)
{
newPosition = JumpNextStar(newPosition);
}
//Get a list of pawns on the same position
var pawnsOnPosition = PawnsOnPosition(newPosition).ToList();
playerPawn.Position = newPosition;
//Loop other pawns if there are any
foreach (var otherPawn in pawnsOnPosition)
{
//Check if other player's pawns
if (otherPawn.Owner != message.PlayerId)
{
//If the player's pawn land on a globe where a other pawn is already standing it kill itself.
if ((tileMap[newPosition].Type & (int)TileType.GLOBE) == (int)TileType.GLOBE)
{
//Suicide
playerPawn.Position = -1;
}
else
{
//Check if there is multiple pawns on the position
if (pawnsOnPosition.Count > 1)
{
playerPawn.Position = -1;
}
else
{
//KILL otherPawn
otherPawn.Position = -1;
await SendMessageAsync(new GameMessageUnity(RoomID, action,
otherPawn.Id + "|" + "-1"))
.ConfigureAwait(false);
}
}
}
}
await SendMessageAsync(new GameMessageUnity(RoomID, action,
playerPawn.Id + "|" + playerPawn.Position)).ConfigureAwait(false);
AdvanceTurn();
}
break;
default:
break;
}
}
}
public void AddMessage(IRoomMessage chatboxMessage)
{
RoomMessageList.Add((RoomMessage)chatboxMessage);
NewMessage?.Invoke(chatboxMessage);
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
if (RoomMessagePatterns.ElementAt(0).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, new string[] { "(ノಠ益ಠ)ノ︵┻━┻", "（╯°□°）╯︵ ┻━┻" }.RandomElement());
}
else if (RoomMessagePatterns.ElementAt(1).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "┬──┬◡ﾉ(° -°ﾉ)");
}
else if (RoomMessagePatterns.ElementAt(2).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "(ケ¬◟¬)ケ");
}
else if (RoomMessagePatterns.ElementAt(3).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "ლ(ಠ益ಠლ)");
}
else if (RoomMessagePatterns.ElementAt(4).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, new string[] { "♪┏(・o･)┛♪", "♪┗ ( ･o･) ┓♪", "♪┏ (･o･) ┛♪", "♪┗ (･o･ ) ┓♪", "♪┏(･o･)┛♪" }.RandomElement());
}
else if (RoomMessagePatterns.ElementAt(5).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, "ಠ_ಠ");
}
else if (RoomMessagePatterns.ElementAt(6).IsMatch(message.Content))
{
jabbrClient.SayToRoom(message.Room, @"¯\_(ツ)_/¯");
}
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var location = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content).Groups[3].Value;
var formattedInformation = GetWeather(location);
jabbrClient.SayToRoom(message.Room, formattedInformation);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
jabbrClient.SayToRoom(message.Room, Coin.RandomElement());
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
foreach (var rule in Rules)
{
jabbrClient.SayToRoom(message.Room, rule);
}
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = PrivateMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var choices = match.Groups[1].Value.Split(new string[] { "\"" }, StringSplitOptions.None).Where(s => !string.IsNullOrWhiteSpace(s));
jabbrClient.SayToRoom(message.Room, choices.RandomElement());
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = RoomMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var achievement = Uri.EscapeUriString(match.Groups[2].Value);
var email = Uri.EscapeUriString(match.Groups[5].Value);
var url = String.Format(Url, achievement);
if (!String.IsNullOrWhiteSpace(email))
{
url += String.Format("?email={0}.png", email);
}
jabbrClient.SayToRoom(message.Room, url);
}
}
public override void Handle(IRoomMessage message, IJabbrClient jabbrClient)
{
base.Handle(message, jabbrClient);
if (this.CanHandle(message))
{
var match = PrivateMessagePatterns.First(p => p.Match(message.Content).Success).Match(message.Content);
var url = string.Format("http://www.google.com/ig/calculator?hl=en&q={0}", Uri.EscapeDataString(match.Groups[3].Value));
var client = new HttpClient();
client.Timeout = new TimeSpan(0, 0, 2);
client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("en-us"));
client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
var request = client.GetAsync(url).ContinueWith(requestTask =>
{
if (requestTask.Result.IsSuccessStatusCode)
{
requestTask.Result.Content.ReadAsStringAsync().ContinueWith(readTask =>
{
dynamic json = JsonConvert.DeserializeObject(readTask.Result);
string solution = json.rhs;
jabbrClient.SayToRoom(message.Room, solution ?? "Does not compute.");
});
}
else
{
jabbrClient.SayToRoom(message.Room, "Does not compute.");
}
});
}
}
