public void Read(StarboundStream stream)
        {
            AssetDigest = stream.ReadString();
            Claim       = stream.ReadVariant();
            bool uuid = stream.ReadBoolean();

            if (uuid)
            {
                UUID = stream.ReadUInt8Array(16);
            }
            PlayerName = stream.ReadString();
            Species    = stream.ReadString();
            Shipworld  = stream.ReadUInt8Array();
            Account    = stream.ReadString();
        }
Exemple #2
0
        public Metadata GetMetadata()
        {
            if (Metadata != null)
            {
                return(Metadata);
            }

            using (StarboundStream ss = new StarboundStream(GetRaw(new byte[] { 0, 0, 0 })))
            {
                var unpacked = DataConverter.Unpack("^ii", ss.ReadUInt8Array(8), 0); //unknown

                Document doc = Document.FromStream(ss);

                if (doc.Name != "WorldMetadata")
                {
                    throw new Exception("Invalid world data!");
                }

                Metadata = new Metadata(doc.Data, doc.Version);

                return(Metadata);
            }
        }
Exemple #3
0
        public IEnumerable <IPacket> UpdateBuffer(bool shouldCopy)
        {
            if (shouldCopy)
            {
                PacketBuffer.AddRange(NetworkBuffer);
            }

            Queue <byte[]> toProcess = new Queue <byte[]>();

            toProcess.Enqueue(PacketBuffer.ToArray());

            while (toProcess.Count > 0)
            {
                byte[] arr = toProcess.Dequeue();

                using (StarboundStream s = new StarboundStream(arr))
                {
                    if (WorkingLength == long.MaxValue && s.Length > 1)
                    {
                        _packetId = s.ReadUInt8();

                        try
                        {
                            WorkingLength = s.ReadSignedVLQ();
                        }
                        catch
                        {
                            WorkingLength = long.MaxValue;

                            yield break;
                        }

                        DataIndex = (int)s.Position;

                        Compressed = WorkingLength < 0;

                        if (Compressed)
                        {
                            WorkingLength = -WorkingLength;
                        }
                    }

                    if (WorkingLength != long.MaxValue)
                    {
                        if (s.Length >= WorkingLength + DataIndex)
                        {
                            if (s.Position != DataIndex)
                            {
                                s.Seek(DataIndex, SeekOrigin.Begin);
                            }

                            byte[] data = s.ReadUInt8Array((int)WorkingLength);

                            if (Compressed)
                            {
                                data = ZlibStream.UncompressBuffer(data);
                            }

                            //todo Omit this after testing
                            //SharpStarLogger.DefaultLogger.Info(string.Format("{0}{1}","ID : ",_packetId));

                            IPacket packet = Decode(_packetId, data);

                            WorkingLength = long.MaxValue;

                            byte[] rest = s.ReadToEnd();
                            PacketBuffer = rest.ToList();

                            if (rest.Length > 0)
                            {
                                toProcess.Enqueue(rest);
                            }

                            yield return(packet);
                        }
                    }
                }
            }
        }
Exemple #4
0
        public static Entity FromStream(IStarboundStream stream)
        {
            EntityType et = (EntityType)stream.ReadUInt8();

            byte[] storeData = stream.ReadUInt8Array();

            Entity ent;

            if (et == EntityType.Projectile)
            {
                ProjectileEntity pent = new ProjectileEntity();

                using (StarboundStream s = new StarboundStream(storeData))
                {
                    pent.Projectile      = s.ReadString();
                    pent.Information     = s.ReadVariant().Value as VariantDict;
                    pent.Unknown1        = s.ReadUInt8Array(17);
                    pent.ThrowerEntityId = s.ReadSignedVLQ();
                    pent.Unknown2        = s.ReadUInt8Array((int)(s.Length - s.Position));
                }

                ent = pent;
            }
            else if (et == EntityType.Player)
            {
                PlayerEntity pent = new PlayerEntity();

                using (StarboundStream s = new StarboundStream(storeData))
                {
                    /*
                     * bool uuid = s.ReadBoolean();
                     *
                     * if (uuid)
                     * {
                     */
                    byte[] uuidDat = s.ReadUInt8Array(16);

                    pent.UUID = BitConverter.ToString(uuidDat, 0).Replace("-", "").ToLower();

                    //}
                }

                ent = pent;
            }
            else if (et == EntityType.Object)
            {
                ObjectEntity oent = new ObjectEntity();

                using (StarboundStream s = new StarboundStream(storeData))
                {
                    oent.Object      = s.ReadString();
                    oent.Information = s.ReadVariant();
                    oent.Unknown     = s.ReadUInt8Array((int)(s.Length - s.Position));
                }

                ent = oent;
            }
            else
            {
                ent = new Entity();
            }

            ent.EntityType = et;
            ent.StoreData  = storeData;
            ent.EntityId   = stream.ReadSignedVLQ();

            return(ent);
        }