public override void StrongSerialize(Stream stream, Vector4 value)
 {
     stream.WriteFloat(value.x);
     stream.WriteFloat(value.y);
     stream.WriteFloat(value.z);
     stream.WriteFloat(value.w);
 }
Beispiel #2
0
 public static void WriteColor(this Stream fs, Color value)
 {
     fs.WriteFloat(value.r);
     fs.WriteFloat(value.g);
     fs.WriteFloat(value.b);
     fs.WriteFloat(value.a);
 }
Beispiel #3
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteFloat(Yaw);
     aStream.WriteFloat(Pitch);
     aStream.WriteBoolean(OnGround);
 }
Beispiel #4
0
 public static void WriteRect(this Stream fs, Rect rect)
 {
     fs.WriteFloat(rect.x);
     fs.WriteFloat(rect.y);
     fs.WriteFloat(rect.width);
     fs.WriteFloat(rect.height);
 }
Beispiel #5
0
 public static void WriteQuaternion(this Stream fs, Quaternion value)
 {
     fs.WriteFloat(value.x);
     fs.WriteFloat(value.y);
     fs.WriteFloat(value.z);
     fs.WriteFloat(value.w);
 }
 public static void Write(Stream stream, Color value)
 {
     stream.WriteFloat(value.r);
     stream.WriteFloat(value.g);
     stream.WriteFloat(value.b);
     stream.WriteFloat(value.a);
 }
Beispiel #7
0
 public override void Serialize(Stream stream, GameStateSerializer serializer)
 {
     stream.WriteStruct(spawnCooldown);
     stream.WriteStruct(surfingSpawnCooldown);
     stream.WriteFloat(surfingSpawnCooldownNonRounded);
     stream.WriteFloat(penguinDurationBonus);
     stream.WriteFloat(penguinDestroyBonus);
     base.Serialize(stream, serializer);
 }
Beispiel #8
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream(aStream);
     aStream.WriteFloat(A);
     aStream.WriteFloat(B);
     aStream.WriteBoolean(C);
     aStream.WriteBoolean(D);
     aStream.WriteFloat(E);
     aStream.WriteFloat(F);
 }
Beispiel #9
0
        /// <summary>
        /// Save StatValue data to stream
        /// </summary>
        /// <param name="stream"></param>
        public void Save(Stream stream)
        {
            damageType.Save(stream);
            stream.WriteStringPacket(value);
            stream.WriteStringPacket(maximum);
            stream.WriteFloat(curBaseValue);
            stream.WriteFloat(curBaseMax);
            stream.WriteFloat(curValue);
            stream.WriteFloat(curMax);
            stream.WriteInt(ActiveModifiers.Count);

            foreach (StatModifier modifier in ActiveModifiers)
            {
                modifier.Save(stream);
            }
        }
        public static void WriteFloatProperty(this Stream stream, IMEPackage pcc, string propName, float value)
        {
            //Debug.WriteLine("Writing float property " + propName + ", value: " + value + " at 0x" + stream.Position.ToString("X6"));

            stream.WritePropHeader(pcc, propName, PropertyType.FloatProperty, 4);
            stream.WriteFloat(value);
        }
