public override void ReadPayload(IValueReader reader)
        {
            this.NetworkID = reader.ReadUInt32();
            this.CharacterName = reader.ReadString();

            this.Action = (PlayerUpdateAction)reader.ReadByte();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SkeletonFrame"/> class.
        /// </summary>
        /// <param name="reader">The <see cref="IValueReader"/> to read from.</param>
        /// <param name="contentPath">The <see cref="ContentPaths"/> to use to load from.</param>
        /// <exception cref="InvalidOperationException">The <see cref="Skeleton"/> failed to load.</exception>
        public SkeletonFrame(IValueReader reader, ContentPaths contentPath)
        {
            Read(reader, contentPath);

            if (Skeleton == null)
                throw new InvalidOperationException("Skeleton failed to load.");
        }

        public virtual InternalEntityEntry StartTracking(IEntityType entityType, object entity, IValueReader valueReader)
        {
            // TODO: Perf: Pre-compute this for speed
            var keyProperties = entityType.GetPrimaryKey().Properties;
            var keyValue = _keyFactorySource.GetKeyFactory(keyProperties).Create(entityType, keyProperties, valueReader);

            if (keyValue == EntityKey.InvalidEntityKey)
            {
                throw new InvalidOperationException(Strings.InvalidPrimaryKey(entityType.DisplayName()));
            }

            var existingEntry = TryGetEntry(keyValue);

            if (existingEntry != null)
            {
                if (existingEntry.Entity != entity)
                {
                    throw new InvalidOperationException(Strings.IdentityConflict(entityType.DisplayName()));
                }

                return existingEntry;
            }

            var newEntry = _subscriber.SnapshotAndSubscribe(_factory.Create(this, entityType, entity, valueReader));

            _identityMap.Add(keyValue, newEntry);
            _entityReferenceMap[entity] = newEntry;

            newEntry.SetEntityState(EntityState.Unchanged);

            return newEntry;
        }

        internal ServerInfo(ISerializationContext context, IValueReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException ("reader");

            Deserialize (context, reader);
        }

        public ChannelChangeInfo(ISerializationContext context, IValueReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException("reader");

            Deserialize (context, reader);
        }

        private IEventCommand ReadNextEvent(IValueReader reader, ScriptCommandType commandType)
        {
            IEventCommand command = null;

            switch(commandType)
            {
                case ScriptCommandType.Jump:
                    command = new JumpCommand ();
                    break;
                case ScriptCommandType.Lock:
                    command = new LockCommand ();
                    break;
                case ScriptCommandType.Pause:
                    command = new PauseCommand ();
                    break;
                case ScriptCommandType.PauseEvent:
                    command = new PauseEventCommand ();
                    break;
                case ScriptCommandType.ApplyMovement:
                    command = new ApplyMovementCommand ();
                    break;
                case ScriptCommandType.Release:
                    command = new ReleaseCommand ();
                    break;
                default:
                    break;
            }

            if(command == null)
                throw new ArgumentOutOfRangeException ("commandType", "The specified event was not found.");

            command.Deserialize (reader);
            return command;
        }

        public override EntityKey Create(
            IEntityType entityType, IReadOnlyList<IProperty> properties, IValueReader valueReader)
        {
            var components = new object[properties.Count];

            for (var i = 0; i < properties.Count; i++)
            {
                var index = properties[i].Index;

                if (valueReader.IsNull(index))
                {
                    return EntityKey.InvalidEntityKey;
                }

                var value = _boxedValueReaders[i].ReadValue(valueReader, index);

                if (Equals(value, _sentinels[i]))
                {
                    return EntityKey.InvalidEntityKey;
                }

                components[i] = value;
            }

            return new CompositeEntityKey(entityType, components);
        }

        private NetworkEntity ReadEntity(ISerializationContext context, IValueReader reader)
        {
            var entity = new NetworkEntity (reader.ReadString (), EntityType.Client);

            entity.NetworkID = reader.ReadUInt16 ();
            UInt16 fieldCount = reader.ReadUInt16 ();

            for (int f = 0; f < fieldCount; f++)
            {
                string name = reader.ReadString ();
                ushort typeID = reader.ReadUInt16 ();

                Type type;
                context.TypeMap.TryGetType (typeID, out type);

                object value;

                if (type == typeof (Vector2))
                    value = reader.Read (context, Vector2Serializer.Instance);
                else if (type == typeof (Vector3))
                    value = reader.Read (context, Vector3Serializer.Instance);
                else
                    value = reader.Read (context, type);

                entity.Fields.Add (name, new PropertyGroup (value, type));
            }

            return entity;
        }

        public override void ReadPayload(ISerializationContext context, IValueReader reader)
        {
            AudioSource[] sourceInfos = new AudioSource[reader.ReadInt32()];
            for (int i = 0; i < sourceInfos.Length; ++i)
                sourceInfos[i] = new AudioSource (context, reader);

            this.Sources = sourceInfos;
        }

        public override void ReadPayload(ISerializationContext context, IValueReader reader)
        {
            int[] sourceIds = new int[reader.ReadInt32()];
            for (int i = 0; i < sourceIds.Length; ++i)
                sourceIds[i] = reader.ReadInt32();

            this.SourceIds = sourceIds;
        }

 public override void ReadPayload(IValueReader reader)
 {
     base.ReadPayload(reader);
     var internalEndPointAddress = new IPAddress(reader.ReadBytes());
     InternalOwnEndPoint = new IPEndPoint(internalEndPointAddress, reader.ReadInt32());
     var externalEndPointAddress = new IPAddress(reader.ReadBytes());
     ExternalPeerEndPoint = new IPEndPoint(externalEndPointAddress, reader.ReadInt32());
 }

		public override void ReadPayload (ISerializationContext context, IValueReader reader)
		{
			if (reader.ReadBool())
				SenderId = reader.ReadString();

			GroupId = reader.ReadInt32();
			Text = reader.ReadString();
		}

 public void Read(IValueReader reader)
 {
     GrhIndex = reader.ReadGrhIndex(_grhIndexValueKey);
     _sourceName = reader.ReadString(_sourceValueKey);
     _destName = reader.ReadString(_destValueKey);
     Offset = reader.ReadVector2(_offsetValueKey);
     Origin = reader.ReadVector2(_originValueKey);
 }

        /// <summary>
        /// Reads a filter from an <see cref="IValueReader"/>.
        /// </summary>
        /// <param name="reader">The <see cref="IValueReader"/> to read from.</param>
        /// <returns>The name of the filter and the filter object.</returns>
        static KeyValuePair<string, MapDrawFilterHelper> ReadFilter(IValueReader reader)
        {
            var key = reader.ReadString(_filterKeyValueName);

            var valueReader = reader.ReadNode(_filterValueValueName);
            var value = new MapDrawFilterHelper(valueReader);

            return new KeyValuePair<string, MapDrawFilterHelper>(key, value);
        }

        public void Deserialize(IValueReader reader)
        {
            this.NonCharacter = reader.ReadBool();
            this.PlayerID = reader.ReadInt32 ();

            int count = reader.ReadInt32 ();
            for(int i = 0; i < count; i++)
                this.path.Add ((Directions) reader.ReadInt32 ());
        }

        public override void ReadPayload(ISerializationContext context, IValueReader reader)
        {
            int numUsers = reader.ReadInt32();
            IUser[] users = new IUser[numUsers];
            for (int i = 0; i < users.Length; ++i)
                users[i] = new User (reader.ReadInt32(), reader.ReadString());

            Users = users;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AnimatedGrhData"/> class.
        /// </summary>
        /// <param name="r">The <see cref="IValueReader"/>.</param>
        /// <param name="grhIndex">The <see cref="GrhIndex"/>.</param>
        /// <param name="cat">The <see cref="SpriteCategorization"/>.</param>
        /// <exception cref="ArgumentNullException"><paramref name="cat"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="grhIndex"/> is equal to GrhIndex.Invalid.</exception>
        AnimatedGrhData(IValueReader r, GrhIndex grhIndex, SpriteCategorization cat) : base(grhIndex, cat)
        {
            var speed = r.ReadInt(_speedValueKey);
            var frames = r.ReadMany(_framesNodeName, (xreader, xname) => xreader.ReadGrhIndex(xname));

            _speed = 1f / speed;
            _frames = CreateFrames(frames);
            _size = GetMaxSize(_frames);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MapGrh"/> class.
        /// </summary>
        /// <param name="reader">The reader to read the values from.</param>
        /// <param name="currentTime">The current time.</param>
        /// <exception cref="ArgumentNullException"><paramref name="reader" /> is <c>null</c>.</exception>
        public MapGrh(IValueReader reader, TickCount currentTime)
        {
            if (reader == null)
                throw new ArgumentNullException("reader");

            _grh = new Grh(null, AnimType.Loop, currentTime);

            ReadState(reader);
        }

        public override EntityKey Create(IEntityType entityType, IReadOnlyList<IProperty> properties, IValueReader valueReader)
        {
            Check.NotNull(entityType, "entityType");
            Check.NotNull(properties, "properties");
            Check.NotNull(valueReader, "valueReader");

            // TODO: Consider using strongly typed ReadValue instead of always object
            return Create(entityType, properties.Select(p => valueReader.ReadValue<object>(p.Index)).ToArray());
        }

        public override void ReadPayload(IValueReader reader)
        {
            int count = reader.ReadInt32 ();

            for(int i = 0; i < count; i++)
            {
                ScriptCommandType commandType = (ScriptCommandType) reader.ReadInt32 ();
                this.EventCommands.Add (this.ReadNextEvent (reader, commandType));
            }
        }