public MessageHeader(MessageDestination destination, int messageType, IntPtr floatValue, IntPtr entity)
 {
     this.Destination = destination;
     this.MessageType = messageType;
     this.FloatValue = floatValue;
     this.Entity = entity;
 }

 public static void SendTutorStateMessage(MessageDestination destination, IntPtr floatValue, IntPtr playerEntity, TutorStateMessage val)
 {
     SendTutorStateMessage(destination, floatValue,playerEntity );
 }

            public Message(PureMessage parent, string name, MessageType type, MessageDestination dest, string message)
            {
                this.parent = parent;

                this.name = name;
                this.type = type;
                this.dest = dest;
                this.message = message;
            }

		internal static void MessageBeginPost(MessageDestination destination, int messageType, IntPtr floatValue, IntPtr playerEntity)
		{
			if (firstMessage) {
				// there is no event which intercepts between
				// the registering part and the first message (weaponlist in cstrike case)
				// so we need to initialize the game mode before the first message so we can
				// intercept this valuable information
				switch (Server.GameDirectory) {
				case "cstrike":
					CounterStrike.CounterStrike.Init();
					break;
				}
				firstMessage = false;
			}

			#if DEBUG
			messageInformation = new MessageInformation(destination, messageType, floatValue, playerEntity);
			messageInformation.CallTimeBegin = DateTime.Now;
			#endif

			message_header = new MessageHeader(destination, messageType, floatValue, playerEntity);
			message_elements = new List<object>();

			MetaModEngine.SetResult(MetaResult.Handled);
			}

 public static void SendWeapPickupMessage(MessageDestination destination, WeapPickupMessage val)
 {
     SendWeapPickupMessage(destination, IntPtr.Zero, IntPtr.Zero , val.WeaponID);
 }

 public static void SendWeaponListMessage(MessageDestination destination, IntPtr floatValue, IntPtr playerEntity, WeaponListMessage val)
 {
     SendWeaponListMessage(destination, floatValue,playerEntity , val.WeaponName, val.PrimaryAmmoID, val.PrimaryAmmoMaxAmount, val.SecondaryAmmoID, val.SecondaryAmmoMaxAmount, val.SlotID, val.NumberInSlot, val.WeaponID, val.Flags);
 }

        public static void SendVGUIMenuMessage(MessageDestination destination, IntPtr floatValue, IntPtr playerEntity, byte MenuID, short KeyBitSum, char Time, byte MultiPart, string Name)
        {
            Message.Begin(destination, Message.GetUserMessageID("VGUIMenu"), floatValue, playerEntity);

            Message.WriteByte(MenuID);
            Message.WriteShort(KeyBitSum);
            Message.WriteChar(Time);
            Message.WriteByte(MultiPart);
            Message.WriteString(Name);
            Message.End();
        }

 public static void SendTutorTextMessage(MessageDestination destination, IntPtr floatValue, IntPtr playerEntity, TutorTextMessage val)
 {
     SendTutorTextMessage(destination, floatValue,playerEntity , val.Unknown1, val.Unknown2, val.Unknown3, val.Unknown4, val.Unknown5);
 }

 public static void SendVoiceMaskMessage(MessageDestination destination, VoiceMaskMessage val)
 {
     SendVoiceMaskMessage(destination, IntPtr.Zero, IntPtr.Zero , val.AudiblePlayersIndexbitSum, val.ServerBannedPlayersIndexBitSum);
 }

        public static void SendViewModeMessage(MessageDestination destination, IntPtr floatValue, IntPtr playerEntity)
        {
            Message.Begin(destination, Message.GetUserMessageID("ViewMode"), floatValue, playerEntity);

            Message.End();
        }

        /// <summary>
        /// Begins with the sending of a message.
        /// </summary>
        /// <param name="destination">
        /// The destination of a message. <see cref="MessageDestination"/>
        /// </param>
        /// <param name="msg_type">
        /// The integer value of the message type. <see cref="System.Int32"/>
        /// </param>
        /// <param name="flValue">
        /// A float value? <see cref="IntPtr"/>
        /// </param>
        /// <param name="player">
        /// If send to a specific player, the player entity has to be supplied here <see cref="IntPtr"/>
        /// </param>
        public static void Begin(MessageDestination destination, int messageType, IntPtr floatValue, IntPtr playerEntity)
        {
            #if DEBUG
            messageInformation = new MessageInformation(destination, messageType, floatValue, playerEntity);
            messageInformation.CallTimeBegin = DateTime.Now;
            #endif

            MetaModEngine.engineFunctions.MessageBegin(destination, messageType, floatValue, playerEntity);
            count = 0;
        }

 public MessageInformation(MessageDestination destination, int messageType, IntPtr val, IntPtr playerEdict)
 {
     MessageDestination = destination;
     MessageType = messageType;
     Value = val;
     PlayerEdict = playerEdict;
     Arguments = new List<MessageArgument>();
 }

 public PlayerSpawnMessage(PureMessage parent, string name, MessageType type, MessageDestination dest, string message)
     : base(parent, name, type, dest, message)
 {
     this.triggerOnce = true;
 }

 public PlayerJoinMessage(PureMessage parent, string name, MessageType type, MessageDestination dest, string message)
     : base(parent, name, type, dest, message)
 {
 }

 public static void SendTrainMessage(MessageDestination destination, TrainMessage val)
 {
     SendTrainMessage(destination, IntPtr.Zero, IntPtr.Zero , val.Speed);
 }