public override async Task <Message> HandleMessage(Message msg)
{
long pos = 0;
NumericMessage numeric = msg as NumericMessage;
if (numeric != null)
{
pos = (long)numeric.Number;
}
else
if (From != null)
{
MessageContext context = new MessageContext(msg, this);
var fromMsg = await From.TrySelectLongAsync(context);
if (!fromMsg.Parsed)
{
return(null);
}
pos = fromMsg.Value;
}
if (pos == 0)
{
pos = LastPosition++;
}
return(new NumericMessage
{
DerivedFrom = msg,
Number = Fib(pos)
});
}
private void ProcessPlayerInfoMessage(NumericMessage numericMessage)
{
InfoLog.WriteInfo("Processing player info message", EPrefix.ServerProcessInfo);
PlayerInfoMessage pimsg = (PlayerInfoMessage)MessageFactory.Create(MessageType.PlayerInfoResponse);
Player p = _server.GetPlayer((short)numericMessage.Number);
if (p == null)
{
pimsg.PlayerData = null;
}
else
{
pimsg.PlayerData = (PlayerData)p.PlayerData.Clone();
}
SendMessage(pimsg, numericMessage.SenderId);
}
private void ProcessLogin(LoginMessage msg)
{
//Pobranie gracza z listy niezalogowanych
Player player = _server.GetPlayerUnlogged(msg.SenderId);
InfoLog.WriteInfo(string.Format(ProcessStringFormat, "Login", msg.SenderId), EPrefix.ServerProcessInfo);
//Jesli gracza nie ma, lub jego stan jest jakis dziwny - koniec obslugi
if (null == player || player.State != MenuState.Unlogged)
{
return;
}
if ((Login(msg.SenderId, msg.Login, msg.Password) || !Settings.Default.DBAvail) && !IsPlayerAlreadyLogged(msg.Login))
{
MenuState state = PlayerStateMachine.Transform(player.State, MenuAction.Login);
if (state == MenuState.Invalid)
{
SendMessage(Utils.CreateResultMessage(ResponseType.Login, ResultType.Unsuccesful), player.Id);
return;
}
LoggingTransfer(player);
player.State = state;
if (!Settings.Default.DBAvail)
{
PlayerData pd = new PlayerData();
pd.Login = msg.Login;
pd.LossNo = pd.WinNo = 0;
pd.Id = msg.SenderId;
player.SetData(pd);
}
}
else
{
SendMessage(Utils.CreateResultMessage(ResponseType.Login, ResultType.Unsuccesful), player.Id);
InfoLog.WriteInfo("Player: " + msg.Login + "failed to login", EPrefix.ServerProcessInfo);
return;
}
SendMessage(Utils.CreateResultMessage(ResponseType.Login, ResultType.Successful), player.Id);
NumericMessage idmsg = (NumericMessage)MessageFactory.Create(MessageType.IdInformation);
idmsg.Number = player.Id;
SendMessage(idmsg, player.Id);
}
/// <summary>
/// Finds a message type to handle the message.
/// </summary>
public ReceivableMessage Process()
{
// Named messages.
if (NickMessage.CanProcess(this))
{
return(new NickMessage(this));
}
if (QuitMessage.CanProcess(this))
{
return(new QuitMessage(this));
}
if (JoinMessage.CanProcess(this))
{
return(new JoinMessage(this));
}
if (PartMessage.CanProcess(this))
{
return(new PartMessage(this));
}
if (PrivateMessage.CanProcess(this))
{
return(new PrivateMessage(this));
}
if (PingMessage.CanProcess(this))
{
return(new PingMessage(this));
}
if (NoticeMessage.CanProcess(this))
{
return(new NoticeMessage(this));
}
if (UserModeMessage.CanProcess(this))
{
return(new UserModeMessage(this));
}
if (ChannelModeMessage.CanProcess(this))
{
return(new ChannelModeMessage(this));
}
if (KickMessage.CanProcess(this))
{
return(new KickMessage(this));
}
if (InviteMessage.CanProcess(this))
{
return(new InviteMessage(this));
}
if (OperwallMessage.CanProcess(this))
{
return(new OperwallMessage(this));
}
if (Receive.TopicMessage.CanProcess(this))
{
return(new Receive.TopicMessage(this));
}
// IRCv3 messages.
if (Receive.v3.CapabilityMessage.CanProcess(this))
{
return(new Receive.v3.CapabilityMessage(this));
}
if (Receive.v3.AwayMessage.CanProcess(this))
{
return(new Receive.v3.AwayMessage(this));
}
// Numerics.
if (NumericMessage.CanProcess(this))
{
// Pass all numeric messages to NumericMessage so an event can be fired, then pass it to more specific instances.
// ReSharper disable once ObjectCreationAsStatement
new NumericMessage(this);
if (WelcomeMessage.CanProcess(this))
{
return(new WelcomeMessage(this));
}
if (YourHostMessage.CanProcess(this))
{
return(new YourHostMessage(this));
}
if (CreatedMessage.CanProcess(this))
{
return(new CreatedMessage(this));
}
if (MyInfoMessage.CanProcess(this))
{
return(new MyInfoMessage(this));
}
if (SupportMessage.CanProcess(this))
{
return(new SupportMessage(this));
}
if (BounceMessage.CanProcess(this))
{
return(new BounceMessage(this));
}
if (MOTDEndMessage.CanProcess(this))
{
return(new MOTDEndMessage(this));
}
if (MOTDStartMessage.CanProcess(this))
{
return(new MOTDStartMessage(this));
}
if (MOTDMessage.CanProcess(this))
{
return(new MOTDMessage(this));
}
if (LUserMessage.CanProcess(this))
{
return(new LUserMessage(this));
}
if (NamesMessage.CanProcess(this))
{
return(new NamesMessage(this));
}
if (EndOfNamesMessage.CanProcess(this))
{
return(new EndOfNamesMessage(this));
}
if (TopicMessage.CanProcess(this))
{
return(new TopicMessage(this));
}
if (TopicWhoTimeMessage.CanProcess(this))
{
return(new TopicWhoTimeMessage(this));
}
if (ListMessage.CanProcess(this))
{
return(new ListMessage(this));
}
if (ListEndMessage.CanProcess(this))
{
return(new ListEndMessage(this));
}
if (YoureOperMessage.CanProcess(this))
{
return(new YoureOperMessage(this));
}
if (AwayMessage.CanProcess(this))
{
return(new AwayMessage(this));
}
if (UnAwayMessage.CanProcess(this))
{
return(new UnAwayMessage(this));
}
if (NowAwayMessage.CanProcess(this))
{
return(new NowAwayMessage(this));
}
if (ChannelModeIsMessage.CanProcess(this))
{
return(new ChannelModeIsMessage(this));
}
if (UModeIsMessage.CanProcess(this))
{
return(new UModeIsMessage(this));
}
if (VersionMessage.CanProcess(this))
{
return(new VersionMessage(this));
}
if (TimeMessage.CanProcess(this))
{
return(new TimeMessage(this));
}
if (WhoMessage.CanProcess(this))
{
return(new WhoMessage(this));
}
if (WhoisMessage.CanProcess(this))
{
return(new WhoisMessage(this));
}
if (EndOfWhoMessage.CanProcess(this))
{
return(new EndOfWhoMessage(this));
}
if (EndOfWhoisMessage.CanProcess(this))
{
return(new EndOfWhoisMessage(this));
}
if (BanListMessage.CanProcess(this))
{
return(new BanListMessage(this));
}
if (EndOfBanListMessage.CanProcess(this))
{
return(new EndOfBanListMessage(this));
}
if (InviteListMessage.CanProcess(this))
{
return(new InviteListMessage(this));
}
if (EndOfInviteListMessage.CanProcess(this))
{
return(new EndOfInviteListMessage(this));
}
if (ExceptListMessage.CanProcess(this))
{
return(new ExceptListMessage(this));
}
if (EndOfExceptListMessage.CanProcess(this))
{
return(new EndOfExceptListMessage(this));
}
if (IsOnMessage.CanProcess(this))
{
return(new IsOnMessage(this));
}
// Catch all for unhandled error messages.
if (ErrorMessage.CanProcess(this))
{
return(new ErrorMessage(this));
}
}
Console.WriteLine("Message handler for \"" + Text + "\" not found.");
return(null);
}
internal void OnNumeric(NumericMessage message) => NumericMessage?.Invoke(message);
public void ProcessMessage(Message message)
{
handlerSuspender.WaitOne();
switch (message.Type)
{
case MessageType.Result:
{
ResultMessage result = message as ResultMessage;
switch ((ResponseType)result.ResponseType)
{
case ResponseType.Login:
if (LoginRequestReply != null)
{
LoginRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
case ResponseType.Register:
if (RegisterRequestReply != null)
{
RegisterRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
case ResponseType.Remind:
if (RemindRequestReply != null)
{
RemindRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
case ResponseType.CreateGame:
if (CreateGameRequestReply != null)
{
CreateGameRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
case ResponseType.JoinGame:
if (JoinGameRequestReply != null)
{
JoinGameRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
case ResponseType.StartGame:
if (StartGameRequestReply != null)
{
StartGameRequestReply(this, new RequestReplyEventArgs(!Convert.ToBoolean(result.Result), ((ResultType)(result.Result)).ToString()));
}
break;
}
}
break;
case MessageType.IdInformation:
{
NumericMessage numericMessage = message as NumericMessage;
ClientPlayerInfo.SenderId = (short)numericMessage.Number;
}
break;
case MessageType.ChatUsers:
{
ChatUsersMessage chatMessage = message as ChatUsersMessage;
switch ((MessageOperation)chatMessage.Option)
{
case MessageOperation.Add:
if (NewChatUsers != null)
{
NewChatUsers(this, new ChatEventArgs(chatMessage.ChatUsers.ToArray()));
}
break;
case MessageOperation.Remove:
if (DeleteChatUsers != null)
{
DeleteChatUsers(this, new ChatEventArgs(chatMessage.ChatUsers.ToArray()));
}
break;
case MessageOperation.List:
if (ResetChatUsers != null)
{
ResetChatUsers(this, new ChatEventArgs(chatMessage.ChatUsers.ToArray()));
}
break;
}
}
break;
case MessageType.ChatText:
if (ChatTextReceive != null)
{
TextMessage textMessage = message as TextMessage;
ChatTextReceive(this, new ChatEventArgs(textMessage.Text));
}
break;
case MessageType.PlayerInfoResponse:
if (PlayerInfoRequestReply != null)
{
PlayerInfoMessage playerInfoMessage = message as PlayerInfoMessage;
PlayerInfoRequestReply(this, new RequestReplyEventArgs(true, playerInfoMessage.PlayerData.ToString()));
}
break;
case MessageType.Games:
{
GamesMessage gamesMessage = message as GamesMessage;
switch ((MessageOperation)gamesMessage.Operation)
{
case MessageOperation.Add:
if (NewGamesInfo != null)
{
NewGamesInfo(this, new GameEventArgs(gamesMessage.ListGameInfo.ToArray()));
}
break;
case MessageOperation.Remove:
if (DeleteGamesInfo != null)
{
DeleteGamesInfo(this, new GameEventArgs(gamesMessage.ListGameInfo.ToArray()));
}
break;
case MessageOperation.List:
if (ResetGamesInfo != null)
{
ResetGamesInfo(this, new GameEventArgs(gamesMessage.ListGameInfo.ToArray()));
}
break;
}
}
break;
case MessageType.GameParams:
{
GameInfoMessage gameInfoMessage = message as GameInfoMessage;
ClientPlayerInfo.GameInfo = gameInfoMessage.GameInfo;
if (GameParamsRequestReply != null)
{
GameParamsRequestReply(this, new RequestReplyEventArgs(true, gameInfoMessage.GameInfo.Description));
}
}
break;
case MessageType.Players:
{
PlayersMessage playersMessage = message as PlayersMessage;
switch ((MessageOperation)playersMessage.Operation)
{
case MessageOperation.Add:
ClientPlayerInfo.Enemies.Add(playersMessage.PlayerList.ToArray());
if (NewPlayers != null)
{
NewPlayers(this, new PlayerEventArgs(playersMessage.PlayerList.ToArray()));
}
break;
case MessageOperation.Remove:
ClientPlayerInfo.Enemies.Remove(playersMessage.PlayerList.ToArray());
if (DeletePlayers != null)
{
DeletePlayers(this, new PlayerEventArgs(playersMessage.PlayerList.ToArray()));
}
break;
case MessageOperation.Modify:
{
PlayerInfo[] players = playersMessage.PlayerList.ToArray();
for (int i = 0; i < players.Length; i++)
{
if (ClientPlayerInfo.Player.Id == players[i].Id)
{
ClientPlayerInfo.Player = players[i];
break;
}
}
ClientPlayerInfo.Enemies.Modify(players);
if (UpdatePlayers != null)
{
UpdatePlayers(this, new PlayerEventArgs(players));
}
}
break;
case MessageOperation.List:
ClientPlayerInfo.Enemies.Clear();
ClientPlayerInfo.Enemies.Add(playersMessage.PlayerList.ToArray());
if (ResetPlayers != null)
{
ResetPlayers(this, new PlayerEventArgs(playersMessage.PlayerList.ToArray()));
}
break;
}
}
break;
default:
InfoLog.WriteInfo("MenuMessageHandler received unknown message type: " + message.Type, EPrefix.ClientInformation);
break;
}
handlerSuspender.Release();
}
/// <summary>
/// Convenience method so we can return and do an assignment in one go
/// </summary>
/// <param name="msg"></param>
/// <param name="value"></param>
/// <returns></returns>
private NumericMessage SetValue(NumericMessage msg, decimal value)
{
msg.Number = value;
return(msg);
}
public async override Task <Message> HandleMessage(Message msg)
{
MessageContext context = new MessageContext(msg, this);
decimal num = 0m;
NumericMessage nMsg = msg as NumericMessage;
if (nMsg != null && From.Value is numberSelector)
{
// Skip overhead of evaluating DataSelector expression if the default was used
num = nMsg.Number;
}
else
{
var selected = await From.TrySelectDecimalAsync(context);
if (selected.Parsed)
{
num = selected.Value;
}
// Can't quantize a non-numeric value, so we shouldn't let this message through
return(null);
}
int position = Array.BinarySearch(Points, num);
if (position >= 0 && Ordinal.Value is falseSelector)
{
// Message's value was already on the scale
return(msg);
}
// At this point we know we're going to be returning a new message with something
var newMsg = new NumericMessage
{
DerivedFrom = msg
};
int absPosition = Math.Abs(position);
if (absPosition >= Points.Length)
{
// Value was off the scale! Aaiiiieee! Return the highest point on the scale
return(SetValue(newMsg, await DesiredValue(context, Points.Length - 1)));
}
if (absPosition == 0)
{
// Below the bottom of the scale. Return the lowest point
return(SetValue(newMsg, await DesiredValue(context, 0)));
}
decimal before = Points[absPosition - 1];
decimal after = Points[absPosition];
// Which side is it closer to?
if (num - before > after - num)
{
return(SetValue(newMsg, await DesiredValue(context, absPosition)));
}
else
{
return(SetValue(newMsg, await DesiredValue(context, absPosition - 1)));
}
}