示例#1
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write string
            ms.WriteUEString((string)data);
        }
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write int
            ms.WriteInt((int)data);
        }
示例#3
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write the byte
            ms.ms.WriteByte((byte)data);
        }
        /// <summary>
        /// Loads from a GameObject
        /// </summary>
        /// <returns></returns>
        public static ArkInventory LoadFromAsset(ArkWorld world, DotArkGameObject r)
        {
            //Get a list of all items
            List <ObjectProperty> inventoryItems;

            if (!r.PropExistsName("InventoryItems"))
            {
                inventoryItems = new List <ObjectProperty>();
            }
            else
            {
                inventoryItems = ((ArrayProperty <ObjectProperty>)r.GetPropsByName("InventoryItems")[0]).items;
            }

            //Now, loop through and create items
            ArkInventory inventory = new ArkInventory();

            inventory.items = new List <ArkPrimalItem>();
            foreach (var o in inventoryItems)
            {
                ArkPrimalItem item = new ArkPrimalItem(world, o.gameObjectRef);
                if (item.isEngram)
                {
                    continue;
                }

                inventory.items.Add(item);
            }

            //Return
            return(inventory);
        }
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //If the length is four, just write the objectID
            //TODO: Track the referenced GameObject so changing the index doesn't break this.
            if (size == 4)
            {
                ms.WriteInt(objectId);
            }
            else if (size >= 8)
            {
                //Write the type
                ms.WriteInt((int)objectRefType);

                //Depending on the type, write it
                if (objectRefType == ObjectPropertyType.TypeID)
                {
                    ms.WriteInt(objectId);
                }
                else if (objectRefType == ObjectPropertyType.TypePath)
                {
                    ms.WriteArkClassname(className, s);
                }
                else
                {
                    throw new Exception("Unknown type of ObjectProperty.");
                }
            }
            else
            {
                throw new Exception($"Unknown ObjectProperty length, {size}. Cannot write.");
            }
        }
 public override void WriteStruct(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
 {
     ms.WriteFloat(r);
     ms.WriteFloat(g);
     ms.WriteFloat(b);
     ms.WriteFloat(a);
 }
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Get name table entry
            ms.WriteArkClassname((ArkClassName)data, s);
        }
示例#8
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write the UInt64
            ms.WriteULong((ulong)data);
        }
示例#9
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            //For now, fake this and pretend this is an empty array
            //TODO: Add ArrayProperty to saveable properties.
            size = 4;

            base.WriteProp(s, go, f, ms);
            ms.WriteArkClassname(arrayType, s);
            ms.WriteInt(0);
        }
示例#10
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write the struct type
            ms.WriteArkClassname(structType, s);

            //Write the struct data.
            structData.WriteStruct(s, go, f, ms);
        }
示例#11
0
        void ReadGameObjectTable()
        {
            int gameObjectCount = ms.ReadInt();

            gameObjects = new List <DotArkGameObject>();
            for (int i = 0; i < gameObjectCount; i++)
            {
                gameObjects.Add(DotArkGameObject.ReadBaseFromFile(this));
            }
        }
示例#12
0
        public HighLevelArkGameObjectRef(ArkWorld world, DotArkGameObject source)
        {
            this.source = source;
            this.world  = world;

            this.guid            = source.guid;
            this.classname       = source.classname;
            this.classnameString = source.classname.classname;
            this.isItem          = source.isItem;
            this.altNames        = source.names;
            this.location        = source.locationData;
        }
示例#13
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            byte value = 0;

            if ((bool)data)
            {
                value = 1;
            }

            //Write
            ms.WriteByte(value);
        }
        static void WriteSingleGameObjectBody(IOMemoryStream ms, DotArkFile f, DotArkGameObject o, DotArkSerializerInstance si)
        {
            //Just start writing properties
            foreach (var prop in o.props)
            {
                prop.WriteProp(si, o, f, ms);
            }

            //Finally, write a None name to tell Ark that this is the end of the list of props.
            ms.WriteArkClassname(new ArkClassName
            {
                classname = "None",
                index     = 0
            }, si);
        }
