public void Write(Stream stream)
        {
            // Game length
            stream.WriteInt(LengthInSeconds);

            // Game version, 8 bytes, ASCII
            stream.WriteString(GameVersion, 8, Encoding.ASCII);

            // Date and time, 8 bytes
            stream.WriteLong(DateAndTime.ToBinary());
            // SawCompletion, 1 byte
            stream.WriteBool(SawCompletion);
            // Number of players, 1 byte
            stream.WriteByte(Convert.ToByte(GetPlayerCount()));
            // Average FPS, 4 bytes
            stream.WriteInt(AverageFPS);
            // Map name, 128 bytes (64 chars), Unicode
            stream.WriteString(MapName, 128);
            // Game mode, 64 bytes (32 chars), Unicode
            stream.WriteString(GameMode, 64);
            // Unique game ID, 4 bytes
            stream.WriteInt(GameID);
            // Whether game options were valid for earning a star, 1 byte
            stream.WriteBool(IsValidForStar);

            // Write player info
            for (int i = 0; i < GetPlayerCount(); i++)
            {
                PlayerStatistics ps = GetPlayer(i);
                ps.Write(stream);
            }
        }
Example #2
0
 public void Write(Stream stream)
 {
     stream.WriteInt(Economy);
     // 1 byte for IsAI
     stream.WriteBool(IsAI);
     // 1 byte for IsLocalPlayer
     stream.WriteBool(IsLocalPlayer);
     // 4 bytes for kills
     stream.Write(BitConverter.GetBytes(Kills), 0, 4);
     // 4 bytes for losses
     stream.Write(BitConverter.GetBytes(Losses), 0, 4);
     // Name takes 32 bytes
     stream.WriteString(Name, 32);
     // 1 byte for SawEnd
     stream.WriteBool(SawEnd);
     // 4 bytes for Score
     stream.WriteInt(Score);
     // 1 byte for Side
     stream.WriteByte(Convert.ToByte(Side));
     // 1 byte for Team
     stream.WriteByte(Convert.ToByte(Team));
     // 1 byte color Color
     stream.WriteByte(Convert.ToByte(Color));
     // 1 byte for WasSpectator
     stream.WriteBool(WasSpectator);
     // 1 byte for Won
     stream.WriteBool(Won);
     // 1 byte for AI level
     stream.WriteByte(Convert.ToByte(AILevel));
 }
Example #3
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(UserID);
     aStream.WriteInt(TargetID);
     aStream.WriteBoolean(LeftClick);
 }
Example #4
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
 }
Example #5
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(X);
     aStream.WriteInt(Z);
     aStream.WriteBoolean(Mode);
 }
Example #6
0
 public void WriteToStream(Stream ms)
 {
     ms.WriteX2String(_previousHash);
     ms.WriteX2String(_dataHash);
     ms.WriteInt(_index);
     ms.WriteInt(_blockTimestamp);
 }
Example #7
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(EntityID);
     aStream.WriteByte(InBed);
     aStream.WriteInt(X);
     aStream.WriteByte(Y);
     aStream.WriteInt(Z);
 }
Example #8
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteByte ((byte)Type);
     aStream.WriteInt (X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
 }
Example #9
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteByte((byte)Status);
     aStream.WriteInt(X);
     aStream.WriteByte(Y);
     aStream.WriteInt(Z);
     aStream.WriteByte((byte)Face);
 }
Example #10
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
     aStream.WriteByte(Yaw);
     aStream.WriteByte(Pitch);
 }
Example #11
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(EntityID);
     aStream.WriteByte((byte)Type);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
 }
Example #12
0
 /// <summary>
 /// Save modifier data to stream
 /// </summary>
 /// <param name="stream"></param>
 public void Save(Stream stream)
 {
     stream.WriteStringPacket(affectedStat);
     stream.WriteInt((int)effectType);
     stream.WriteInt((int)valueTarget);
     stream.WriteInt((int)valueType);
     stream.WriteStringPacket(value);
     stream.WriteFloat(AppliedValue);
     stream.WriteStringPacket(id.ToString());
 }
