protected virtual IEnumerable<Message> CreateResponseMessages(MessageType messageType, string fieldName = "", params string[] messages)
        {
            var messageList = new List<Message>();
            messages.ForEach(m => messageList.Add(new Message(m, fieldName, messageType)));

            return messageList;
        }

 public void Add( string text, MessageType type )
 {
     if( type == MessageType.Normal ) {
         Log.Add( text );
         LogChatToFile( text );
     } else if( type == MessageType.Status1 ) {
         Status1 = text;
     } else if( type == MessageType.Status2 ) {
         Status2 = text;
     } else if( type == MessageType.Status3 ) {
         Status3 = text;
     } else if( type == MessageType.BottomRight1 ) {
         BottomRight1 = text;
     } else if( type == MessageType.BottomRight2 ) {
         BottomRight2 = text;
     } else if( type == MessageType.BottomRight3 ) {
         BottomRight3 = text;
     } else if( type == MessageType.Announcement ) {
         Announcement = text;
     } else if( type >= MessageType.ClientStatus1 && type <= MessageType.ClientStatus6 ) {
         ClientStatus[(int)(type - MessageType.ClientStatus1)] = text;
     } else if( type == MessageType.ClientClock ) {
         ClientClock = text;
     }
     game.Events.RaiseChatReceived( text, type );
 }

 public static ResponseType show(Window parent_window, DialogFlags dialogFlags, MessageType messageType, ButtonsType buttonsType,string  message)
 {
     _dlg = new MessageDialog (parent_window, dialogFlags,messageType, buttonsType, message);
     ResponseType response = (ResponseType) _dlg.Run ();
     _dlg.Destroy ();
     return response;
 }

        public void Init()
        {
            using (var transaction = new TransactionScope(TransactionScopeOption.Suppress))
            using (var session = subscriptionStorageSessionProvider.OpenStatelessSession())
            using (var tx = session.BeginTransaction(System.Data.IsolationLevel.ReadCommitted))
            {
                var v2XSubscriptions = session.QueryOver<Subscription>()
                    .Where(s => s.TypeName == null)
                    .List();
                if (v2XSubscriptions.Count == 0)
                    return;

                Logger.DebugFormat("Found {0} v2X subscriptions going to upgrade", v2XSubscriptions.Count);

                foreach (var v2XSubscription in v2XSubscriptions)
                {
                    var mt = new MessageType(v2XSubscription.MessageType);
                    v2XSubscription.Version = mt.Version.ToString();
                    v2XSubscription.TypeName = mt.TypeName;

                    session.Update(v2XSubscription);
                }

                tx.Commit();
                transaction.Complete();

                Logger.InfoFormat("{0} v2X subscriptions upgraded", v2XSubscriptions.Count);
            }
        }

        public override UIImage IconImageForMessageType(MessageType type) {
            if (this.config.Icon != null)
                return this.config.Icon.ToNative();

            var msgType = (MessageType)Enum.Parse(typeof(MessageType), config.Event.ToString());
            return base.IconImageForMessageType(msgType);
        }

        // Message box
        public static ResponseType ShowMessageBox(Window parent,
            MessageType mtype,
            ButtonsType buttons,
            string title,
            string message,
            params string[] args)
        {
            MessageDialog msgDlg =
                new MessageDialog(parent,
                                  DialogFlags.Modal,
                                  mtype,
                                  buttons,
                                  message,
                                  args);
            msgDlg.Title = title;
            msgDlg.UseMarkup = false;

            ResponseType response = ResponseType.None;
            msgDlg.Response += (object o, ResponseArgs args2) =>
            {
                msgDlg.Destroy();
                response = args2.ResponseId;
            };
            msgDlg.Run();
            return response;
        }

 public UnexpectedMessageException(
     MessageType messageType,
     MessageType expectedMessageType)
 {
     MessageType = messageType;
     ExpectedMessageType = expectedMessageType;
 }

        public byte[] ReceiveMessage(out MessageType type)
        {
            if (_disposed)
                throw new ObjectDisposedException(GetType().FullName);

            // Read the fixed length string that tells the message size and type
            byte[] byteBuffer = new byte[11];
            int bytesRead = _networkStream.Read(byteBuffer, 0, 11);
            if (bytesRead != 11)
                throw new ConnectionException(bytesRead.ToString());

            string header = Encoding.ASCII.GetString(byteBuffer);
            int bytesComing = Convert.ToInt32(header.Substring(1));
            type = (MessageType)Convert.ToInt32(header.Substring(0, 1));
            byteBuffer = new byte[bytesComing];

            // Read the message
            int offset = 0;
            do
            {
                bytesRead = _networkStream.Read(byteBuffer, offset, bytesComing - offset);
                if (bytesRead != 0)
                    offset += bytesRead;
                else
                    throw new ConnectionException(header);
            } while (offset != bytesComing);

            return byteBuffer;
        }

 public override void Append(MessageType messageType, string message)
 {
     using (var sw = new StreamWriter(this.FilePath, true))
     {
         sw.WriteLine($"{messageType}: {message}");
     }
 }

 public SessionMessage(MessageType messageType, MessageBehaviors behavior, string message, string key,string caption, MessageButton? messageButtons, MessageIcon? messageIcon)
 {
     if (behavior == MessageBehaviors.Modal && (!messageButtons.HasValue || !messageIcon.HasValue))
     {
         messageButtons = messageButtons ?? MessageButton.Ok;
         if(!messageIcon.HasValue)
         {
             switch(messageType)
             {
                 case MessageType.Error:
                     messageIcon = MessageIcon.Error;
                     break;
                 case MessageType.Info:
                     messageIcon = MessageIcon.Information;
                     break;
                 case MessageType.Success:
                     messageIcon = MessageIcon.Success;
                     break;
                 case MessageType.Warning:
                     messageIcon = MessageIcon.Warning;
                     break;
                 default:
                     messageIcon = MessageIcon.Information;
                     break;
             }
         }
     }
     Key = key;
     Message = message;
     Caption = caption;
     Type = messageType;
     Behavior = behavior;
     Buttons = messageButtons;
     Icon = messageIcon;
 }

 public Message(MessageType type, uint id, string route, JsonObject data)
 {
     this.type = type;
     this.id = id;
     this.route = route;
     this.data = data;
 }

        protected override Message Deserialize(BinaryReader reader, MessageType messageType)
        {
            int type = reader.ReadInt32();
            if (type == 2) {
                MessageStream stream = new MessageStream(messageType);
                int sz = reader.ReadInt32();
                for (int i = 0; i < sz; i++) {
                    stream.AddMessage(Deserialize(reader, messageType));
                }

                return stream as Message;
            }

            if (type == 1) {
                Message message;
                string messageName = reader.ReadString();
                if (messageType == MessageType.Request) {
                    message = new RequestMessage(messageName);
                } else {
                    message = new ResponseMessage(messageName);
                }

                int sz = reader.ReadInt32();
                for (int i = 0; i < sz; i++)
                    message.Arguments.Add(ReadArgument(reader));

                int v = reader.ReadInt32();
                if (v != 8)
                    throw new FormatException();

                return message;
            }

            throw new FormatException("Unable to determine the format of the message.");
        }

		public override void Reset()
		{
			gameObject = null;
			delivery = MessageType.SendMessage;
			options = SendMessageOptions.DontRequireReceiver;
			functionCall = null;
		}

 /// <summary>
 /// Produces Message.
 /// </summary>
 /// <param name="message">Message type.</param>
 /// <param name="parameter">Integer number.</param>
 /// <param name="secondParameter">Second Number.</param>
 /// <returns>Returns new message.</returns>
 public string MakeMessage(MessageType message, int parameter = 0, int secondParameter = 0)
 {
     switch (message)
     {
         case MessageType.Welcome:
             return new SimpleMessage(WelcomeText).Show();
         case MessageType.GameRules:
             return new SimpleMessage(GameRulesText).Show();
         case MessageType.Command:
             return new SimpleMessage(CommandText).Show();
         case MessageType.WrongNumber:
             return new TwoParameterMessage(new SimpleMessage(WrongNumberText), parameter, secondParameter).Show();
         case MessageType.Congratulation:
             return new OneParameterMessage(new SimpleMessage(CongratulationText), parameter).Show();
         case MessageType.CheatCongratulation:
             return new TwoParameterMessage(new SimpleMessage(CheatCongratulationText), parameter, secondParameter).Show();
         case MessageType.EnterName:
             return new SimpleMessage(EnterNameText).Show();
         case MessageType.Exit:
             return new SimpleMessage(ExitText).Show();
         case MessageType.InvalidCommand:
             return new SimpleMessage(InvalidCommandText).Show();
         case MessageType.InvalidNumberLength:
             return new SimpleMessage(InvalidNumberLengthText).Show();
         default:
             throw new ArgumentNullException(NullExceptionText);
     }
 }

	/// <summary>
	/// 
	/// </summary>
	public override void OnInspectorGUI()
	{

		if (m_PathFoldout || m_MovementFoldout || m_PhysicsFoldout || m_RotationFoldout || m_SoundFoldout)
		{

			if (m_Component.PathWaypoints != null)
				m_WaypointCount = m_Component.PathWaypoints.transform.childCount;
			else
				m_WaypointCount = 0;

			if (m_WaypointCount < 2)
			{
				PathMessageType = MessageType.Warning;
				PathInfo = NoWaypointsMessage;
			}

		}

		GUI.color = Color.white;
		
		DoPathFoldout();
		DoMovementFoldout();
		DoRotationFoldout();
		DoPhysicsFoldout();
		DoSoundFoldout();

		// update
		if (GUI.changed)
			EditorUtility.SetDirty(target);
		
	}

 public LogEventArgs(string message, MessageType messageType, StackTrace st)
 {
     this.message = message;
     this.dateTime = DateTime.Now;
     this.messageType = messageType;
     this.stackTrace = st;
 }

 private ResultDTO(MessageType messageType)
 {
     this.messageType = messageType;
     levelCount = Application.levelCount;
     loadedLevel = Application.loadedLevel;
     loadedLevelName = Application.loadedLevelName;
 }

 public void ShowMessage(string message, MessageType status)
 {
     MessageTextBlock.Text = message;
     RootBorder.Background = (status == MessageType.Successful) ? _successfulColor : _failedColor;
     RootBorder.BringIntoView();
     AnimatePopup();
 }

 public ChatMessageValues(MessageType type, string message, bool hasLanguage = false, bool hasRealmId = false)
 {
     ChatType = type;
     Message = message;
     HasLanguage = hasLanguage;
     HasRealmId = hasRealmId;
 }

        //public override void Receive<BrideAssignment>(int fromNode, BrideAssignment message, MessageType type)
        //{
        //    throw new NotImplementedException();
        //}
        public override void ReceiveEmail(long fromPseudonym, object message, MessageType type)
        {
            if (type == MessageType.UserAssignments)   // From a distributor: Here's a list of bridge id share for you.
            {
                var assignments = message as List<UserAssignment>;
                if (distributorPseudonyms.Count == 1)
                {
                    foreach (var a in assignments)
                        Bridges.Add(Simulator.GetNode<Bridge>((int)a.BridgeShare.Value));
                }
                else
                {
                    foreach (var a in assignments)
                    {
                        if (!BridgeShares.ContainsKey(a.BridgePseudonym))
                            BridgeShares[a.BridgePseudonym] = new List<Zp>();

                        BridgeShares[a.BridgePseudonym].Add(a.BridgeShare);

                        if (BridgeShares[a.BridgePseudonym].Count == distributorPseudonyms.Count)
                        {
                            // We have enough number of shares to reconstruct the bridge ID
                            int bridgeId = (int)ShamirSharing.Reconstruct(BridgeShares[a.BridgePseudonym],
                                Simulator.PolynomialDegree, Simulator.Prime).Value;

                            Debug.Assert(Simulator.GetNodes<Bridge>().Any(b => b.Id == bridgeId), "Invalid bridge ID reconstructed from shares.");
                            Bridges.Add(Simulator.GetNode<Bridge>(bridgeId));
                            BridgeShares[a.BridgePseudonym] = null;
                        }
                    }
                }
            }
            else throw new Exception("Invalid message received.");
        }