Beispiel #11
0
 public override void OnValue <T>(T obj)
 {
     if (obj is bool)
     {
         Stream.WriteUInt8(Convert.ToByte(obj));
     }
     else if (obj is char)
     {
         Stream.WriteUInt8(Convert.ToByte(obj));
     }
     else if (obj is short)
     {
         Stream.WriteVarUInt16(IntegerHelper.EncodeZigzag(Convert.ToInt16(obj)));
     }
     else if (obj is int)
     {
         Stream.WriteVarUInt32(IntegerHelper.EncodeZigzag(Convert.ToInt32(obj)));
     }
     else if (obj is Int64)
     {
         Stream.WriteVarUInt64(IntegerHelper.EncodeZigzag(Convert.ToInt64(obj)));
     }
     else if (obj is byte)
     {
         Stream.WriteUInt8(Convert.ToByte(obj));
     }
     else if (obj is ushort)
     {
         Stream.WriteVarUInt16(Convert.ToUInt16(obj));
     }
     else if (obj is uint)
     {
         Stream.WriteVarUInt32(Convert.ToUInt32(obj));
     }
     else if (obj is UInt64)
     {
         Stream.WriteVarUInt64(Convert.ToUInt64(obj));
     }
     else if (obj is float)
     {
         Stream.WriteFloat((float)Convert.ToDouble(obj));
     }
     else if (obj is double)
     {
         Stream.WriteDouble(Convert.ToDouble(obj));
     }
     else
     {
         var type = obj.GetType();
         if (type.IsEnum)
         {
             Stream.WriteVarUInt32(Convert.ToUInt32(obj));
         }
         else
         {
             Console.WriteLine("Invalid value:{0} in type:{1}", obj, obj.GetType());
         }
     }
 }
 public static void WriteFloatArray(this Stream s, float[] inputData)
 {
     s.WriteInt32(inputData.Length);
     foreach (float element in inputData)
     {
         s.WriteFloat(element);
     }
 }
 /// <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());
 }
        public static void WritePrimitiveOrStringType(this Stream stream, object obj)
        {
            Type t = obj.GetType();

            if (t == typeof(Byte))
            {
                stream.WriteByte((byte)obj);
            }
            else if (t == typeof(Boolean))
            {
                stream.WriteBool((bool)obj);
            }
            else if (t == typeof(short))
            {
                stream.WriteInt16((short)obj);
            }
            else if (t == typeof(ushort))
            {
                stream.WriteUInt16((ushort)obj);
            }
            else if (t == typeof(int))
            {
                stream.WriteInt32((int)obj);
            }
            else if (t == typeof(uint))
            {
                stream.WriteUInt32((uint)obj);
            }
            else if (t == typeof(long))
            {
                stream.WriteInt64((long)obj);
            }
            else if (t == typeof(ulong))
            {
                stream.WriteUInt64((ulong)obj);
            }
            else if (t == typeof(float))
            {
                stream.WriteFloat((float)obj);
            }
            else if (t == typeof(double))
            {
                stream.WriteDouble((double)obj);
            }
            else if (t == typeof(string))
            {
                stream.WriteStringWithLength((string)obj);
            }
            else
            {
                throw new NotImplementedException();
            }
        }
Beispiel #15
0
        private static void WritePrimitiveData(Stream s, SerializeTypeEnum type, object val)
        {
            switch (type)
            {
            case SerializeTypeEnum.Bool:
                s.WriteBool((bool)val);
                break;

            case SerializeTypeEnum.Byte:
                s.WriteByte((byte)val);
                break;

            case SerializeTypeEnum.Double:
                s.WriteDouble((Double)val);
                break;

            case SerializeTypeEnum.Float:
                s.WriteFloat((float)val);
                break;

            case SerializeTypeEnum.Int16:
                s.WriteInt16((Int16)val);
                break;

            case SerializeTypeEnum.Int32:
                s.WriteInt32((Int32)val);
                break;

            case SerializeTypeEnum.Int64:
                s.WriteInt64((Int64)val);
                break;

            case SerializeTypeEnum.UInt16:
                s.WriteUInt16((UInt16)val);
                break;

            case SerializeTypeEnum.UInt32:
                s.WriteUInt32((UInt32)val);
                break;

            case SerializeTypeEnum.UInt64:
                s.WriteUInt64((UInt64)val);
                break;

            case SerializeTypeEnum.String:
                s.WriteString((string)val, Encoding.ASCII);
                break;

            default:
                throw new Exception();
            }
        }
Beispiel #16
0
        /// <summary>
        /// Save state to filestream
        /// </summary>
        /// <param name="stream"></param>
        public void Save(Stream stream)
        {
            // Write file format version
            stream.WriteFloat(1.4f);

            foreach (StatValue stat in Stats)
            {
                stat.Save(stream);
            }

            stream.WriteInt(damageModifiers.Count);
            foreach (DamageModifier damageModifier in damageModifiers)
            {
                damageModifier.Save(stream);
            }

            stream.WriteInt(Effects.Count);
            foreach (StatEffect effect in Effects)
            {
                stream.WriteStringPacket(effect.name);
                stream.WriteFloat(effect.RemainingTime);
            }
        }
        private static void WriteTDS_FLTN(object value, Stream stream, FormatItem format, Encoding enc)
        {
            switch (value)
            {
            case float f:
                stream.WriteByte(4);
                stream.WriteFloat(f);
                break;

            case double d:
                stream.WriteByte(8);
                stream.WriteDouble(d);
                break;

            default:
                stream.WriteByte(0);
                break;
            }
        }
 private static void WriteTDS_FLT4(object value, Stream stream, FormatItem format, Encoding enc)
 {
     stream.WriteFloat(Cast <float>(value, format, enc));
 }