Example #13
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(EntityID);
     aStream.WriteString16(Title);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
     aStream.WriteInt(Direction);
 }
Example #14
0
 public override void Save(Stream stream)
 {
     stream.WriteByte((byte)Field.SpecialTile);
     stream.WriteByte((byte)Type);
     stream.WriteInt(d_map);
     stream.WriteInt(d_x);
     stream.WriteInt(d_y);
     stream.WriteByte((byte)d_anim);
     stream.WriteDouble(density);
     base.Save(stream);
 }
Example #15
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(EntityID);
     aStream.WriteString16(PlayerName);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
     aStream.WriteByte(Rotation);
     aStream.WriteByte(Pitch);
     aStream.WriteShort(CurrentItem);
 }
Example #16
0
 public static void WriteByteArray(this Stream stream, byte[] data)
 {
     if (null != data)
     {
         int len = data.Length;
         stream.WriteInt(len);
         stream.Write(data, 0, len);
     }
     else
     {
         stream.WriteInt(-1);
     }
 }
Example #17
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(X);
     aStream.WriteByte(Y);
     aStream.WriteInt(Z);
     aStream.WriteByte((byte)Direction);
     aStream.WriteShort(ItemID);
     if (ItemID >= 0)
     {
         aStream.WriteByte(Amount);
         aStream.WriteShort(Damage);
     }
 }
Example #18
0
 public void Save(Stream stream)
 {
     stream.WriteStringPacket(displayName);
     if (icon == null)
     {
         stream.WriteInt(0);
     }
     else
     {
         byte[] spriteData = icon.texture.EncodeToPNG();
         stream.WriteInt(spriteData.Length);
         stream.Write(spriteData, 0, spriteData.Length);
     }
 }
Example #19
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteInt(EntityID);
     aStream.WriteShort(ItemID);
     aStream.WriteByte(Count);
     aStream.WriteShort(DamageData);
     aStream.WriteInt(X);
     aStream.WriteInt(Y);
     aStream.WriteInt(Z);
     aStream.WriteByte(Rotation);
     aStream.WriteByte(Pitch);
     aStream.WriteByte(Roll);
 }
Example #20
0
        public static async Task WriteString(this Stream stream, string value)
        {
            if (value == null)
            {
                await stream.WriteInt(-1);
            }
            else
            {
                var buffer = Encoding.UTF8.GetBytes(value);

                await stream.WriteInt(buffer.Length);

                await stream.WriteAsync(buffer, 0, buffer.Length);
            }
        }
Example #21
0
        /// <summary>
        /// Serializes the data store.
        /// </summary>
        /// <param name="stream">The stream to write the serialized data to.</param>
        private void SerializeStore(Stream stream)
        {
            stream.WriteInt(Store.Count);

            foreach (var pair in Store)
            {
                byte[] str_raw = Encoding.UTF8.GetBytes(pair.Key);

                stream.WriteInt(str_raw.Length);
                stream.Write(str_raw, 0, str_raw.Length);

                stream.WriteInt(pair.Value.Length);
                stream.Write(pair.Value, 0, pair.Value.Length);
            }
        }
Example #22
0
        public static void WriteVarchar(this Stream stream, string value)
        {
            var bytes = Encoding.UTF8.GetBytes(value);

            stream.WriteInt(bytes.Length);
            stream.Write(bytes);
        }
Example #23
0
 public static void WriteIntArray(this Stream stream, int[] Number)
 {
     foreach (var N in Number)
     {
         stream.WriteInt(N);
     }
 }
Example #24
0
 /// <summary>
 ///   Writes an IP address and port
 /// </summary>
 /// <param name="stream"> The stream. </param>
 /// <param name="endpoint"> The endpoint. </param>
 public static void WriteInet(this Stream stream, IPEndPoint endpoint)
 {
     byte[] ip = endpoint.Address.GetAddressBytes();
     stream.Write(new[] { (byte)ip.Length }, 0, 1);
     stream.Write(ip, 0, ip.Length);
     stream.WriteInt(endpoint.Port);
 }
