Пример #1
0
        public WorldObjectProperty ReadNextWorldObjectProperty(Stream src, long?count = null)
        {
            WorldObjectProperty prop = new WorldObjectProperty();

            prop.name = ReadNextString(src);
            if (prop.name == "None")
            {
                return(null);
            }

            prop.type  = ReadNextString(src);
            prop.size  = ReadNextInt32(src);
            prop.index = ReadNextInt32(src);

            if (!count.HasValue)
            {
                prop.value = ReadNextWorldObjectPropertyValue(src, prop.type);
            }
            else
            {
                prop.isMultiple = true;
                prop.values     = new List <object>();

                string subType = prop.type == "StructProperty" || prop.type == "ByteProperty" ? ReadNextString(src) : null;

                for (long i = 0; i < count; i++)
                {
                    prop.values.Add(ReadNextWorldObjectPropertyValue(src, prop.type, subType, i == 0, true));
                }
            }

            return(prop);
        }
Пример #2
0
        public WorldObjectProperties ReadNextWorldObjectProperties(Stream src, Int32 objectType)
        {
            WorldObjectProperties properties = new WorldObjectProperties();

            properties.properties = new List <WorldObjectProperty>();
            properties.size       = ReadNextInt32(src);
            Int64 start = src.Position;

            // entity
            if (objectType == 1)
            {
                properties.parentId      = ReadNextWorldObjectRef(src);
                properties.childrenCount = ReadNextInt32(src);

                for (int i = 0; i < properties.childrenCount; i++)
                {
                    WorldObjectRef child = ReadNextWorldObjectRef(src);
                    if (child != null)
                    {
                        if (properties.children == null)
                        {
                            properties.children = new List <WorldObjectRef>();
                        }

                        properties.children.Add(child);
                    }
                }
            }

            long notReaded = start + properties.size - src.Position;

            while (notReaded > 0)
            {
                WorldObjectProperty prop = ReadNextWorldObjectProperty(src);
                notReaded = start + properties.size - src.Position;
                if (prop == null)
                {
                    break;
                }

                properties.properties.Add(prop);
            }

            if (notReaded > 0)
            {
                src.Position += notReaded; // skip unknown
            }

            return(properties);
        }
Пример #3
0
        public WorldObjectStructProperty ReadNextWorldObjectDynamicStructProperty(
            Stream src,
            string type = null
            )
        {
            WorldObjectStructProperty structProp = new WorldObjectStructProperty();

            structProp.type       = type;
            structProp.properties = new List <WorldObjectProperty>();

            while (true)
            {
                WorldObjectProperty prop = ReadNextWorldObjectProperty(src);
                if (prop == null)
                {
                    break;
                }

                structProp.properties.Add(prop);
            }

            return(structProp);
        }