Beispiel #19
0
 public override void WriteToStream(Stream aStream)
 {
     aStream.WriteFloat(Value);
 }
        public static void Write(object value, Stream stream, FormatItem format, Encoding enc)
        {
            switch (format.DataType)
            {
            case TdsDataType.TDS_BIT:
                switch (value)
                {
                case bool b:
                    stream.WriteBool(b);
                    break;

                default:
                    stream.WriteByte(0);
                    break;
                }
                break;

            case TdsDataType.TDS_INT1:
                stream.WriteByte(Cast <byte>(value, format));
                break;

            //no TDS_SINT1, we will transmit as an INTN(2)
            case TdsDataType.TDS_INT2:
                stream.WriteShort(Cast <short>(value, format));
                break;

            case TdsDataType.TDS_UINT2:
                stream.WriteUShort(Cast <ushort>(value, format));
                break;

            case TdsDataType.TDS_INT4:
                stream.WriteInt(Cast <int>(value, format));
                break;

            case TdsDataType.TDS_UINT4:
                stream.WriteUInt(Cast <uint>(value, format));
                break;

            case TdsDataType.TDS_INT8:
                stream.WriteLong(Cast <long>(value, format));
                break;

            case TdsDataType.TDS_UINT8:
                stream.WriteULong(Cast <ulong>(value, format));
                break;

            case TdsDataType.TDS_INTN:
                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;
                }
                break;

            case TdsDataType.TDS_UINTN:
                switch (value)
                {
                case byte b:
                    stream.WriteByte(1);
                    stream.WriteByte(b);
                    break;

                case ushort s:
                    stream.WriteByte(2);
                    stream.WriteUShort(s);
                    break;

                case uint i:
                    stream.WriteByte(4);
                    stream.WriteUInt(i);
                    break;

                case ulong l:
                    stream.WriteByte(8);
                    stream.WriteULong(l);
                    break;

                //case null:
                default:
                    stream.WriteByte(0);
                    break;
                }
                break;

            case TdsDataType.TDS_FLT4:
                stream.WriteFloat(Cast <float>(value, format));
                break;

            case TdsDataType.TDS_FLT8:
                stream.WriteDouble(Cast <double>(value, format));
                break;

            case TdsDataType.TDS_FLTN:
                switch (value)
                {
                case float f:
                    stream.WriteByte(4);
                    stream.WriteFloat(f);
                    break;

                case double d:
                    stream.WriteByte(8);
                    stream.WriteDouble(d);
                    break;

                default:
                    stream.WriteByte(0);
                    break;
                }
                break;

            case TdsDataType.TDS_VARCHAR:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteBytePrefixedString(Cast <string>(value, format), enc);
                }
                break;

            case TdsDataType.TDS_LONGCHAR:
                if (!stream.TryWriteIntPrefixedNull(value))
                {
                    stream.WriteIntPrefixedString(Cast <string>(value, format), enc);
                }
                break;

            case TdsDataType.TDS_VARBINARY:
            case TdsDataType.TDS_BINARY:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteBytePrefixedByteArray(Cast <byte[]>(value, format));
                }
                break;

            case TdsDataType.TDS_LONGBINARY:
                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;
                    }
                }
                break;

            case TdsDataType.TDS_DECN:
            case TdsDataType.TDS_NUMN:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    switch (value)
                    {
                    case AseDecimal ad:
                        stream.WriteDecimal(ad);
                        break;

                    default:
                        stream.WriteDecimal(Cast <decimal>(value, format));
                        break;
                    }
                }
                break;

            case TdsDataType.TDS_DATETIME:
                stream.WriteIntPartDateTime(Cast <DateTime>(value, format));
                break;

            case TdsDataType.TDS_DATETIMEN:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteIntPartDateTime(Cast <DateTime>(value, format));
                }
                break;

            case TdsDataType.TDS_DATE:
                stream.WriteDate(Cast <DateTime>(value, format));
                break;

            case TdsDataType.TDS_DATEN:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteDate(Cast <DateTime>(value, format));
                }
                break;

            case TdsDataType.TDS_TIME:
                stream.WriteTime(Cast <TimeSpan>(value, format));
                break;

            case TdsDataType.TDS_TIMEN:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteTime(Cast <TimeSpan>(value, format));
                }
                break;

            case TdsDataType.TDS_MONEYN:
                if (!stream.TryWriteBytePrefixedNull(value))
                {
                    stream.WriteMoney(Cast <decimal>(value, format));
                }
                break;

            default:
                Debug.Assert(false, $"Unsupported data type {format.DataType}");
                break;
            }
        }
 public static void Write(Stream stream, Vector3 value)
 {
     stream.WriteFloat(value.x);
     stream.WriteFloat(value.y);
     stream.WriteFloat(value.z);
 }
 public override void WriteBack(Stream s)
 {
     s.WriteFloat(Value);
 }