Example #25
0
        public override async Task Encode()
        {
            var count = 0;

            using (var buffer = new MemoryStream())
            {
                foreach (var player in Resources.LeaderboardCache.GlobalPlayers)
                {
                    if (player == null)
                    {
                        continue;
                    }
                    await buffer.WriteLong(player.AccountId);

                    await buffer.WriteString(player.Name);

                    await buffer.WriteInt(count + 1);

                    await buffer.WriteInt(player.Score);

                    await buffer.WriteInt(200);

                    await player.AvatarRankingEntry(buffer);

                    if (count++ >= 199)
                    {
                        break;
                    }
                }

                await Stream.WriteInt(count);

                await Stream.WriteBuffer(buffer.ToArray());
            }
        }
Example #26
0
        public static void WriteIntPrefixedByteArray(this Stream stream, byte[] value)
        {
            var len = value.Length;

            stream.WriteInt(len);
            stream.Write(value, 0, len);
        }
Example #27
0
        //Refer: corefx SqlDateTime.FromTimeSpan
        public static void WriteIntPartDateTime(this Stream stream, DateTime value)
        {
            var span  = value - SqlDateTimeEpoch;
            var day   = span.Days;
            var ticks = span.Ticks - day * TimeSpan.TicksPerDay;

            if (ticks < 0L)
            {
                day--;
                ticks += TimeSpan.TicksPerDay;
            }
            var time = (int)((double)ticks / TimeSpan.TicksPerMillisecond * SqlTicksPerMillisecond + 0.5);

            stream.WriteInt(day);
            stream.WriteInt(time);
        }
        private static void WriteTDS_LONGBINARY(object value, Stream stream, FormatItem format, Encoding enc)
        {
            if (!stream.TryWriteIntPrefixedNull(value))
            {
                switch (value)
                {
                case string s:
                    stream.WriteIntPrefixedByteArray(Encoding.Unicode.GetBytes(s));
                    break;

                case char c:
                    stream.WriteIntPrefixedByteArray(Encoding.Unicode.GetBytes(new[] { c }));
                    break;

                case byte[] ba:
                    stream.WriteIntPrefixedByteArray(ba);
                    break;

                case byte b:
                    stream.WriteIntPrefixedByteArray(new[] { b });
                    break;

                default:
                    stream.WriteInt(0);
                    break;
                }
            }
        }
Example #29
0
        public override async Task Encode()
        {
            /*var count = 0;
             *
             * using (var buffer = new MemoryStream())
             * {
             *  foreach (var player in Resources.LeaderboardCache.GlobalPlayers)
             *  {
             *      if (player == null) continue;
             *
             *      await buffer.WriteVInt(player.HighId); // HighId
             *      await buffer.WriteVInt(player.LowId); // LowId
             *      await buffer.WriteString(player.Name); // Name
             *      await buffer.WriteVInt(count + 1); // Order
             *      await buffer.WriteVInt(player.Score); // Score
             *      await buffer.WriteVInt(200); // PreviousOrder
             *
             *      await player.AvatarRankingEntry(buffer);
             *
             *      count++;
             *  }
             *
             *  await Stream.WriteVInt(count);
             *  await Stream.WriteBuffer(buffer.ToArray());
             * }*/
            await Stream.WriteVInt(0);

            await Stream.WriteInt(0);

            await Stream.WriteInt(Utils.GetSecondsUntilNextMonth);
        }