示例#15
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Convert from Base64 string
            byte[] buf = Convert.FromBase64String((string)data);

            //If this does not match the length, die
            if (size != buf.Length)
            {
                throw new Exception("The size of the TextProperty did not match the real size, in bytes.");
            }

            //Write
            ms.ms.Write(buf, 0, size);
        }
        public override void WriteStruct(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            //Write all of the props in the dict
            foreach (var p in props)
            {
                //Write property
                p.Value.WriteProp(s, go, f, ms);
            }

            //Finally, write a None type to stop Ark
            ms.WriteArkClassname(new ArkClassName
            {
                classname = "None",
                index     = 0
            }, s);
        }
        public DotArkGameObject gameObjectRef; //Only exists if the above is ObjectPropertyType.TypeID

        public ObjectProperty(DotArkDeserializer d, int index, int length)
        {
            var ms = d.ms;

            //If the length is four (only seems to happen on version 5), this is an integer.
            if (length == 4)
            {
                objectRefType    = ObjectPropertyType.TypeID;
                dataFilePosition = ms.position;
                objectId         = ms.ReadInt();
            }
            else if (length >= 8)
            {
                //Read type
                int type = ms.ReadInt();
                if (type > 1 || type < 0)
                {
                    throw new Exception($"Unknown ref type! Expected 0 or 1, but got {type} instead!");
                }
                //Convert this to our enum
                objectRefType    = (ObjectPropertyType)type;
                dataFilePosition = ms.position;
                //Depending on the type, read it in.
                if (objectRefType == ObjectPropertyType.TypeID)
                {
                    objectId = ms.ReadInt();
                }
                if (objectRefType == ObjectPropertyType.TypePath)
                {
                    className = ms.ReadArkClassname(d);
                }
            }
            else
            {
                dataFilePosition = ms.position;
                throw new Exception($"Unknown object ref length! Expected 4 or >= 8, but got {length} instead.");
            }
            //If this is a type ID, I **THINK** this is a refrence to a GameObject
            if (objectRefType == ObjectPropertyType.TypeID)
            {
                if (objectId != -1)
                {
                    gameObjectRef = d.gameObjects[objectId];
                }
            }
        }
