private void OnServerError(ServerErrorMessage serverErrorMessage)
{
if (serverErrorMessage.Error.Contains("Requires a user session"))
{
File.Delete(App.CurrentPlayerFilename);
this.authenticated = null; // causes re-login
}
Console.WriteLine($"{DateTime.Now}: server error '{serverErrorMessage.Error}'!");
}
public void OnStateFluxServerError(ServerErrorMessage message)
{
DebugLog($"OnStateFluxServerError - {message.Error}!");
StartCoroutine(nameof(ActivateLoginPanel));
if (!message.Error.Contains("requires a user session"))
{
_errorPanel.SendMessage("OnStateFluxError", message.Error);
}
}
public void OnServerError(ServerErrorMessage message)
{
if (IsServer)
{
return;
}
if (!message.shouldDisconnect)
{
return;
}
Stop();
}
/// <summary>
/// Called when the server receives an error message
/// </summary>
/// <param name="console">The server GUI - provides access to the underlying server process</param>
/// <param name="message">The error message</param>
public void OnErrorMessage(IServerConsole console, ServerErrorMessage message)
{
foreach (IPlugin plugin in Enabled)
{
try
{
plugin.OnErrorMessage(console, message);
}
catch (Exception ex)
{
console.DisplayLine($"Error in method OnErrorMessage for plugin {plugin.Name}: {ex}", red);
}
}
}
public void SendServerError(int connectionId, short errorCode, string errorMessage)
{
if (!IsServer)
{
return;
}
//if (!Transport.Sessions.TryGetValue(connectionId, out NetworkSession player) || !player.IsReady)
// return;
ServerErrorMessage message = new ServerErrorMessage();
message.errorCode = errorCode;
message.errorMessage = errorMessage;
Transport.ServerSendPacket(connectionId, MessageId.ServerError, message, DeliveryMethod.ReliableOrdered);
}
private void OnServerError(ServerErrorMessage serverErrorMessage)
{
lock (this)
{
if (serverErrorMessage.Error.Contains("Requires a user session"))
{
ResetSavedSession();
}
if (_webSocket != null)
{
_webSocket.Close();
}
}
Log($"{DateTime.Now}: server error '{serverErrorMessage.Error}'!");
}
private void ProcessMessagesHandler(object source, MessageEventArgs e)
{
string msgTxt = e.Data.ToString();
Message responseMessage = JsonConvert.DeserializeObject <Message>(msgTxt);
Message mappedMessage = null;
if (responseMessage.MessageType == MessageTypeNames.ChatSaid)
{
mappedMessage = JsonConvert.DeserializeObject <ChatSaidMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.PlayerListing)
{
mappedMessage = JsonConvert.DeserializeObject <PlayerListingMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.GameInstanceCreated)
{
mappedMessage = JsonConvert.DeserializeObject <GameInstanceCreatedMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.JoinedGameInstance)
{
mappedMessage = JsonConvert.DeserializeObject <JoinedGameInstanceMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.GameInstanceListing)
{
mappedMessage = JsonConvert.DeserializeObject <GameInstanceListingMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.RequestFullState)
{
mappedMessage = JsonConvert.DeserializeObject <RequestFullStateMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.StateChanged)
{
mappedMessage = JsonConvert.DeserializeObject <StateChangedMessage>(msgTxt);
}
else if (responseMessage.MessageType == MessageTypeNames.ServerError)
{
ServerErrorMessage error = JsonConvert.DeserializeObject <ServerErrorMessage>(msgTxt);
OnServerError(error);
mappedMessage = error;
}
if (mappedMessage != null)
{
_responses.Enqueue(mappedMessage);
}
}
protected override void OnMessage(MessageEventArgs e)
{
try
{
Message message = DeserializeMessage(e.Data);
MessageHandlerBinding binding = _handlerMap[message.GetType()];
MessageHandler handler = binding.objectTarget;
MethodInfo method = binding.methodTarget;
Player player = this.GetCurrentSessionPlayer();
string pname = (player != null) ? player.Name : "unknown";
bool verbose = (message.MessageType != MessageTypeNames.HostStateChange &&
message.MessageType != MessageTypeNames.GuestInputChange &&
message.MessageType != MessageTypeNames.GuestCommandChange &&
message.MessageType != MessageTypeNames.HostCommandChange &&
message.MessageType != MessageTypeNames.MiceChange);
if (verbose)
{
LogMessage($"OnMessage {message.MessageType} from {pname}");
}
Message responseMessage = (Message)method.Invoke(handler, new object[] { message });
if (responseMessage != null)
{
Respond(responseMessage);
}
//if(verbose)
//{
// LogMessage($"OnMessage {message.MessageType} from {pname}");
//}
}
catch (Exception exception)
{
string msg = (exception.InnerException == null) ? exception.Message : exception.InnerException.Message;
LogMessage($"{msg}");
ServerErrorMessage error = new ServerErrorMessage()
{
Error = msg
};
Send(JsonConvert.SerializeObject(error));
}
}
public void OnErrorMessage(IServerConsole console, ServerErrorMessage message)
{
}
public void EnqueueMessageError(ServerErrorMessage message)
{
EnqueueMessage(400, "Bad Request", message);
}
public void OnClientTurnReceived(int subTick, int checksum, LogicArrayList <LogicCommand> commands)
{
if (this.m_destructed || this.m_logicGameMode.GetState() == 4 || this.m_logicGameMode.GetState() == 5)
{
return;
}
int currentTimestamp = TimeUtil.GetTimestamp();
int logicTimestamp = this.m_logicGameMode.GetStartTime() + LogicTime.GetTicksInSeconds(subTick);
if (currentTimestamp + 1 >= logicTimestamp)
{
if (commands != null)
{
this.m_serverCommandStorage.CheckExecutableServerCommands(subTick, commands);
for (int i = 0; i < commands.Size(); i++)
{
this.m_logicGameMode.GetCommandManager().AddCommand(commands[i]);
}
}
int previousSubTick = this.m_logicGameMode.GetLevel().GetLogicTime().GetTick();
try
{
this.m_logicWatch.Start();
for (int i = 0, count = subTick - previousSubTick; i < count; i++)
{
this.m_logicGameMode.UpdateOneSubTick();
if (this.m_logicWatch.ElapsedMilliseconds >= GameMode.MAX_LOGIC_LOOP_TIME)
{
Logging.Error(string.Format("GameMode.onClientTurnReceived: logic update stopped because it took too long. ({0}ms for {1} updates)",
this.m_logicWatch.ElapsedMilliseconds, i));
break;
}
}
GameModeClusterManager.ReportLogicUpdateSpeed(this.m_logicWatch.ElapsedMilliseconds);
this.m_logicWatch.Reset();
}
catch (LogicException exception)
{
Logging.Error("GameMode.onClientTurnReceived: logic exception thrown: " + exception + " (acc id: " + (long)this.m_session.AccountId + ")");
ServerErrorMessage serverErrorMessage = new ServerErrorMessage();
serverErrorMessage.SetErrorMessage(exception.Message);
this.m_session.SendPiranhaMessage(serverErrorMessage, 1);
this.m_session.SendMessage(new StopSessionMessage(), 1);
}
catch (Exception exception)
{
Logging.Error("GameMode.onClientTurnReceived: exception thrown: " + exception + " (acc id: " + (long)this.m_session.AccountId + ")");
this.m_session.SendMessage(new StopSessionMessage(), 1);
}
this.CheckChecksum(checksum);
if (this.m_avatarChangeListener != null)
{
this.SaveState();
}
if (this.m_liveReplayId != null)
{
this.UpdateLiveReplay(subTick, commands);
}
if (this.m_logicGameMode.IsBattleOver())
{
this.m_shouldDestruct = true;
}
if (this.m_shouldDestruct)
{
this.m_session.DestructGameMode();
}
}
else
{
this.m_session.SendMessage(new StopSessionMessage(), 1);
}
}
private void HandleReply(object sender, IReply e)
{
if (e.GetType() == typeof(ServerReplyMessage))
{
ServerReplyMessage msg = (ServerReplyMessage)e;
switch (msg.ReplyCode)
{
// If we get a WHO response, we parse and add the nicks to the specified channel if they are not there already.
case IRCReplyCode.RPL_WHOREPLY:
ChannelRWLock.EnterWriteLock();
string[] msgSplit = msg.Message.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (msgSplit.GetUpperBound(0) > 0)
{
string target = msgSplit[0];
if (target.StartsWith("&") || target.StartsWith("#"))
{
if (msgSplit.GetUpperBound(0) >= 7)
{
string nickname = msgSplit[4];
string realname = msgSplit[7];
string username = msgSplit[1];
string host = msgSplit[2];
string modeString = msgSplit[5];
Channel channel = Channels.Find(chan => chan.Name == target);
if (channel != null)
{
Nick nick = channel.GetNick(nickname);
bool nickFound = true;
if (nick == null)
{
nickFound = false;
nick = new Nick();
}
nick.Nickname = nickname;
nick.Host = host;
nick.Realname = realname;
nick.Username = username;
nick.Modes = new List <UserMode>();
nick.Privileges = new List <PrivilegeMode>();
char[] modeArr = modeString.ToCharArray();
for (int i = 1; i <= modeArr.GetUpperBound(0); i++)
{
if (PrivilegeMapping.ContainsKey(modeArr[i].ToString()))
{
nick.Privileges.Add(PrivilegeMapping[modeArr[i].ToString()]);
}
else if (modeArr[i].ToString() == "*")
{
nick.Modes.Add(UserMode.o);
}
else
{
UserMode foundMode;
bool valid = Enum.TryParse(modeArr[i].ToString(), false, out foundMode);
if (valid)
{
nick.Modes.Add(foundMode);
}
}
}
if (!nickFound)
{
channel.AddNick(nick);
}
}
}
}
}
ChannelRWLock.ExitWriteLock();
break;
// On a topic reply, update the channel's topic
case IRCReplyCode.RPL_TOPIC:
ChannelRWLock.EnterWriteLock();
string[] topicSplit = msg.Message.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (topicSplit.GetUpperBound(0) > 0)
{
string topicChan = topicSplit[0];
Channel topicChannel = Channels.Find(chan => chan.Name == topicChan);
if (topicChannel != null)
{
topicChannel.Topic = topicSplit[1].Remove(0, 1);
}
}
ChannelRWLock.ExitWriteLock();
break;
default:
break;
}
}
else
{
ServerErrorMessage msg = (ServerErrorMessage)e;
}
}
/// <summary>
/// Creates a message by type.
/// </summary>
public override PiranhaMessage CreateMessageByType(int type)
{
PiranhaMessage message = null;
if (type < 20000)
{
switch (type)
{
case 10100:
{
message = new ClientHelloMessage();
break;
}
case 10101:
{
message = new LoginMessage();
break;
}
case 10108:
{
message = new KeepAliveMessage();
break;
}
case 10113:
{
message = new SetDeviceTokenMessage();
break;
}
case 10116:
{
message = new ResetAccountMessage();
break;
}
case 10117:
{
message = new ReportUserMessage();
break;
}
case 10118:
{
message = new AccountSwitchedMessage();
break;
}
case 10150:
{
message = new AppleBillingRequestMessage();
break;
}
case 10212:
{
message = new ChangeAvatarNameMessage();
break;
}
case 14101:
{
message = new GoHomeMessage();
break;
}
case 14102:
{
message = new EndClientTurnMessage();
break;
}
case 14134:
{
message = new AttackNpcMessage();
break;
}
case 14262:
{
message = new BindGoogleServiceAccountMessage();
break;
}
case 14325:
{
message = new AskForAvatarProfileMessage();
break;
}
case 14715:
{
message = new SendGlobalChatLineMessage();
break;
}
}
}
else
{
switch (type)
{
case 20000:
{
message = new ExtendedSetEncryptionMessage();
break;
}
case 20100:
{
message = new ServerHelloMessage();
break;
}
case 20103:
{
message = new LoginFailedMessage();
break;
}
case 20104:
{
message = new LoginOkMessage();
break;
}
case 20108:
{
message = new KeepAliveServerMessage();
break;
}
case 20117:
{
message = new ReportUserStatusMessage();
break;
}
case 20151:
{
message = new AppleBillingProcessedByServerMessage();
break;
}
case 20161:
{
message = new ShutdownStartedMessage();
break;
}
case 20171:
{
message = new PersonalBreakStartedMessage();
break;
}
case 20261:
{
message = new GoogleServiceAccountBoundMessage();
break;
}
case 20262:
{
message = new GoogleServiceAccountAlreadyBoundMessage();
break;
}
case 24101:
{
message = new OwnHomeDataMessage();
break;
}
case 24104:
{
message = new OutOfSyncMessage();
break;
}
case 24111:
{
message = new AvailableServerCommand();
break;
}
case 24112:
{
message = new WaitingToGoHomeMessage();
break;
}
case 24115:
{
message = new ServerErrorMessage();
break;
}
case 24133:
{
message = new NpcDataMessage();
break;
}
case 24334:
{
message = new AvatarProfileMessage();
break;
}
case 24411:
{
message = new AvatarStreamMessage();
break;
}
case 24715:
{
message = new GlobalChatLineMessage();
break;
}
}
}
return(message);
}
IEnumerator ReceiveAndDispatchMessages()
{
while (!connection.SocketOpenWithIdentity)
{
foreach (var listener in listeners)
{
listener.OnStateFluxWaitingToConnect();
}
yield return(new WaitForSeconds(1));
}
while (true)
{
openWithIdentity = connection.SocketOpenWithIdentity;
if (!connected && openWithIdentity)
{
connected = true;
userName = connection.UserName;
foreach (var listener in listeners)
{
listener.OnStateFluxConnect();
}
}
else if (connected && !openWithIdentity)
{
connected = false;
userName = "";
foreach (var listener in listeners)
{
listener.OnStateFluxDisconnect();
}
}
bool draining = true;
int drainingCount = 50;
while (draining && (drainingCount--) > 0)
{
StateFlux.Model.Message message = connection.ReceiveResponse();
draining = (message != null);
if (draining)
{
if (message.MessageType == MessageTypeNames.HostStateChanged)
{
// FIXME: convert all the others to linq method ForEach
listeners.ForEach(l => l.OnStateFluxHostStateChanged((HostStateChangedMessage)message));
}
else if (message.MessageType == MessageTypeNames.MiceChanged)
{
MiceChangedMessage msg = (MiceChangedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxMiceChanged(msg);
}
}
else if (message.MessageType == MessageTypeNames.HostCommandChanged)
{
HostCommandChangedMessage msg = (HostCommandChangedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxHostCommandChanged(msg);
}
}
else if (message.MessageType == MessageTypeNames.GuestCommandChanged)
{
GuestCommandChangedMessage msg = (GuestCommandChangedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxGuestCommandChanged(msg);
}
}
else if (message.MessageType == MessageTypeNames.GuestInputChanged)
{
GuestInputChangedMessage msg = (GuestInputChangedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxGuestInputChanged(msg);
}
}
else if (message.MessageType == MessageTypeNames.PlayerListing)
{
PlayerListingMessage msg = (PlayerListingMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxPlayerListing(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceCreated)
{
GameInstanceCreatedMessage msg = (GameInstanceCreatedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceCreated(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceListing)
{
GameInstanceListingMessage msg = (GameInstanceListingMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceListing(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceJoined)
{
GameInstanceJoinedMessage msg = (GameInstanceJoinedMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceJoined(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceStart)
{
GameInstanceStartMessage msg = (GameInstanceStartMessage)message;
Debug.Log($"Game start message, host is {msg.Host.Name}");
Debug.Log($"Current player name is {connection.CurrentPlayer.Name}");
isHosting = (msg.Host.Name == connection.CurrentPlayer.Name);
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceStart(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceStopped)
{
GameInstanceStoppedMessage msg = (GameInstanceStoppedMessage)message;
Debug.Log($"Game stopped message, host is {msg.Host.Name}");
Debug.Log($"Current player name is {connection.CurrentPlayer.Name}");
isHosting = (msg.Host.Name == connection.CurrentPlayer.Name);
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceStopped(msg);
}
}
else if (message.MessageType == MessageTypeNames.GameInstanceLeft)
{
GameInstanceLeftMessage msg = (GameInstanceLeftMessage)message;
Debug.Log($"Player {msg.Player.Name} left {msg.GameName}:{msg.InstanceName}");
Debug.Log($"Current player name is {connection.CurrentPlayer.Name}");
foreach (var listener in listeners)
{
listener.OnStateFluxGameInstanceLeft(msg);
}
}
else if (message.MessageType == MessageTypeNames.ChatSaid)
{
ChatSaidMessage msg = (ChatSaidMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxChatSaid(msg);
}
}
else if (message.MessageType == MessageTypeNames.ServerError)
{
ServerErrorMessage msg = (ServerErrorMessage)message;
foreach (var listener in listeners)
{
listener.OnStateFluxServerError(msg);
}
}
else
{
foreach (var listener in listeners)
{
listener.OnStateFluxOtherMessage(message);
}
}
}
}
yield return(null);
}
}
public void OnStateFluxServerError(ServerErrorMessage message)
{
}
public override PiranhaMessage CreateMessageByType(int type)
{
PiranhaMessage message = null;
if (type < 20000)
{
switch (type)
{
case ClientCryptoErrorMessage.MESSAGE_TYPE:
{
message = new ClientCryptoErrorMessage();
break;
}
case ClientHelloMessage.MESSAGE_TYPE:
{
message = new ClientHelloMessage();
break;
}
case LoginMessage.MESSAGE_TYPE:
{
message = new LoginMessage();
break;
}
case KeepAliveMessage.MESSAGE_TYPE:
{
message = new KeepAliveMessage();
break;
}
case SetDeviceTokenMessage.MESSAGE_TYPE:
{
message = new SetDeviceTokenMessage();
break;
}
case ResetAccountMessage.MESSAGE_TYPE:
{
message = new ResetAccountMessage();
break;
}
case ReportUserMessage.MESSAGE_TYPE:
{
message = new ReportUserMessage();
break;
}
case AccountSwitchedMessage.MESSAGE_TYPE:
{
message = new AccountSwitchedMessage();
break;
}
case UnlockAccountMessage.MESSAGE_TYPE:
{
message = new UnlockAccountMessage();
break;
}
case AppleBillingRequestMessage.MESSAGE_TYPE:
{
message = new AppleBillingRequestMessage();
break;
}
case ChangeAvatarNameMessage.MESSAGE_TYPE:
{
message = new ChangeAvatarNameMessage();
break;
}
case AcceptFriendMessage.MESSAGE_TYPE:
{
message = new AcceptFriendMessage();
break;
}
case AddFriendMessage.MESSAGE_TYPE:
{
message = new AddFriendMessage();
break;
}
case AskForFriendListMessage.MESSAGE_TYPE:
{
message = new AskForFriendListMessage();
break;
}
case RemoveFriendMessage.MESSAGE_TYPE:
{
message = new RemoveFriendMessage();
break;
}
case StartFriendLiveSpectateMessage.MESSAGE_TYPE:
{
message = new StartFriendLiveSpectateMessage();
break;
}
case InboxOpenedMessage.MESSAGE_TYPE:
{
message = new InboxOpenedMessage();
break;
}
case GoHomeMessage.MESSAGE_TYPE:
{
message = new GoHomeMessage();
break;
}
case EndClientTurnMessage.MESSAGE_TYPE:
{
message = new EndClientTurnMessage();
break;
}
case CancelMatchmakingMessage.MESSAGE_TYPE:
{
message = new CancelMatchmakingMessage();
break;
}
case AttackHomeMessage.MESSAGE_TYPE:
{
message = new AttackHomeMessage();
break;
}
case StartFriendlyChallengeSpectateMessage.MESSAGE_TYPE:
{
message = new StartFriendlyChallengeSpectateMessage();
break;
}
case ScoutFriendlyBattleMessage.MESSAGE_TYPE:
{
message = new ScoutFriendlyBattleMessage();
break;
}
case VisitHomeMessage.MESSAGE_TYPE:
{
message = new VisitHomeMessage();
break;
}
case HomeBattleReplayMessage.MESSAGE_TYPE:
{
message = new HomeBattleReplayMessage();
break;
}
case AttackMatchedHomeMessage.MESSAGE_TYPE:
{
message = new AttackMatchedHomeMessage();
break;
}
case AcceptFriendlyBattleMessage.MESSAGE_TYPE:
{
message = new AcceptFriendlyBattleMessage();
break;
}
case CancelChallengeMessage.MESSAGE_TYPE:
{
message = new CancelChallengeMessage();
break;
}
case AttackNpcMessage.MESSAGE_TYPE:
{
message = new AttackNpcMessage();
break;
}
case DuelNpcMessage.MESSAGE_TYPE:
{
message = new DuelNpcMessage();
break;
}
case BindGoogleServiceAccountMessage.MESSAGE_TYPE:
{
message = new BindGoogleServiceAccountMessage();
break;
}
case BindFacebookAccountMessage.MESSAGE_TYPE:
{
message = new BindFacebookAccountMessage();
break;
}
case CreateAllianceMessage.MESSAGE_TYPE:
{
message = new CreateAllianceMessage();
break;
}
case AskForAllianceDataMessage.MESSAGE_TYPE:
{
message = new AskForAllianceDataMessage();
break;
}
case AskForJoinableAlliancesListMessage.MESSAGE_TYPE:
{
message = new AskForJoinableAlliancesListMessage();
break;
}
case JoinAllianceMessage.MESSAGE_TYPE:
{
message = new JoinAllianceMessage();
break;
}
case ChangeAllianceMemberRoleMessage.MESSAGE_TYPE:
{
message = new ChangeAllianceMemberRoleMessage();
break;
}
case LeaveAllianceMessage.MESSAGE_TYPE:
{
message = new LeaveAllianceMessage();
break;
}
case DonateAllianceUnitMessage.MESSAGE_TYPE:
{
message = new DonateAllianceUnitMessage();
break;
}
case ChatToAllianceStreamMessage.MESSAGE_TYPE:
{
message = new ChatToAllianceStreamMessage();
break;
}
case ChangeAllianceSettingsMessage.MESSAGE_TYPE:
{
message = new ChangeAllianceSettingsMessage();
break;
}
case RequestJoinAllianceMessage.MESSAGE_TYPE:
{
message = new RequestJoinAllianceMessage();
break;
}
case RespondToAllianceJoinRequestMessage.MESSAGE_TYPE:
{
message = new RespondToAllianceJoinRequestMessage();
break;
}
case SendAllianceInvitationMessage.MESSAGE_TYPE:
{
message = new SendAllianceInvitationMessage();
break;
}
case JoinAllianceUsingInvitationMessage.MESSAGE_TYPE:
{
message = new JoinAllianceUsingInvitationMessage();
break;
}
case SearchAlliancesMessage.MESSAGE_TYPE:
{
message = new SearchAlliancesMessage();
break;
}
case AskForAvatarProfileMessage.MESSAGE_TYPE:
{
message = new AskForAvatarProfileMessage();
break;
}
case AskForAllianceBookmarksFullDataMessage.MESSAGE_TYPE:
{
message = new AskForAllianceBookmarksFullDataMessage();
break;
}
case AddAllianceBookmarkMessage.MESSAGE_TYPE:
{
message = new AddAllianceBookmarkMessage();
break;
}
case RemoveAllianceBookmarkMessage.MESSAGE_TYPE:
{
message = new RemoveAllianceBookmarkMessage();
break;
}
case AskForAllianceRankingListMessage.MESSAGE_TYPE:
{
message = new AskForAllianceRankingListMessage();
break;
}
case AskForAvatarRankingListMessage.MESSAGE_TYPE:
{
message = new AskForAvatarRankingListMessage();
break;
}
case AskForAvatarLocalRankingListMessage.MESSAGE_TYPE:
{
message = new AskForAvatarLocalRankingListMessage();
break;
}
case AskForAvatarLastSeasonRankingListMessage.MESSAGE_TYPE:
{
message = new AskForAvatarLastSeasonRankingListMessage();
break;
}
case AskForAvatarDuelLastSeasonRankingListMessage.MESSAGE_TYPE:
{
message = new AskForAvatarDuelLastSeasonRankingListMessage();
break;
}
case RemoveAvatarStreamEntryMessage.MESSAGE_TYPE:
{
message = new RemoveAvatarStreamEntryMessage();
break;
}
case AskForLeagueMemberListMessage.MESSAGE_TYPE:
{
message = new AskForLeagueMemberListMessage();
break;
}
case BattleEndClientTurnMessage.MESSAGE_TYPE:
{
message = new BattleEndClientTurnMessage();
break;
}
case AvatarNameCheckRequestMessage.MESSAGE_TYPE:
{
message = new AvatarNameCheckRequestMessage();
break;
}
case SendGlobalChatLineMessage.MESSAGE_TYPE:
{
message = new SendGlobalChatLineMessage();
break;
}
case Village2AttackStartSpectateMessage.MESSAGE_TYPE:
{
message = new Village2AttackStartSpectateMessage();
break;
}
}
}
else
{
switch (type)
{
case SetEncryptionMessage.MESSAGE_TYPE:
{
message = new ExtendedSetEncryptionMessage();
break;
}
case ServerHelloMessage.MESSAGE_TYPE:
{
message = new ServerHelloMessage();
break;
}
case LoginFailedMessage.MESSAGE_TYPE:
{
message = new LoginFailedMessage();
break;
}
case LoginOkMessage.MESSAGE_TYPE:
{
message = new LoginOkMessage();
break;
}
case FriendListMessage.MESSAGE_TYPE:
{
message = new FriendListMessage();
break;
}
case FriendListUpdateMessage.MESSAGE_TYPE:
{
message = new FriendListUpdateMessage();
break;
}
case KeepAliveServerMessage.MESSAGE_TYPE:
{
message = new KeepAliveServerMessage();
break;
}
case AddFriendErrorMessage.MESSAGE_TYPE:
{
message = new AddFriendErrorMessage();
break;
}
case ReportUserStatusMessage.MESSAGE_TYPE:
{
message = new ReportUserStatusMessage();
break;
}
case UnlockAccountOkMessage.MESSAGE_TYPE:
{
message = new UnlockAccountOkMessage();
break;
}
case UnlockAccountFailedMessage.MESSAGE_TYPE:
{
message = new UnlockAccountFailedMessage();
break;
}
case AppleBillingProcessedByServerMessage.MESSAGE_TYPE:
{
message = new AppleBillingProcessedByServerMessage();
break;
}
case ShutdownStartedMessage.MESSAGE_TYPE:
{
message = new ShutdownStartedMessage();
break;
}
case PersonalBreakStartedMessage.MESSAGE_TYPE:
{
message = new PersonalBreakStartedMessage();
break;
}
case FacebookAccountBoundMessage.MESSAGE_TYPE:
{
message = new FacebookAccountBoundMessage();
break;
}
case AvatarNameChangeFailedMessage.MESSAGE_TYPE:
{
message = new AvatarNameChangeFailedMessage();
break;
}
case AvatarOnlineStatusUpdated.MESSAGE_TYPE:
{
message = new AvatarOnlineStatusUpdated();
break;
}
case AvatarOnlineStatusListMessage.MESSAGE_TYPE:
{
message = new AvatarOnlineStatusListMessage();
break;
}
case AllianceOnlineStatusUpdatedMessage.MESSAGE_TYPE:
{
message = new AllianceOnlineStatusUpdatedMessage();
break;
}
case GoogleServiceAccountBoundMessage.MESSAGE_TYPE:
{
message = new GoogleServiceAccountBoundMessage();
break;
}
case GoogleServiceAccountAlreadyBoundMessage.MESSAGE_TYPE:
{
message = new GoogleServiceAccountAlreadyBoundMessage();
break;
}
case AvatarNameCheckResponseMessage.MESSAGE_TYPE:
{
message = new AvatarNameCheckResponseMessage();
break;
}
case AcceptFriendErrorMessage.MESSAGE_TYPE:
{
message = new AcceptFriendErrorMessage();
break;
}
case OwnHomeDataMessage.MESSAGE_TYPE:
{
message = new OwnHomeDataMessage();
break;
}
case AttackHomeFailedMessage.MESSAGE_TYPE:
{
message = new AttackHomeFailedMessage();
break;
}
case OutOfSyncMessage.MESSAGE_TYPE:
{
message = new OutOfSyncMessage();
break;
}
case EnemyHomeDataMessage.MESSAGE_TYPE:
{
message = new EnemyHomeDataMessage();
break;
}
case AvailableServerCommandMessage.MESSAGE_TYPE:
{
message = new AvailableServerCommandMessage();
break;
}
case WaitingToGoHomeMessage.MESSAGE_TYPE:
{
message = new WaitingToGoHomeMessage();
break;
}
case VisitedHomeDataMessage.MESSAGE_TYPE:
{
message = new VisitedHomeDataMessage();
break;
}
case HomeBattleReplayDataMessage.MESSAGE_TYPE:
{
message = new HomeBattleReplayDataMessage();
break;
}
case ServerErrorMessage.MESSAGE_TYPE:
{
message = new ServerErrorMessage();
break;
}
case HomeBattleReplayFailedMessage.MESSAGE_TYPE:
{
message = new HomeBattleReplayFailedMessage();
break;
}
case LiveReplayHeaderMessage.MESSAGE_TYPE:
{
message = new LiveReplayHeaderMessage();
break;
}
case LiveReplayDataMessage.MESSAGE_TYPE:
{
message = new LiveReplayDataMessage();
break;
}
case ChallengeFailedMessage.MESSAGE_TYPE:
{
message = new ChallengeFailedMessage();
break;
}
case VisitFailedMessage.MESSAGE_TYPE:
{
message = new VisitFailedMessage();
break;
}
case AttackSpectatorCountMessage.MESSAGE_TYPE:
{
message = new AttackSpectatorCountMessage();
break;
}
case LiveReplayEndMessage.MESSAGE_TYPE:
{
message = new LiveReplayEndMessage();
break;
}
case LiveReplayFailedMessage.MESSAGE_TYPE:
{
message = new LiveReplayFailedMessage();
break;
}
case NpcDataMessage.MESSAGE_TYPE:
{
message = new NpcDataMessage();
break;
}
case AllianceDataMessage.MESSAGE_TYPE:
{
message = new AllianceDataMessage();
break;
}
case AllianceJoinFailedMessage.MESSAGE_TYPE:
{
message = new AllianceJoinFailedMessage();
break;
}
case JoinableAllianceListMessage.MESSAGE_TYPE:
{
message = new JoinableAllianceListMessage();
break;
}
case AllianceListMessage.MESSAGE_TYPE:
{
message = new AllianceListMessage();
break;
}
case AllianceStreamMessage.MESSAGE_TYPE:
{
message = new AllianceStreamMessage();
break;
}
case AllianceStreamEntryMessage.MESSAGE_TYPE:
{
message = new AllianceStreamEntryMessage();
break;
}
case AllianceStreamEntryRemovedMessage.MESSAGE_TYPE:
{
message = new AllianceStreamEntryRemovedMessage();
break;
}
case AllianceJoinRequestOkMessage.MESSAGE_TYPE:
{
message = new AllianceJoinRequestOkMessage();
break;
}
case AllianceJoinRequestFailedMessage.MESSAGE_TYPE:
{
message = new AllianceJoinRequestFailedMessage();
break;
}
case AllianceInvitationSendFailedMessage.MESSAGE_TYPE:
{
message = new AllianceInvitationSendFailedMessage();
break;
}
case AllianceInvitationSentOkMessage.MESSAGE_TYPE:
{
message = new AllianceInvitationSentOkMessage();
break;
}
case AllianceFullEntryUpdateMessage.MESSAGE_TYPE:
{
message = new AllianceFullEntryUpdateMessage();
break;
}
case AllianceWarSearchDataMessage.MESSAGE_TYPE:
{
message = new AllianceWarSearchDataMessage();
break;
}
case AllianceWarDataMessage.MESSAGE_TYPE:
{
message = new AllianceWarDataMessage();
break;
}
case AllianceCreateFailedMessage.MESSAGE_TYPE:
{
message = new AllianceCreateFailedMessage();
break;
}
case AvatarProfileMessage.MESSAGE_TYPE:
{
message = new AvatarProfileMessage();
break;
}
case AllianceWarFullEntryMessage.MESSAGE_TYPE:
{
message = new AllianceWarFullEntryMessage();
break;
}
case AllianceWarDataFailedMessage.MESSAGE_TYPE:
{
message = new AllianceWarDataFailedMessage();
break;
}
case AllianceWarHistoryMessage.MESSAGE_TYPE:
{
message = new AllianceWarHistoryMessage();
break;
}
case AvatarProfileFailedMessage.MESSAGE_TYPE:
{
message = new AvatarProfileFailedMessage();
break;
}
case BookmarksListMessage.MESSAGE_TYPE:
{
message = new BookmarksListMessage();
break;
}
case AllianceBookmarksFullDataMessage.MESSAGE_TYPE:
{
message = new AllianceBookmarksFullDataMessage();
break;
}
case Village2AttackEntryListMessage.MESSAGE_TYPE:
{
message = new Village2AttackEntryListMessage();
break;
}
case Village2AttackEntryUpdateMessage.MESSAGE_TYPE:
{
message = new Village2AttackEntryUpdateMessage();
break;
}
case Village2AttackEntryAddedMessage.MESSAGE_TYPE:
{
message = new Village2AttackEntryAddedMessage();
break;
}
case Village2AttackEntryRemovedMessage.MESSAGE_TYPE:
{
message = new Village2AttackEntryRemovedMessage();
break;
}
case AllianceRankingListMessage.MESSAGE_TYPE:
{
message = new AllianceRankingListMessage();
break;
}
case AllianceLocalRankingListMessage.MESSAGE_TYPE:
{
message = new AllianceLocalRankingListMessage();
break;
}
case AvatarRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarRankingListMessage();
break;
}
case AvatarLocalRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarLocalRankingListMessage();
break;
}
case AvatarLastSeasonRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarLastSeasonRankingListMessage();
break;
}
case AvatarDuelLocalRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarDuelLocalRankingListMessage();
break;
}
case AvatarDuelLastSeasonRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarDuelLastSeasonRankingListMessage();
break;
}
case AvatarDuelRankingListMessage.MESSAGE_TYPE:
{
message = new AvatarDuelRankingListMessage();
break;
}
case AvatarStreamMessage.MESSAGE_TYPE:
{
message = new AvatarStreamMessage();
break;
}
case AvatarStreamEntryMessage.MESSAGE_TYPE:
{
message = new AvatarStreamEntryMessage();
break;
}
case AvatarStreamEntryRemovedMessage.MESSAGE_TYPE:
{
message = new AvatarStreamEntryRemovedMessage();
break;
}
case LeagueMemberListMessage.MESSAGE_TYPE:
{
message = new LeagueMemberListMessage();
break;
}
case GlobalChatLineMessage.MESSAGE_TYPE:
{
message = new GlobalChatLineMessage();
break;
}
case AllianceWarEventMessage.MESSAGE_TYPE:
{
message = new AllianceWarEventMessage();
break;
}
case FriendlyScoutHomeDataMessage.MESSAGE_TYPE:
{
message = new FriendlyScoutHomeDataMessage();
break;
}
case Village2AttackAvatarDataMessage.MESSAGE_TYPE:
{
message = new Village2AttackAvatarDataMessage();
break;
}
case AttackEventMessage.MESSAGE_TYPE:
{
message = new AttackEventMessage();
break;
}
case TitanDisconnectedMessage.MESSAGE_TYPE:
{
message = new DisconnectedMessage();
break;
}
case CryptoErrorMessage.MESSAGE_TYPE:
{
message = new CryptoErrorMessage();
break;
}
}
}
return(message);
}
private async Task SendErrorToCaller(ServiceError error)
{
var errResponse = ServerErrorMessage.FromServiceError(error);
await Clients.Caller.SendAsync(DISPATCH_MESSAGE, errResponse).ConfigureAwait(false);
}