Example #30
0
        public static void WriteTime(this Stream stream, TimeSpan value)
        {
            var milliseconds = (double)value.Ticks / TimeSpan.TicksPerMillisecond;
            var time         = (int)((milliseconds * Constants.Sql.RegularDateTime.TicksPerMillisecond) + 0.5);

            stream.WriteInt(time);
        }
        private static void WriteTDS_INTN(object value, Stream stream, FormatItem format, Encoding enc)
        {
            switch (value)
            {
            case byte b:
                stream.WriteByte(1);
                stream.WriteByte(b);
                break;

            case sbyte sb:
                stream.WriteByte(2);
                stream.WriteShort(sb);
                break;

            case short s:
                stream.WriteByte(2);
                stream.WriteShort(s);
                break;

            case int i:
                stream.WriteByte(4);
                stream.WriteInt(i);
                break;

            case long l:
                stream.WriteByte(8);
                stream.WriteLong(l);
                break;

            //case null:
            default:
                stream.WriteByte(0);
                break;
            }
        }
Example #32
0
 public override void Serialize(Stream stream, Type type, object value)
 {
     var array = value as Array;
     var elementType = type.GetElementType();
     stream.WriteInt(array.Length);
     for (int i = 0; i < array.Length; i++)
         ctx.Serializer.Serialize_Main(stream, elementType, array.GetValue(i));
 }
        public override void Serialize(Stream stream, Type type, object value)
        {
            var collection = (ICollection)value;
            Type elementType = GetElementType(type);
            stream.WriteInt(collection.Count);

            foreach (var item in collection)
                ctx.Serializer.Serialize_Main(stream, elementType, item);
        }
Example #34
0
 public static void Stream(IEnumerable<HashBlock> hashBlocks, Stream outputStream)
 {
     outputStream.WriteUInt((uint) hashBlocks.Count());
     foreach (HashBlock block in hashBlocks)
     {
         outputStream.Write(block.Hash, 0, 16);
         outputStream.WriteInt(block.Length);
         outputStream.WriteLong(block.Offset);
         outputStream.WriteUInt(block.Checksum);
     }
 }
Example #35
0
 private void SendByteDelta(ByteDelta delta, Stream inputStream, Stream outputStream)
 {
     outputStream.WriteByte(DeltaStreamConstants.NEW_BLOCK_START_MARKER);
     outputStream.WriteInt(delta.Length);
     var buffer = new byte[delta.Length];
     inputStream.Seek(delta.Offset, SeekOrigin.Begin);
     long totalRead = 0;
     while (totalRead < delta.Length)
     {
         var toRead = (int) MathEx.Bounded(0, StreamChunkSize, delta.Length - totalRead);
         int readLength = inputStream.Read(buffer, 0, toRead);
         if (readLength == 0 && totalRead < delta.Length)
             throw new IOException("Input stream offset out of bounds, or not enough data available");
         outputStream.Write(buffer, 0, readLength);
         totalRead += readLength;
     }
 }
Example #36
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (X);
     aStream.WriteByte (Y);
     aStream.WriteInt (Z);
     aStream.WriteByte ((byte)Direction);
     aStream.WriteShort (ItemID);
     if (ItemID >= 0) {
         aStream.WriteByte (Amount);
         aStream.WriteShort (Damage);
     }
 }
Example #37
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (X);
     aStream.WriteInt (Z);
     aStream.WriteBoolean(Mode);
 }
Example #38
0
 private void SendCopyDelta(CopyDelta delta, Stream inputStream, Stream outputStream)
 {
     if (inputStream.CanSeek == false) throw new IOException("inputStream not seekable");
     outputStream.WriteByte(DeltaStreamConstants.COPY_BLOCK_START_MARKER);
     outputStream.WriteLong(delta.Offset);
     outputStream.WriteInt(delta.Length);
     inputStream.Seek(delta.Length, SeekOrigin.Current);
 }
Example #39
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteByte (Animate);
 }
Example #40
0
        public override void WriteTo(Stream stream, bool writeType, bool writeName)
        {
            base.WriteTo(stream, writeType, writeName);

            stream.WriteByte(ItemType);
            stream.WriteInt(Length);

            for (int i = 0; i < Length; ++i)
            {
                Items[i].WriteTo(stream, false, false);
            }
        }