Beispiel #23
0
        private static void WritePrimitiveDataArray(Stream s, SerializeTypeEnum type, Array tval)
        {
            switch (type)
            {
            case SerializeTypeEnum.Bool:
            {
                var val = tval as bool[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteBool(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.Byte:
            {
                var val = tval as byte[];
                s.Write(val, 0, val.Length);
            }
            break;

            case SerializeTypeEnum.Double:
            {
                var val = tval as double[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteDouble(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.Float:
            {
                var val = tval as float[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteFloat(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.Int16:
            {
                var val = tval as Int16[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteInt16(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.Int32:
            {
                var val = tval as Int32[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteInt32(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.Int64:
            {
                var val = tval as Int64[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteInt64(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.UInt16:
            {
                var val = tval as UInt16[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteUInt16(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.UInt32:
            {
                var val = tval as UInt32[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteUInt32(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.UInt64:
            {
                var val = tval as UInt64[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteUInt64(val[i]);
                }
            }
            break;

            case SerializeTypeEnum.String:
            {
                var val = tval as string[];
                for (var i = 0; i < val.Length; i++)
                {
                    s.WriteString(val[i], Encoding.UTF8);
                }
            }
            break;

            default:
                throw new Exception();
            }
        }
Beispiel #24
0
        /// <summary>
        /// Save StatValue data to stream
        /// </summary>
        /// <param name="stream"></param>
        public void Save(Stream stream)
        {
            stream.WriteStringPacket(name);
            stream.WriteFloat(curBaseValue);
            stream.WriteFloat(curBaseMin);
            stream.WriteFloat(curBaseMax);
            stream.WriteFloat(curBaseRegenAmount);
            stream.WriteFloat(curBaseRegenDelay);
            stream.WriteFloat(curValue);
            stream.WriteFloat(curMin);
            stream.WriteFloat(curMax);
            stream.WriteFloat(curRegenAmount);
            stream.WriteFloat(curRegenDelay);
            stream.WriteFloat(nextRegen);
            stream.WriteInt(ActiveModifiers.Count);

            foreach (StatModifier modifier in ActiveModifiers)
            {
                modifier.Save(stream);
            }
        }
Beispiel #25
0
 public override void WriteToStream(Stream aStream)
 {
     base.WriteToStream (aStream);
     aStream.WriteFloat(A);
     aStream.WriteFloat (B);
     aStream.WriteBoolean (C);
     aStream.WriteBoolean (D);
     aStream.WriteFloat (E);
     aStream.WriteFloat (F);
 }
Beispiel #26
0
        public override void WriteToStream(Stream aStream)
        {
            base.WriteToStream (aStream);

            aStream.WriteDouble (X);
            aStream.WriteDouble (Stance);
            aStream.WriteDouble (Y);
            aStream.WriteDouble (Z);
            aStream.WriteFloat (Yaw);
            aStream.WriteFloat (Pitch);
            aStream.WriteBoolean (OnGround);
        }
Beispiel #27
0
 public static void WriteVector3(this Stream fs, Vector3 value)
 {
     fs.WriteFloat(value.x);
     fs.WriteFloat(value.y);
     fs.WriteFloat(value.z);
 }
 public override void WriteBack(Stream s)
 {
     s.WriteFloat(X);
     s.WriteFloat(Y);
 }