示例#18
0
        public override void WriteProp(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
        {
            base.WriteProp(s, go, f, ms);

            //Write enum name
            ms.WriteArkClassname(enumName, s);

            //If this is a normal byte, write the byte value. Else, write the classname
            if (isNormalByte)
            {
                ms.ms.WriteByte(byteValue);
            }
            else
            {
                ms.WriteArkClassname(enumValue, s);
            }
        }
示例#19
0
        public ArkPlayer(ArkWorld world, DotArkGameObject orig) : base(world, orig)
        {
            playerName = GetStringProperty("PlayerName");
            steamName  = GetStringProperty("PlatformProfileName");
            arkId      = GetUInt64Property("LinkedPlayerDataID");

            //Read the struct containing Steam ID
            StructProperty       sprop  = (StructProperty)GetSingleProperty("PlatformProfileID");
            ArkStructUniqueNetId nsprop = (ArkStructUniqueNetId)sprop.structData;

            steamId = nsprop.netId;

            //Tribe stuff
            if (HasProperty("TribeName"))
            {
                tribeName = GetStringProperty("TribeName");
                tribeId   = GetInt32Property("TargetingTeam");
                isInTribe = true;
            }
            else
            {
                tribeName = "No Tribe";
                tribeId   = -1;
                isInTribe = false;
            }

            //Check if alive
            try
            {
                HighLevelArkGameObjectRef statusComponent = GetGameObjectRef("MyCharacterStatusComponent");
                currentStats = ArkDinosaurStats.ReadStats(statusComponent, "CurrentStatusValues", false);
                isAlive      = currentStats.health > 0.1f;
            } catch
            {
                isAlive = false;
            }
        }
示例#20
0
        public ArkStructure(ArkWorld world, DotArkGameObject orig, StructureDisplayMetadata displayMetadata) : base(world, orig)
        {
            tribeId              = GetInt32Property("TargetingTeam");
            isInTribe            = true;
            hasInventory         = HasProperty("MyInventoryComponent");
            this.displayMetadata = displayMetadata;

            if (HasProperty("CurrentItemCount"))
            {
                currentItemCount = GetInt32Property("CurrentItemCount");
            }
            if (HasProperty("MaxItemCount"))
            {
                currentItemCount = GetInt32Property("MaxItemCount");
            }
            if (HasProperty("Health"))
            {
                currentHealth = GetFloatProperty("Health");
            }
            if (HasProperty("MaxHealth"))
            {
                maxHealth = GetFloatProperty("MaxHealth");
            }
        }
示例#21
0
        static void WriteHead(IOMemoryStream ms, DotArkFile f, DotArkSerializerInstance si, DotArkGameObject go, long propertyOffset)
        {
            //Write data according to https://us-central.assets-static-2.romanport.com/ark/#gameobject+base_header
            ms.WriteBytes(go.guid.ToByteArray());   //Write the GUID
            ms.WriteArkClassname(go.classname, si); //Write classname
            ms.WriteIntBool(go.isItem);

            //Write classname array
            ms.WriteInt(go.names.Count);
            foreach (var n in go.names)
            {
                ms.WriteArkClassname(n, si);
            }

            //Write unknowns
            ms.WriteIntBool(go.unknownData1);
            ms.WriteInt(go.unknownData2);

            //Write position data if it exists.
            ms.WriteIntBool(go.locationData != null);
            if (go.locationData != null)
            {
                ms.WriteLocationData(go.locationData);
            }

            //Write the offset to the properties data
            ms.WriteInt((int)propertyOffset);

            //Write last unknown data
            ms.WriteInt(go.unknownData3);
        }
 public override void WriteStruct(DotArkSerializerInstance s, DotArkGameObject go, DotArkFile f, IOMemoryStream ms)
 {
     ms.WriteInt(unk);
     ms.WriteUEString(netId);
 }
        public ArkPrimalItem(ArkWorld world, DotArkGameObject orig) : base(world, orig)
        {
            //Check if this is claimed not to be an item
            if (!isItem)
            {
                throw new Exception("Cannot read ArkPrimalItem when property 'isItem' is false!");
            }
            //Read in values. Start with values that will never be null
            classname = orig.classname.classname;
            stackSize = 1;
            if (orig.PropExistsName("ItemQuantity"))
            {
                stackSize = (int)orig.GetPropByName("ItemQuantity").data;
            }
            owner = new HighLevelArkGameObjectRef(world, (orig.GetPropsByName <ObjectProperty>("OwnerInventory")[0]).gameObjectRef);

            //Convert ItemID
            ArkStructProps itemIdStruct = (ArkStructProps)orig.GetPropsByName <StructProperty>("ItemId")[0].structData;

            byte[] buf = new byte[8];
            BitConverter.GetBytes((UInt32)itemIdStruct.props_string["ItemID1"].data).CopyTo(buf, 0);
            BitConverter.GetBytes((UInt32)itemIdStruct.props_string["ItemID2"].data).CopyTo(buf, 4);
            itemId = BitConverter.ToUInt64(buf, 0);

            //Read booleans
            isBlueprint = GetBooleanProperty("bIsBlueprint");
            isEngram    = GetBooleanProperty("bIsEngram");

            //Read props that may not exist
            if (CheckIfValueExists("SavedDurability"))
            {
                savedDurability = GetFloatProperty("SavedDurability");
            }
            else
            {
                savedDurability = 1;
            }

            if (CheckIfValueExists("CrafterCharacterName"))
            {
                crafterName = GetStringProperty("CrafterCharacterName");
            }
            else
            {
                crafterName = null;
            }

            if (CheckIfValueExists("CrafterTribeName"))
            {
                crafterTribe = GetStringProperty("CrafterTribeName");
            }
            else
            {
                crafterTribe = null;
            }

            if (CheckIfValueExists("LastAutoDurabilityDecreaseTime"))
            {
                lastDurabilityDecreaseTime = (double)orig.GetPropsByName <DoubleProperty>("LastAutoDurabilityDecreaseTime")[0].data;
            }
            else
            {
                lastDurabilityDecreaseTime = -1;
            }
        }
示例#24
0
        public ArkDinosaur(ArkWorld world, DotArkGameObject orig) : base(world, orig)
        {
            //Grab the data and save it here.
            //Get the other components of this dinosaur.
            HighLevelArkGameObjectRef statusComponent = GetGameObjectRef("MyCharacterStatusComponent");

            //Check if this dinosaur is tamed.
            isTamed = CheckIfValueExists("TamedName") && CheckIfValueExists("TribeName") && CheckIfValueExists("TargetingTeam");
            //Grab the values that will exist on both tamed and untamed dinosaurs.
            isFemale = GetBooleanProperty("bIsFemale");
            //Convert the colors into a byte array and hex.
            var colorAttrib = GetPropertiesByName("ColorSetIndices"); //Get all of the color properties from the dinosaur. These are indexes in the color table.

            colors     = new byte[colorAttrib.Length];                //Initialize the array for storing the indexes. These will be saved to the file.
            colors_hex = new string[colorAttrib.Length];              //Initialize the array for reading nice HTML color values.
            for (int i = 0; i < colors.Length; i++)                   //For each color region this dinosaur has. Each "ColorSetIndices" value is a color region.
            {
                colors[i] = ((ByteProperty)colorAttrib[i]).byteValue; //Get the index in the color table by getting the byte value out of the property
                //Validate that the color is in range
                byte color = colors[i];
                if (color <= 0 || color > ArkColorIds.ARK_COLOR_IDS.Length)
                {
                    colors_hex[i] = "#FFF";
                }
                else
                {
                    colors_hex[i] = ArkColorIds.ARK_COLOR_IDS[colors[i] - 1]; //Look this up in the color table to get the nice HTML value.
                }
            }
            //Read the dinosaur ID by combining the the bytes of the two UInt32 values.
            byte[] buf = new byte[8];
            BitConverter.GetBytes(GetUInt32Property("DinoID1")).CopyTo(buf, 0);
            BitConverter.GetBytes(GetUInt32Property("DinoID2")).CopyTo(buf, 4);
            //Convert this to a ulong
            dinosaurId = BitConverter.ToUInt64(buf, 0);
            //Read in levels
            currentStats        = ArkDinosaurStats.ReadStats(statusComponent, "CurrentStatusValues", false);
            baseLevelupsApplied = ArkDinosaurStats.ReadStats(statusComponent, "NumberOfLevelUpPointsApplied", true);
            baseLevel           = 1;
            if (statusComponent.CheckIfValueExists("BaseCharacterLevel"))
            {
                baseLevel = statusComponent.GetInt32Property("BaseCharacterLevel");
            }
            level = baseLevel;
            //Now, convert attributes that only exist on tamed dinosaurs.
            isInTribe = isTamed;
            if (isTamed)
            {
                tamedName            = GetStringProperty("TamedName");
                tribeId              = GetInt32Property("TargetingTeam");
                tamerName            = GetStringProperty("TribeName");
                tamedLevelupsApplied = ArkDinosaurStats.ReadStats(statusComponent, "NumberOfLevelUpPointsAppliedTamed", true);
                if (statusComponent.CheckIfValueExists("ExtraCharacterLevel"))
                {
                    level += statusComponent.GetUInt16Property("ExtraCharacterLevel");
                }
                if (statusComponent.HasProperty("ExperiencePoints"))
                {
                    experience = statusComponent.GetFloatProperty("ExperiencePoints");
                }
                else
                {
                    experience = 0;
                }

                isBaby = GetBooleanProperty("bIsBaby");
                if (isBaby)
                {
                    babyAge         = GetFloatProperty("BabyAge");
                    nextImprintTime = -1;
                    if (HasProperty("BabyNextCuddleTime"))
                    {
                        nextImprintTime = GetDoubleProperty("BabyNextCuddleTime");
                    }
                    if (statusComponent.HasProperty("DinoImprintingQuality"))
                    {
                        imprintQuality = statusComponent.GetFloatProperty("DinoImprintingQuality");
                    }
                    else
                    {
                        imprintQuality = 0;
                    }
                }
            }

            //Get the dino entry data
            dino_entry = ArkImports.GetDinoDataByClassname(classname.classname);

            isInit = true;
        }
示例#25
0
 public ArkCharacter(ArkWorld world, DotArkGameObject orig) : base(world, orig)
 {
 }