Example #41
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteShort(VelX);
     aStream.WriteShort (VelY);
     aStream.WriteShort (VelZ);
 }
Example #42
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     // write ID
     aStream.WriteInt (EntityID);
     aStream.WriteString16 (UserName);
     aStream.WriteLong (0);
     aStream.WriteByte (0);
 }
Example #43
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteByte ((byte)Status);
     aStream.WriteInt (X);
     aStream.WriteByte (Y);
     aStream.WriteInt (Z);
     aStream.WriteByte ((byte)Face);
 }
Example #44
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt(VehicleID);
 }
Example #45
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
 }
Example #46
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteShort (Slot);
     aStream.WriteShort (ItemID);
     aStream.WriteShort (Damage);
 }
Example #47
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (CollectedEID);
     aStream.WriteInt (CollectorEID);
 }
Example #48
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (UserID);
     aStream.WriteInt (TargetID);
     aStream.WriteBoolean (LeftClick);
 }
Example #49
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteByte (InBed);
     aStream.WriteInt (X);
     aStream.WriteByte (Y);
     aStream.WriteInt (Z);
 }
Example #50
0
        /// <summary>
        /// Writes the query parameters.
        /// </summary>
        /// <param name="buffer">The buffer.</param>
        protected void WriteQueryParameters(Stream buffer)
        {
            buffer.WriteConsistency(CqlConsistency);

            var flags = (byte)((Parameters != null ? 1 : 0) |
                               (SkipMetaData ? 2 : 0) |
                               (PageSize.HasValue ? 4 : 0) |
                               (PagingState != null ? 8 : 0) |
                               (SerialConsistency.HasValue ? 16 : 0) |
                               (ProtocolVersion >= 3 && Timestamp.HasValue ? 32 : 0));

            buffer.WriteByte(flags);

            if(Parameters != null)
            {
                buffer.WriteShort((ushort)Parameters.Count);
                foreach(var value in Parameters)
                    buffer.WriteByteArray(value);
            }

            if(PageSize.HasValue)
                buffer.WriteInt(PageSize.Value);

            if(PagingState != null)
                buffer.WriteByteArray(PagingState);

            if(SerialConsistency.HasValue)
                buffer.WriteShort((ushort)SerialConsistency.Value);

            if(ProtocolVersion >= 3 && Timestamp.HasValue)
                buffer.WriteLong(Timestamp.Value.ToTimestamp()*1000); //convert milliseconds to microseconds
        }
Example #51
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteString16 (Title);
     aStream.WriteInt (X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
     aStream.WriteInt (Direction);
 }
Example #52
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt(X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
     aStream.WriteByte (Yaw);
     aStream.WriteByte (Pitch);
 }
Example #53
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteShort (ItemID);
     aStream.WriteByte (Count);
     aStream.WriteShort (DamageData);
     aStream.WriteInt (X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
     aStream.WriteByte (Rotation);
     aStream.WriteByte (Pitch);
     aStream.WriteByte (Roll);
 }
Example #54
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteInt (EntityID);
     aStream.WriteString16 (PlayerName);
     aStream.WriteInt (X);
     aStream.WriteInt (Y);
     aStream.WriteInt (Z);
     aStream.WriteByte (Rotation);
     aStream.WriteByte (Pitch);
     aStream.WriteShort (CurrentItem);
 }
Example #55
0
 void EncodeDisp32(Stream buffer, byte constant)
 {
     if (indexReg != null) {
     buffer.WriteByte (CombineModRM (MOD_R32_PTR_DISP32, 0x04, constant));
     buffer.WriteByte (CombineSib (baseReg.Index, indexReg.Index, scale));
     } else {
     buffer.WriteByte (CombineModRM (MOD_R32_PTR_DISP32, baseReg.Index, constant));
     if (baseReg == ESP)
         buffer.WriteByte (0x24);
     }
     buffer.WriteInt (disp);
 }