public MessageNode(GameMessage message, int start, int end)
 {
     this.gameMessage = message;
     this.mStart = start;
     this.mEnd = end;
     Text = String.Join(".", (message.GetType().ToString().Split('.').Skip(5)));
 }

 public GameServerPacket(GameMessage message)
 {
     m_stream = new MemoryStream();
     m_writer = new BinaryWriter(m_stream);
     m_writer.Write((byte)(StocMessage.GameMsg));
     m_writer.Write((byte)message);
 }

 public void BroadcastGlobal(GameMessage message)
 {
     foreach (var player in this.Players.Values)
     {
         player.InGameClient.SendMessageNow(message);
     }
 }

 public GameMessageResult Message_TouchStarted(GameMessage msg)
 {
     ToggleSelected();
     GameMessenger.Reg("touchEnded", this, Message_TouchEnded);
     GameMessenger.Reg("touchMoved", this, Message_TouchMoved);
     return GameMessageResult.handledMessage;
 }

 public GameMessageResult Message_newTestInputRecording(GameMessage msg)
 {
     var testName = (string)msg.data;
     text.text = "[Test] " + testName;
     Clear();
     return GameMessageResult.handledMessage;
 }

	public void HoldEnd (GameMessage msg)
	{
        Debug.Log("HoldEnd");
        // TODO(oz) Differenciate hold end from hold start
        ChangeBehaviour(Behaviour.HoldStart);
		SoundController.instance.PlaySfx (SoundController.SfxType.FxTams2, msg.targetId);
	}

		public GameServerPacket(GameMessage message):base(GamePacketByteLength)
		{
			Write((byte)(StocMessage.GameMsg));
			this.PacketMsg=StocMessage.GameMsg;
			Write((byte)message);
			this.GameMsg = message;
		}

    public override void OnGameMessage(GameMessage gameMessage)
    {
        //requestedState = gameMessage.unityInstanceStatus.requestedState;
        gameMessage.unityInstanceStatus.state = gameMessage.unityInstanceStatus.requestedState;

        Reply(gameMessage);
    }

	public static void Log(string txt, float life = 3.0f){
		GameMessage msg = new GameMessage ();
		msg.text = txt;
		msg.time = Time.time;
		msg.life = life;
		message_stream.OnNext(msg);
	}

		public static byte[] EmtryMessage(GameMessage message){
			byte[] data =null;
			using(GameServerPacket packet=new GameServerPacket(message)){
				data = packet.Content;
			}
			return data;
		}

 public static PacketWriter CreateAccount(bool successful, GameMessage failureReason)
 {
     var pw = GetWriter(ServerPacketID.CreateAccount);
     pw.Write(successful);
     if (!successful)
         pw.WriteEnum(failureReason);
     return pw;
 }

 /// <summary>
 /// Sends data to the <see cref="INetworkSender"/>. This method is thread-safe.
 /// </summary>
 /// <param name="sender">The <see cref="INetworkSender"/> to use to send the data.</param>
 /// <param name="message">GameMessage to send to the User.</param>
 /// <param name="messageType">The <see cref="ServerMessageType"/> to use for sending the <paramref name="message"/>.</param>
 /// <param name="parameters">Message parameters.</param>
 public static void Send(this INetworkSender sender, GameMessage message, ServerMessageType messageType,
                         params object[] parameters)
 {
     using (var pw = ServerPacket.SendMessage(message, parameters))
     {
         sender.Send(pw, messageType);
     }
 }

 public CoreMessage(GameMessage msg, BinaryReader reader, byte[] raw)
 {
     Message = msg;
     Reader = reader;
     m_raw = raw;
     m_stream = (MemoryStream)reader.BaseStream;
     m_startPosition = m_stream.Position;
 }

 public override GameMessage getMessage()
 {
     GameMessage message = new GameMessage ();
     message.bPieceSelectionMessage = false;
     message.iIndex1 = (int)squareIndex.x;
     message.iIndex2 = (int)squareIndex.y;
     return message;
 }

 public static GameMessage DespawnMessage(int index)
 {
     GameMessage msg = new GameMessage();
     msg.DataType = DataTypeDespawnEntity;
     msg.index = index;
     msg.MessageSize = 0;
     return msg;
 }

 public GameMessageResult Message_TouchMoved(GameMessage msg)
 {
     if (msg.data != null) {
         var position = (Ray)msg.data;
         gameObject.transform.position = position.origin;
     }
     return GameMessageResult.handledMessage;
 }

        public static void SendMessage(this GameObject sender, GameMessage msg, GameObject target)
        {
            if (msg == null)
            {
                Log.Game.WriteWarning("ExtMethodsGameObject: Tried to send a null message.\n{0}", Environment.StackTrace);
                return;
            }

            // if there is already a list on the stack then we have re-entered SendMessage i.e. a HandleMessage method has
            // called SendMessage
            if (_receiverStack.Count > 0)
                _currentReceivers = new List<ICmpHandlesMessages>();

            _receiverStack.Push(_currentReceivers);
            _currentReceivers.Clear();

            if (target != null)
            {
                if (!target.Active)
                {
                    _currentReceivers = _receiverStack.Pop();
                    return;
                }

                target.GetComponents(_currentReceivers);
            }
            else
            {
                Scene.Current.FindComponents(_currentReceivers);
            }

            try
            {
                for (int i = _currentReceivers.Count - 1; i >= 0; i--)
                {
                    var receiver = _currentReceivers[i];

                    if (receiver == null || ((Component)receiver).Disposed || ((Component)receiver).Active == false)
                        continue;

                    receiver.HandleMessage(sender, msg);

                    if (i > _currentReceivers.Count)
                        i = _currentReceivers.Count;

                    if (msg.Handled)
                        break;
                }
            }
            finally
            {
                _receiverStack.Pop();
                if (_receiverStack.Count > 0)
                    _currentReceivers = _receiverStack.Peek();
                else
                    _currentReceivers = _receivers;
            }
        }

	/// <summary>
	/// Adds the new messages to waiting queue.
	/// </summary>
	/// <param name="messages">Messages.</param>
	private void AddNewMessagesToWaitingQueue (List<string> messages)
	{
		foreach(string message in messages)
		{
			GameMessage newMessage = new GameMessage();
			newMessage.Message = message;
			waitingGameMessages.Enqueue(newMessage);
		}
	}

 public override GameMessage getMessage()
 {
     // PieceSelection function
     GameMessage message = new GameMessage ();
     message.bPieceSelectionMessage = true;
     message.iIndex1 = pieceIndex;
     message.belongsToAttacker = belongsToAttacker;
     return message;
 }

        public void Consume(GameClient client, GameMessage message)
        {
            if (message is AssignActiveSkillMessage) OnAssignActiveSkill(client, (AssignActiveSkillMessage)message);
            else if (message is AssignPassiveSkillMessage) OnAssignPassiveSkill(client, (AssignPassiveSkillMessage)message);
            else if (message is PlayerChangeHotbarButtonMessage) OnPlayerChangeHotbarButtonMessage(client, (PlayerChangeHotbarButtonMessage)message);
            else return;

            UpdateClient(client);
            client.FlushOutgoingBuffer();
        }