// websocket数据解包 public byte[] AnalyticData(byte[] recBytes, int recByteLength) { if (recByteLength < 2) { return(null); } bool fin = (recBytes[0] & 0x80) == 0x80; // 1bit,1表示最后一帧 if (!fin) { return(null);// 超过一帧暂不处理 } bool mask_flag = (recBytes[1] & 0x80) == 0x80; // 是否包含掩码 if (!mask_flag) { return(null);// 不包含掩码的暂不处理 } int payload_len = recBytes[1] & 0x7F; // 数据长度 byte[] masks = new byte[4]; byte[] messageData; if (payload_len == 126) { Array.Copy(recBytes, 4, masks, 0, 4); payload_len = (ushort)(recBytes[2] << 8 | recBytes[3]); messageData = new byte[payload_len]; Array.Copy(recBytes, 8, messageData, 0, payload_len); } else if (payload_len == 127) { Array.Copy(recBytes, 10, masks, 0, 4); byte[] uInt64Bytes = new byte[8]; for (int i = 0; i < 8; i++) { uInt64Bytes[i] = recBytes[9 - i]; } ulong len = BitConverter.ToUInt64(uInt64Bytes, 0); messageData = new byte[len]; for (ulong i = 0; i < len; i++) { messageData[i] = recBytes[i + 14]; } } else { Array.Copy(recBytes, 2, masks, 0, 4); messageData = new byte[payload_len]; Array.Copy(recBytes, 6, messageData, 0, payload_len); } for (var i = 0; i < payload_len; i++) { messageData[i] = (byte)(messageData[i] ^ masks[i % 4]); } return(messageData); }
private static MovementInfo ReadMovementUpdateBlock(Packet packet, WowGuid guid, object index) { var moveInfo = new MovementInfo(); var guid1 = new byte[8]; var transportGuid = new byte[8]; var goTransportGuid = new byte[8]; var attackingTargetGuid = new byte[8]; var guid5 = new byte[8]; var guid6 = new byte[8]; var guid7 = new byte[8]; var bit160 = false; var bit528 = false; var bit600 = false; var bit544 = false; var bit526 = false; var bit552 = false; var bit524 = false; var bit572 = false; var bit525 = false; var bit664 = false; var bit527 = false; var bit536 = false; var bit644 = false; var bit560 = false; var hasAnimKit1 = false; var hasAnimKit2 = false; var hasAnimKit3 = false; var hasFullSpline = false; var hasSplineStartTime = false; var hasSplineVerticalAcceleration = false; var hasMovementFlags = false; var hasMoveFlagsExtra = false; var hasTimestamp = false; var hasOrientation = false; var hasTransportData = false; var hasTransportTime2 = false; var hasTransportTime3 = false; var hasGOTransportTime2 = false; var hasGOTransportTime3 = false; var hasPitch = false; var hasFallData = false; var hasFallDirection = false; var hasSplineElevation = false; var bits168 = 0u; var splineCount = 0u; var bits138 = 0u; var bits98 = 0u; var bits25C = 0u; var bits26C = 0u; var bits288 = 0u; var bits418 = 0u; var bits2AA = 0u; var splineType = SplineType.Stop; var bit676 = packet.ReadBit("bit676", index); var hasAnimKits = packet.ReadBit("Has Anim Kits", index); // 498 var isLiving = packet.ReadBit("Is Living", index); // 368 var bit810 = packet.ReadBit("bit810", index); packet.ReadBit(); //fake bit var transportFrames = packet.ReadBits("Transport Frames Count", 22, index); // 1068 var hasVehicleData = packet.ReadBit("Has Vehicle Data", index); // 488 var bit1044 = packet.ReadBit("bit1044", index); packet.ReadBit(); //fake bit var bit476 = packet.ReadBit("bit476", index); var hasGameObjectRotation = packet.ReadBit("Has GameObject Rotation", index); // 512 packet.ReadBit(); //fake bit var bit680 = packet.ReadBit("bit680", index); var hasAttackingTarget = packet.ReadBit("Has Attacking Target", index); // 464 var hasSceneObjectData = packet.ReadBit("Has Scene Object Data", index); // 1032 var bit1064 = packet.ReadBit("bit1064", index); packet.ReadBit(); //fake bit var bit668 = packet.ReadBit("bit668", index); var hasTransportPosition = packet.ReadBit("Has Transport Position", index); // 424 var bit681 = packet.ReadBit("bit681", index); var hasStationaryPosition = packet.ReadBit("Has Stationary Position", index); // 448 if (isLiving) { guid1[2] = packet.ReadBit(); var bit140 = packet.ReadBit(); hasPitch = !packet.ReadBit("Has Pitch", index); //104 hasTransportData = packet.ReadBit("Has Transport Data", index); //96 packet.ReadBit(); // 164 fake bit if (hasTransportData) { transportGuid[4] = packet.ReadBit(); transportGuid[2] = packet.ReadBit(); hasTransportTime3 = packet.ReadBit(); transportGuid[0] = packet.ReadBit(); transportGuid[1] = packet.ReadBit(); transportGuid[3] = packet.ReadBit(); transportGuid[6] = packet.ReadBit(); transportGuid[7] = packet.ReadBit(); hasTransportTime2 = packet.ReadBit(); transportGuid[5] = packet.ReadBit(); } hasTimestamp = !packet.ReadBit(); guid1[6] = packet.ReadBit(); guid1[4] = packet.ReadBit(); guid1[3] = packet.ReadBit(); hasOrientation = !packet.ReadBit(); //40 bit160 = !packet.ReadBit(); guid1[5] = packet.ReadBit(); bits98 = packet.ReadBits("bits98", 22, index); //144 hasMovementFlags = !packet.ReadBit(); bits168 = packet.ReadBits(19); //352 /*var bits356 = new uint[bits168]; * for (var i = 0; i < bits168; ++i) * { * bits356[i] = packet.ReadBits(2); * }*/ hasFallData = packet.ReadBit(); //132 if (hasMovementFlags) { moveInfo.Flags = (uint)packet.ReadBitsE <MovementFlag>("Movement Flags", 30, index); } hasSplineElevation = !packet.ReadBit("Has SplineElevation", index);//136 moveInfo.HasSplineData = packet.ReadBit("Has SplineData", index); var bit141 = packet.ReadBit(); guid1[0] = packet.ReadBit(); guid1[7] = packet.ReadBit(); guid1[1] = packet.ReadBit(); if (moveInfo.HasSplineData) { hasFullSpline = packet.ReadBit(); if (hasFullSpline) { hasSplineVerticalAcceleration = packet.ReadBit(); //260 hasSplineStartTime = packet.ReadBit(); //252 var bit304 = packet.ReadBit(); splineCount = packet.ReadBits(20); packet.ReadBitsE <SplineMode>("Spline Mode", 2, index); packet.ReadBitsE <SplineFlag434>("Spline flags", 25, index); if (bit304) { bits138 = packet.ReadBits(21); packet.ReadBits(2); } } } hasMoveFlagsExtra = !packet.ReadBit(); //20 if (hasFallData) { hasFallDirection = packet.ReadBit(); //128 } if (hasMoveFlagsExtra) { moveInfo.Flags2 = (uint)packet.ReadBitsE <MovementFlag2>("Extra Movement Flags", 13, index); } } /*if (hasSceneObjectData) * { * * }*/ if (hasTransportPosition) //424 { packet.StartBitStream(goTransportGuid, 4, 1, 0); hasGOTransportTime2 = packet.ReadBit(); // 420 packet.StartBitStream(goTransportGuid, 6, 5, 3, 2, 7); hasGOTransportTime3 = packet.ReadBit(); // 412 } if (bit668) { bit528 = packet.ReadBit(); bit600 = packet.ReadBit(); bit544 = packet.ReadBit(); bit526 = packet.ReadBit(); bit552 = packet.ReadBit(); bit524 = packet.ReadBit(); bit572 = packet.ReadBit(); bit525 = packet.ReadBit(); bit664 = packet.ReadBit(); bit527 = packet.ReadBit(); if (bit664) { bits288 = packet.ReadBits(20); } bit536 = packet.ReadBit(); bit644 = packet.ReadBit(); bit560 = packet.ReadBit(); if (bit664) { bits25C = packet.ReadBits(21); //604 bits26C = packet.ReadBits(21); //624 } } if (hasAnimKits) { hasAnimKit2 = !packet.ReadBit(); hasAnimKit3 = !packet.ReadBit(); hasAnimKit1 = !packet.ReadBit(); } if (hasAttackingTarget) { attackingTargetGuid = packet.StartBitStream(4, 6, 5, 2, 0, 1, 3, 7); } if (bit1064) { bits418 = packet.ReadBits(22); } if (bit810) { bits2AA = packet.ReadBits(7); } packet.ResetBitReader(); for (var i = 0; i < transportFrames; ++i) { packet.ReadInt32("Transport frame", index, i); } /*if (hasSceneObjectData) * { * until if ( *(_BYTE *)(v3 + 668) ) * }*/ if (isLiving) { if (hasTransportData) //96 { moveInfo.Transport = new MovementInfo.TransportInfo(); packet.ReadXORByte(transportGuid, 7); moveInfo.Transport.Offset.X = packet.ReadSingle(); if (hasTransportTime3) { packet.ReadUInt32("Transport Time 3", index); } moveInfo.Transport.Offset.O = packet.ReadSingle(); moveInfo.Transport.Offset.Y = packet.ReadSingle(); packet.ReadXORByte(transportGuid, 4); packet.ReadXORByte(transportGuid, 1); packet.ReadXORByte(transportGuid, 3); moveInfo.Transport.Offset.Z = packet.ReadSingle(); packet.ReadXORByte(transportGuid, 5); if (hasTransportTime2) { packet.ReadUInt32("Transport Time 2", index); } packet.ReadXORByte(transportGuid, 0); var seat = packet.ReadSByte("Transport Seat", index); //72 packet.ReadXORByte(transportGuid, 6); packet.ReadXORByte(transportGuid, 2); packet.ReadUInt32("Transport Time", index); //76 moveInfo.Transport.Guid = new WowGuid64(BitConverter.ToUInt64(transportGuid, 0)); packet.AddValue("Transport GUID", moveInfo.Transport.Guid, index); packet.AddValue("Transport Position", moveInfo.Transport.Offset, index); if (moveInfo.Transport.Guid.HasEntry() && moveInfo.Transport.Guid.GetHighType() == HighGuidType.Vehicle && guid.HasEntry() && guid.GetHighType() == HighGuidType.Creature) { VehicleTemplateAccessory vehicleAccessory = new VehicleTemplateAccessory { Entry = moveInfo.Transport.Guid.GetEntry(), AccessoryEntry = guid.GetEntry(), SeatId = seat }; Storage.VehicleTemplateAccessories.Add(vehicleAccessory, packet.TimeSpan); } } packet.ReadXORByte(guid1, 4); /*for (var i = 0; i < 10; ++i) * packet.ReadSingle("unk float"); * if (bits98 > 0) * packet.ReadBits((int)bits98);*/ //for (var i = 0; i < bits98; ++i) // packet.ReadInt32("Int9C", index, i); if (moveInfo.HasSplineData) //344 { if (hasFullSpline) //336 { packet.ReadUInt32("Spline Time", index); //232 packet.ReadSingle("Duration Mod Next", index); //244 // NYI block here packet.ReadSingle("Duration Mod", index); //240 for (uint i = 0; i < splineCount; i++) { Vector3 v = new Vector3(); v.X = packet.ReadSingle(); //0 v.Z = packet.ReadSingle(); //8 v.Y = packet.ReadSingle(); //4 packet.AddValue("Spline", v, index); } if (hasSplineStartTime) { packet.ReadUInt32("Spline Start time", index); //256 } var type = packet.ReadByte(); // 228 switch (type) { case 1: splineType = SplineType.Normal; break; case 2: splineType = SplineType.FacingSpot; break; case 3: splineType = SplineType.FacingTarget; break; case 4: splineType = SplineType.FacingAngle; break; } if (splineType == SplineType.FacingAngle) // == 4 { packet.ReadSingle("Facing Angle", index); } if (splineType == SplineType.FacingSpot) // == 2 { packet.ReadVector3("Facing spot", index); } if (hasSplineVerticalAcceleration) //252 { packet.ReadSingle("Spline Vertical Acceleration", index); } packet.ReadUInt32("Spline FULL Time", index); //236 } moveInfo.Position.X = packet.ReadSingle(); //212 moveInfo.Position.Z = packet.ReadSingle(); //220 packet.ReadUInt32("Spline ID", index); //208 moveInfo.Position.Y = packet.ReadSingle(); //216 } packet.ReadSingle("Fly Speed", index); //188 if (bit160) { packet.ReadUInt32("unk160"); } packet.ReadXORByte(guid1, 2); if (hasFallData) //132 { if (hasFallDirection) //128 { packet.ReadSingle("Jump Sin Angle", index); //124 packet.ReadSingle("Jump XY Speed", index); //116 packet.ReadSingle("Jump Cos Angle", index); //120 } packet.ReadUInt32("Jump Fall Time", index); //108 packet.ReadSingle("Jump Z Speed", index); //112 } packet.ReadXORByte(guid1, 1); packet.ReadSingle("Turn Speed", index); if (hasTimestamp) { packet.ReadUInt32("Time?", index); } packet.ReadSingle("Swim Speed", index); //176 if (hasSplineElevation) //136 { packet.ReadSingle("Spline Elevation", index); //196 } packet.ReadXORByte(guid1, 7); packet.ReadSingle("Pitch Speed", index); //200 for (var i = 0; i < bits98; ++i) { packet.ReadInt32("UNK counter", index, i); } moveInfo.Position.X = packet.ReadSingle(); //28 if (hasPitch) { packet.ReadSingle("Pitch", index); //104 } if (hasOrientation) { moveInfo.Orientation = packet.ReadSingle("Orientation", index); //40 } moveInfo.WalkSpeed = packet.ReadSingle("Walk Speed", index) / 2.5f; // 168 moveInfo.Position.Y = packet.ReadSingle(); //32 packet.ReadSingle("Fly Back Speed", index); //192 packet.ReadXORByte(guid1, 3); packet.ReadXORByte(guid1, 5); packet.ReadXORByte(guid1, 6); packet.ReadXORByte(guid1, 0); packet.ReadSingle("Run Back Speed", index); //184 moveInfo.RunSpeed = packet.ReadSingle("Run Speed", index) / 7.0f; //172 packet.ReadSingle("Swim Back Speed", index); //180 moveInfo.Position.Z = packet.ReadSingle(); //36 } packet.AddValue("Position", moveInfo.Position, index); if (bit668) { if (bit664) { for (var i = 0; i < bits288; ++i) { packet.ReadSingle("Float652+4", index, i); packet.ReadSingle("Float652", index, i); packet.ReadSingle("Float652+8", index, i); } } if (bit600) { packet.ReadSingle("Float584", index); packet.ReadSingle("Float580", index); packet.ReadSingle("Float596", index); packet.ReadSingle("Float592", index); packet.ReadSingle("Float576", index); packet.ReadSingle("Float588", index); } if (bit644) { for (var i = 0; i < bits25C; ++i) { packet.ReadSingle("Float608", index, i); packet.ReadSingle("Float608+4", index, i); } for (var i = 0; i < bits26C; ++i) { packet.ReadSingle("Float260+0", index, i); packet.ReadSingle("Float260+1", index, i); } packet.ReadSingle("Float624", index); packet.ReadSingle("Float624+4", index); } packet.ReadUInt32("unk520", index); if (bit544) { packet.ReadUInt32("unk544", index); } if (bit552) { packet.ReadUInt32("unk548", index); } if (bit536) { packet.ReadUInt32("unk532", index); } if (bit560) { packet.ReadUInt32("unk556", index); } if (bit572) { packet.ReadSingle("Float564", index); packet.ReadSingle("Float568", index); } } if (hasTransportPosition) { moveInfo.Transport = new MovementInfo.TransportInfo(); if (hasGOTransportTime2) { packet.ReadUInt32("Transport Time 2", index); } moveInfo.Transport.Offset.Y = packet.ReadSingle(); //388 packet.ReadSByte("Transport Seat", index); //400 moveInfo.Transport.Offset.X = packet.ReadSingle(); //384 packet.ReadXORBytes(goTransportGuid, 2, 4, 1); if (hasGOTransportTime3) { packet.ReadUInt32("Transport Time 3", index); //412 } packet.ReadUInt32("Transport Time", index); //404 moveInfo.Transport.Offset.O = packet.ReadSingle(); //396 moveInfo.Transport.Offset.Z = packet.ReadSingle(); //392 packet.ReadXORBytes(goTransportGuid, 6, 0, 5, 3, 7); moveInfo.Transport.Guid = new WowGuid64(BitConverter.ToUInt64(goTransportGuid, 0)); packet.AddValue("Transport GUID", moveInfo.Transport.Guid, index); packet.AddValue("Transport Position", moveInfo.Transport.Offset, index); } if (hasAttackingTarget) { packet.ParseBitStream(attackingTargetGuid, 7, 1, 5, 2, 6, 3, 0, 4); packet.WriteGuid("Attacking Target GUID", attackingTargetGuid, index); } if (hasVehicleData) { moveInfo.VehicleId = packet.ReadUInt32("Vehicle Id", index); packet.ReadSingle("Vehicle Orientation", index); } if (hasStationaryPosition) { moveInfo.Position.Y = packet.ReadSingle(); moveInfo.Position.Z = packet.ReadSingle(); moveInfo.Orientation = packet.ReadSingle("Stationary Orientation", index); moveInfo.Position.X = packet.ReadSingle(); packet.AddValue("Stationary Position", moveInfo.Position, index); } if (bit676) { packet.ReadUInt32("unk672"); } if (hasAnimKits) { if (hasAnimKit1) { packet.ReadUInt16("Anim Kit 1", index); } if (hasAnimKit3) { packet.ReadUInt16("Anim Kit 3", index); } if (hasAnimKit2) { packet.ReadUInt16("Anim Kit 2", index); } } if (bit810) { packet.ReadBytes("Bytes", (int)bits2AA); } if (bit476) { packet.ReadUInt32("unk472"); } if (bit1064) { for (var i = 0; i < bits418; ++i) { packet.ReadInt32("unk1052+4", index, i); } } if (hasGameObjectRotation) { moveInfo.Rotation = packet.ReadPackedQuaternion("GameObject Rotation", index); } if (bit1044) { packet.ReadInt32("unk1040", index); } if (isLiving && moveInfo.HasSplineData && hasFullSpline && splineType == SplineType.FacingTarget) { var facingTargetGuid = new byte[8]; packet.StartBitStream(facingTargetGuid, 4, 7, 0, 5, 1, 2, 3, 6); packet.ParseBitStream(facingTargetGuid, 4, 2, 0, 5, 6, 3, 1, 7); packet.WriteGuid("Facing Target GUID", facingTargetGuid, index); } return(moveInfo); }
/// <inheritdoc /> protected override object DeserialiseDataObjectInt(Stream inputStream, Type resultType, Dictionary <string, string> options) { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } #if NETFX_CORE var constructor = (from ctor in resultType.GetTypeInfo().DeclaredConstructors where ctor.GetParameters().Length == 0 select ctor).FirstOrDefault(); if (constructor == null || !explicitlySerializableType.GetTypeInfo().IsAssignableFrom(resultType.GetTypeInfo())) #else var constructor = resultType.GetConstructor(BindingFlags.Instance, null, new Type[] { }, null); if (constructor == null) { constructor = resultType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { }, null); } if (constructor == null || !explicitlySerializableType.IsAssignableFrom(resultType)) #endif { byte[] buffer = new byte[8]; if (resultType == typeof(bool)) { inputStream.Read(buffer, 0, sizeof(bool)); return(BitConverter.ToBoolean(buffer, 0)); } else if (resultType == typeof(byte)) { return((byte)inputStream.ReadByte()); } else if (resultType == typeof(sbyte)) { return((sbyte)(inputStream.ReadByte() - 128)); } else if (resultType == typeof(Int16)) { inputStream.Read(buffer, 0, sizeof(short)); return(BitConverter.ToInt16(buffer, 0)); } else if (resultType == typeof(UInt16)) { inputStream.Read(buffer, 0, sizeof(ushort)); return(BitConverter.ToUInt16(buffer, 0)); } else if (resultType == typeof(Int32)) { inputStream.Read(buffer, 0, sizeof(int)); return(BitConverter.ToInt32(buffer, 0)); } else if (resultType == typeof(UInt32)) { inputStream.Read(buffer, 0, sizeof(uint)); return(BitConverter.ToUInt32(buffer, 0)); } else if (resultType == typeof(Int64)) { inputStream.Read(buffer, 0, sizeof(long)); return(BitConverter.ToInt64(buffer, 0)); } else if (resultType == typeof(UInt64)) { inputStream.Read(buffer, 0, sizeof(ulong)); return(BitConverter.ToUInt64(buffer, 0)); } else if (resultType == typeof(IntPtr)) { inputStream.Read(buffer, 0, sizeof(long)); return(new IntPtr(BitConverter.ToInt64(buffer, 0))); } else if (resultType == typeof(UIntPtr)) { inputStream.Read(buffer, 0, sizeof(ulong)); return(new UIntPtr(BitConverter.ToUInt64(buffer, 0))); } else if (resultType == typeof(Char)) { inputStream.Read(buffer, 0, sizeof(char)); return(BitConverter.ToChar(buffer, 0)); } else if (resultType == typeof(Single)) { inputStream.Read(buffer, 0, sizeof(float)); return(BitConverter.ToSingle(buffer, 0)); } else if (resultType == typeof(Double)) { inputStream.Read(buffer, 0, sizeof(double)); return(BitConverter.ToDouble(buffer, 0)); } else if (resultType == typeof(String)) { inputStream.Read(buffer, 0, sizeof(int)); byte[] objData = new byte[BitConverter.ToInt32(buffer, 0)]; inputStream.Read(objData, 0, objData.Length); return(new String(Encoding.UTF8.GetChars(objData))); } else { throw new ArgumentException("Provided type " + resultType.ToString() + " either does not have a parameterless constructor or does not implement IExplicitlySerialize", "resultType"); } } var result = constructor.Invoke(new object[] { }) as IExplicitlySerialize; result.Deserialize(inputStream); return(result); }
private static PropertyInfo getProperty(ExportEntry entry) { IMEPackage pcc = entry.FileRef; string reference = null; PropertyType type; switch (entry.ClassName) { case "IntProperty": type = PropertyType.IntProperty; break; case "StringRefProperty": type = PropertyType.StringRefProperty; break; case "FloatProperty": type = PropertyType.FloatProperty; break; case "BoolProperty": type = PropertyType.BoolProperty; break; case "StrProperty": type = PropertyType.StrProperty; break; case "NameProperty": type = PropertyType.NameProperty; break; case "DelegateProperty": type = PropertyType.DelegateProperty; break; case "ObjectProperty": case "ClassProperty": case "ComponentProperty": type = PropertyType.ObjectProperty; reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4)); break; case "StructProperty": type = PropertyType.StructProperty; reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4)); break; case "BioMask4Property": case "ByteProperty": type = PropertyType.ByteProperty; reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4)); break; case "ArrayProperty": type = PropertyType.ArrayProperty; PropertyInfo arrayTypeProp = getProperty(pcc.GetUExport(BitConverter.ToInt32(entry.Data, 44))); if (arrayTypeProp != null) { switch (arrayTypeProp.Type) { case PropertyType.ObjectProperty: case PropertyType.StructProperty: case PropertyType.ArrayProperty: reference = arrayTypeProp.Reference; break; case PropertyType.ByteProperty: if (arrayTypeProp.Reference == "Class") { reference = arrayTypeProp.Type.ToString(); } else { reference = arrayTypeProp.Reference; } break; case PropertyType.IntProperty: case PropertyType.FloatProperty: case PropertyType.NameProperty: case PropertyType.BoolProperty: case PropertyType.StrProperty: case PropertyType.StringRefProperty: case PropertyType.DelegateProperty: reference = arrayTypeProp.Type.ToString(); break; case PropertyType.None: case PropertyType.Unknown: default: System.Diagnostics.Debugger.Break(); return(null); } } else { return(null); } break; case "InterfaceProperty": default: return(null); } bool transient = (BitConverter.ToUInt64(entry.Data, 24) & 0x0000000000002000) != 0; return(new PropertyInfo(type, reference, transient)); }
/// <summary> /// 从流中读取一个ulong数据 /// </summary> /// <returns></returns> public ulong ReadULong() { byte[] arr = new byte[4]; base.Read(arr, 0, 4); return(BitConverter.ToUInt64(arr, 0)); }
public ulong GetRandomULong() { CheckBuf(sizeof(ulong)); return(BitConverter.ToUInt64(_buf, _idx)); }
/// <summary> /// Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array. /// </summary> /// <param name="value">An array of bytes.</param> /// <param name="startIndex">The starting position within value.</param> /// <returns>A 64-bit unsigned integer formed by the eight bytes beginning at startIndex.</returns> /// <exception cref="System.ArgumentException"> /// startIndex is greater than or equal to the length of value minus 7, and is /// less than or equal to the length of value minus 1. /// </exception> /// <exception cref="System.ArgumentNullException">value is null.</exception> /// <exception cref="System.ArgumentOutOfRangeException"> /// startIndex is less than zero or greater than the length of value /// minus 1. /// </exception> public static ulong ToUInt64(byte[] value, int startIndex) => !IsLittleEndian ? BitConverter.ToUInt64(value, startIndex) : BitConverter.ToUInt64(value.Reverse().ToArray(), value.Length - sizeof(ulong) - startIndex);
/// <summary> /// Unwrap object wrapped in <see cref="SerializedObjectWrapper"/> /// </summary> /// <param name="item"></param> /// <returns></returns> object Unwrap(SerializedObjectWrapper item) { if (item.Data.Array == null) { return(null); } if (item.Flags == RawDataFlag) { ArraySegment <byte> tmp = item.Data; if (tmp.Count == tmp.Array.Length) { return(tmp.Array); } // we should never arrive here, but it's better to be safe than sorry var retval = new byte[tmp.Count]; Array.Copy(tmp.Array, tmp.Offset, retval, 0, tmp.Count); return(retval); } var code = (TypeCode)(item.Flags & 0x00ff); byte[] data = item.Data.Array; int offset = item.Data.Offset; int count = item.Data.Count; switch (code) { // incrementing a non-existing key then getting it // returns as a string, but the flag will be 0 // so treat all 0 flagged items as string // this may help inter-client data management as well // // however we store 'null' as Empty + an empty array, // so this must special-cased for compatibilty with // earlier versions. we introduced DBNull as null marker in emc2.6 case TypeCode.Empty: return((data == null || count == 0) ? null : Encoding.UTF8.GetString(data, offset, count)); case TypeCode.DBNull: return(null); case TypeCode.String: return(Encoding.UTF8.GetString(data, offset, count)); case TypeCode.Boolean: return(BitConverter.ToBoolean(data, offset)); case TypeCode.Int16: return(BitConverter.ToInt16(data, offset)); case TypeCode.Int32: return(BitConverter.ToInt32(data, offset)); case TypeCode.Int64: return(BitConverter.ToInt64(data, offset)); case TypeCode.UInt16: return(BitConverter.ToUInt16(data, offset)); case TypeCode.UInt32: return(BitConverter.ToUInt32(data, offset)); case TypeCode.UInt64: return(BitConverter.ToUInt64(data, offset)); case TypeCode.Char: return(BitConverter.ToChar(data, offset)); case TypeCode.DateTime: return(DateTime.FromBinary(BitConverter.ToInt64(data, offset))); case TypeCode.Double: return(BitConverter.ToDouble(data, offset)); case TypeCode.Single: return(BitConverter.ToSingle(data, offset)); case TypeCode.Object: using (var ms = new MemoryStream(data, offset, count)) { #if NETSTANDARD2_0 return(null); #else return(bf.Deserialize(ms)); #endif } default: throw new InvalidOperationException("Unknown TypeCode was returned: " + code); } }
public static ulong GetUInt64() { return(BitConverter.ToUInt64(GetBytes(sizeof(ulong)), 0)); }
private void ParseFields() { if (Format == null) { return; } int offset = 0; byte[] message = this.Blob; string format = Format.FormatString; for (int k = 0, n = format.Length; k < n; k++) { char ch = format[k]; object value = null; switch (ch) { case 'b': value = (sbyte)message[offset]; offset++; break; case 'B': value = message[offset]; offset++; break; case 'h': value = BitConverter.ToInt16(message, offset); offset += 2; break; case 'H': value = BitConverter.ToUInt16(message, offset); offset += 2; break; case 'i': value = BitConverter.ToInt32(message, offset); offset += 4; break; case 'I': value = BitConverter.ToUInt32(message, offset); offset += 4; break; case 'q': value = BitConverter.ToInt64(message, offset); offset += 8; break; case 'Q': value = BitConverter.ToUInt64(message, offset); offset += 8; break; case 'f': value = BitConverter.ToSingle(message, offset); offset += 4; break; case 'd': value = BitConverter.ToDouble(message, offset); offset += 8; break; case 'c': value = (BitConverter.ToInt16(message, offset) / 100.0); offset += 2; break; case 'C': value = (BitConverter.ToUInt16(message, offset) / 100.0); offset += 2; break; case 'e': value = (BitConverter.ToInt32(message, offset) / 100.0); offset += 4; break; case 'E': value = (BitConverter.ToUInt32(message, offset) / 100.0); offset += 4; break; case 'L': value = ((double)BitConverter.ToInt32(message, offset) / 10000000.0); offset += 4; break; case 'n': value = ASCIIEncoding.ASCII.GetString(message, offset, 4).Trim(NullTerminator); offset += 4; break; case 'N': value = ASCIIEncoding.ASCII.GetString(message, offset, 16).Trim(NullTerminator); offset += 16; break; case 'M': int modeno = message[offset]; value = modeno; offset++; break; case 'Z': value = ASCIIEncoding.ASCII.GetString(message, offset, 64).Trim(NullTerminator); offset += 64; break; default: throw new Exception(string.Format("Unexpected format specifier '{0}'", ch)); } if (k < Format.Columns.Length) { cache[Format.Columns[k]] = new LogField() { Name = Format.Columns[k], Value = value, Parent = this }; } } }
public static dynamic ConvertBuffer(string datatype, byte[] buffer) { try { (string type, int size) = Separate(datatype); if (type == "Bool") { if (size > 1) { return(Array.ConvertAll(buffer, val => val == 0 ? false : true)); } else { return(buffer[0] == 0 ? false : true); } } else if (type == "Float") { if (size > 1) { float[] temp = new float[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToSingle(buffer, i * sizeof(float)); } return(temp); } else { return(BitConverter.ToSingle(buffer, 0)); } } else if (type == "Double") { if (size > 1) { double[] temp = new double[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToDouble(buffer, i * sizeof(double)); } return(temp); } else { return(BitConverter.ToDouble(buffer, 0)); } } else if (type == "Char") { return(Encoding.ASCII.GetString(buffer)); } else if (type.Contains("Int")) { if (type == "Int8") { if (size > 1) { return(Array.ConvertAll(buffer, val => unchecked ((sbyte)val))); } else { return(unchecked ((sbyte)buffer[0])); } } else if (type == "UInt8") { if (size > 1) { return(buffer); } else { return(buffer[0]); } } if (type == "Int16") { if (size > 1) { short[] temp = new short[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToInt16(buffer, i * sizeof(short)); } return(temp); } else { return(BitConverter.ToInt16(buffer, 0)); } } else if (type == "UInt16") { if (size > 1) { ushort[] temp = new ushort[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToUInt16(buffer, i * sizeof(ushort)); } return(temp); } else { return(BitConverter.ToUInt16(buffer, 0)); } } if (type == "Int32") { if (size > 1) { int[] temp = new int[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToInt32(buffer, i * sizeof(int)); } return(temp); } else { return(BitConverter.ToInt32(buffer, 0)); } } else if (type == "UInt32") { if (size > 1) { uint[] temp = new uint[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToUInt32(buffer, i * sizeof(uint)); } return(temp); } else { return(BitConverter.ToUInt32(buffer, 0)); } } if (type == "Int64") { if (size > 1) { long[] temp = new long[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToInt64(buffer, i * sizeof(long)); } return(temp); } else { return(BitConverter.ToInt64(buffer, 0)); } } else if (type == "UInt64") { if (size > 1) { ulong[] temp = new ulong[size]; for (int i = 0; i < size; i++) { temp[i] = BitConverter.ToUInt64(buffer, i * sizeof(ulong)); } return(temp); } else { return(BitConverter.ToUInt64(buffer, 0)); } } } else { throw new Exception(string.Format("Unknown datatype: {0}.", type)); } return(null); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return(null); } }
/// <summary> /// Accept a client's request. /// </summary> public void Accept() { if (!_client.Connected) { return; } try { var sizeBuffer = new byte[8]; _stream.Read(sizeBuffer, 0, sizeBuffer.Length); var messageLength = BitConverter.ToUInt64(sizeBuffer, 0); var messageBuffer = new byte[_client.ReceiveBufferSize]; var messageBuilder = new StringBuilder(); var requestType = (Request)_stream.ReadByte(); if (!Enum.IsDefined(typeof(Request), requestType)) { Close(); return; } switch (requestType) { case Request.Get: var read = 0uL; do { read += (uint)_stream.Read(messageBuffer, 0, messageBuffer.Length); messageBuilder.Append(Encoding.ASCII.GetString(messageBuffer)); } while (read < messageLength); var request = JObject.Parse(messageBuilder.ToString()); { using (var fs = LogHandler.GetLogStream(request["LogID"].ToObject <string>())) { if (fs == null) { Send(ErrorAsJSON(Error.LogNotFound)); break; } var rl = BitConverter.GetBytes(fs.Length); _stream.Write(rl, 0, rl.Length); fs.CopyTo(_stream); } } break; case Request.Put: try { const int readTimeout = 1000; _stream.ReadTimeout = readTimeout; Send(new JObject { { "LogID", LogHandler.PutFromStream(_stream) } }.ToString()); } catch (JsonException) { Send(ErrorAsJSON(Error.InvalidLog)); } break; } } catch (JsonReaderException) { } catch (IOException) { } catch (Win32Exception e) { if (e.NativeErrorCode == -2147467259) { Console.WriteLine("Run server as admin."); Environment.Exit(1); } else { throw; } } finally { Close(); } }
private static MovementInfo ReadMovementUpdateBlock547(ref Packet packet, Guid guid, int index) { var moveInfo = new MovementInfo(); var hasUnkDword676 = packet.ReadBit(); var hasVehicleData = packet.ReadBit("Has Vehicle Data", index); var hasUnkDword1044 = packet.ReadBit(); var hasGameObjectRotation = packet.ReadBit("Has GameObject Rotation", index); packet.ReadBit("unk byte0", index); var living = packet.ReadBit("Living", index); var hasUnkLargeBlock = packet.ReadBit("Has Unk Large Block", index); packet.ReadBit("Unk Byte2", index); var hasUnkLargeBlock2 = packet.ReadBit("Has Unk Large Block2", index); packet.ReadBit("Self", index); packet.ReadBit("Unk Byte681", index); packet.ReadBit("Unk Byte1", index); var hasGameObjectPosition = packet.ReadBit("Has GameObject Position", index); var transport = packet.ReadBit("Has Transport Data", index); var hasAnimKits = packet.ReadBit("Has AnimKits", index); var hasStationaryPosition = packet.ReadBit("Has Stationary Position", index); var hasAttackingTarget = packet.ReadBit("Has Attacking Target", index); var unkLoopCounter = packet.ReadBits("Unknown array size", 22, index); var hasUnkString = packet.ReadBit("Has Unknown String", index); var hasTransportFrames = packet.ReadBit("Has Transport Frames", index); uint transportFramesCount = 0; uint UnkStringLen = 0; //int IsLivingUnkCountLoop = 0; uint IsLivingUnkCounter = 0; var hasOrientation = false; var guid2 = new byte[8]; var hasPitch = false; var hasFallData = false; var hasSplineElevation = false; var hasTransportData = false; var hasTimestamp = false; var hasMovementCounter = false; var transportGuid = new byte[8]; var hasTransportTime2 = false; var hasTransportTime3 = false; var bit216 = false; var hasSplineStartTime = false; var splineCount = 0u; var splineType = SplineType.Stop; var facingTargetGuid = new byte[8]; var hasSplineVerticalAcceleration = false; var hasSplineUnkPart = false; var hasFallDirection = false; var goTransportGuid = new byte[8]; var hasGOTransportTime2 = false; var hasGOTransportTime3 = false; var attackingTargetGuid = new byte[8]; var SplineFacingTargetGuid = new byte[8]; var hasAnimKit1 = false; var hasAnimKit2 = false; var hasAnimKit3 = false; bool[] UnkLargeBlockBits = new bool[13]; uint[] UnkLargeBlockCount = new uint[3]; if (hasTransportFrames) { transportFramesCount = packet.ReadBits("Transport Frames Count", 22, index); } if (hasGameObjectPosition) { goTransportGuid[3] = packet.ReadBit(); goTransportGuid[5] = packet.ReadBit(); goTransportGuid[2] = packet.ReadBit(); goTransportGuid[1] = packet.ReadBit(); goTransportGuid[4] = packet.ReadBit(); hasGOTransportTime3 = packet.ReadBit(); hasGOTransportTime2 = packet.ReadBit(); goTransportGuid[0] = packet.ReadBit(); goTransportGuid[6] = packet.ReadBit(); goTransportGuid[7] = packet.ReadBit(); } if (living) { hasTransportData = packet.ReadBit("Has Transport Data", index); if (hasTransportData) { transportGuid[4] = packet.ReadBit(); transportGuid[0] = packet.ReadBit(); transportGuid[5] = packet.ReadBit(); transportGuid[2] = packet.ReadBit(); transportGuid[3] = packet.ReadBit(); hasTransportTime2 = packet.ReadBit(); transportGuid[7] = packet.ReadBit(); transportGuid[6] = packet.ReadBit(); transportGuid[1] = packet.ReadBit(); hasTransportTime3 = packet.ReadBit(); } hasPitch = !packet.ReadBit("Lacks pitch", index); packet.ReadBit("Has MovementInfo spline", index); packet.ReadBits("IsLicingUnkLoop", 19, index); guid2[1] = packet.ReadBit(); var hasExtraMovementFlags = !packet.ReadBit(); /*var v37 = IsLivingUnkCountLoop == 0; * * if (!v37) * { * for (int i = 0; i < IsLivingUnkCountLoop; ++i) * { * packet.ReadBits("Unk DWORD24 Loop1", 2, index, (int)i); * } * }*/ packet.ReadBit("Unk Bit from movementInfo", index); hasSplineElevation = !packet.ReadBit("Lacks spline elevation", index); if (hasExtraMovementFlags) { moveInfo.FlagsExtra = packet.ReadEnum <MovementFlagExtra>("Extra Movement Flags", 13, index); } hasOrientation = !packet.ReadBit("Lacks orientation", index); hasTimestamp = !packet.ReadBit("Has Timestamp", index); var hasMovementFlags = !packet.ReadBit(); hasMovementCounter = !packet.ReadBit("Has Movement Counter", index); guid2[2] = packet.ReadBit(); guid2[6] = packet.ReadBit(); hasFallData = packet.ReadBit("Has Fall Data", index); guid2[5] = packet.ReadBit(); guid2[4] = packet.ReadBit(); guid2[0] = packet.ReadBit(); if (hasMovementFlags) { moveInfo.Flags = (WowPacketParser.Enums.MovementFlag)packet.ReadEnum <MovementFlag>("Movement Flags", 30, index); } packet.ReadBit("Unk byte164", index); if (hasFallData) { hasFallDirection = packet.ReadBit("Has Fall Direction", index); } packet.ReadBits("Is Living Unk Counter", 22, index); guid2[7] = packet.ReadBit(); moveInfo.HasSplineData = packet.ReadBit("Has Spline Data", index); guid2[3] = packet.ReadBit(); if (moveInfo.HasSplineData) { bit216 = packet.ReadBit("Has extended spline data", index); if (bit216) { packet.ReadBits("Unk bits", 2, index); hasSplineStartTime = packet.ReadBit("Has spline start time", index); splineCount = packet.ReadBits("Spline Waypoints", 22, index); packet.ReadEnum <SplineFlag434>("Spline flags", 25, index); hasSplineVerticalAcceleration = packet.ReadBit("Has spline vertical acceleration", index); hasSplineUnkPart = packet.ReadBit(); if (hasSplineUnkPart) { packet.ReadBits("Unk word300", 2, index); //unk word300 packet.ReadBits("Unk dword284", 21, index); //unk dword284 } } } } if (hasUnkLargeBlock2) { UnkLargeBlockBits[0] = packet.ReadBit(); UnkLargeBlockBits[1] = packet.ReadBit(); packet.ReadBit("Unk Byte256", index); packet.ReadBit("Unk Byte257", index); UnkLargeBlockBits[4] = packet.ReadBit(); packet.ReadBit("Unk Byte254", index); UnkLargeBlockBits[6] = packet.ReadBit(); packet.ReadBit("Unk Byte255", index); UnkLargeBlockBits[8] = packet.ReadBit(); if (UnkLargeBlockBits[8]) { UnkLargeBlockCount[0] = packet.ReadBits(21); UnkLargeBlockCount[1] = packet.ReadBits(21); } UnkLargeBlockBits[9] = packet.ReadBit(); if (UnkLargeBlockBits[9]) { UnkLargeBlockCount[2] = packet.ReadBits(20); } UnkLargeBlockBits[10] = packet.ReadBit(); packet.ReadBit("Unk Byte258", index); UnkLargeBlockBits[12] = packet.ReadBit(); } if (hasAttackingTarget) { attackingTargetGuid = packet.StartBitStream(4, 6, 3, 5, 0, 2, 7, 1); } if (hasAnimKits) { hasAnimKit2 = !packet.ReadBit(); hasAnimKit3 = !packet.ReadBit(); hasAnimKit1 = !packet.ReadBit(); } if (hasUnkString) { UnkStringLen = packet.ReadBits(7); } packet.ResetBitReader(); // Reading data for (var i = 0u; i < unkLoopCounter; ++i) { packet.ReadUInt32("Unk UInt32", index, (int)i); } if (hasUnkLargeBlock2) { if (UnkLargeBlockBits[10]) { packet.ReadSingle("Unk Float 234", index); packet.ReadSingle("Unk Float 238", index); } if (UnkLargeBlockBits[8]) { for (uint i = 0; i < UnkLargeBlockCount[1]; ++i) { packet.ReadSingle("Unk Float Loop1", index); packet.ReadSingle("Unk Float1 Loop1", index); } packet.ReadSingle("Unk Float 27C", index); for (uint i = 0; i < UnkLargeBlockCount[0]; ++i) { packet.ReadSingle("Unk Float Loop0", index); packet.ReadSingle("Unk Float1 Loop0", index); } packet.ReadSingle("Unk Float 280", index); } if (UnkLargeBlockBits[1]) { packet.ReadSingle("Unk Float 244", index); packet.ReadSingle("Unk Float 250", index); packet.ReadSingle("Unk Float 254", index); packet.ReadSingle("Unk Float 248", index); packet.ReadSingle("Unk Float 240", index); packet.ReadSingle("Unk Float 24C", index); } packet.ReadInt32("Unk DWORD 520", index); if (UnkLargeBlockBits[9]) { for (uint i = 0; i < UnkLargeBlockCount[2]; ++i) { packet.ReadSingle("Unk Float Loop2", index); packet.ReadSingle("Unk Float1 Loop2", index); packet.ReadSingle("Unk Float2 Loop2", index); } } if (UnkLargeBlockBits[12]) { packet.ReadInt32("Unk DWORD 540", index); } if (UnkLargeBlockBits[6]) { packet.ReadInt32("Unk DWORD 532", index); } if (UnkLargeBlockBits[0]) { packet.ReadInt32("Unk DWORD 556", index); } if (UnkLargeBlockBits[4]) { packet.ReadInt32("Unk DWORD 548", index); } } if (living) { if (hasFallData) { if (hasFallDirection) { packet.ReadSingle("Jump Sin", index); packet.ReadSingle("Jump Cos", index); packet.ReadSingle("Jump XY Speed", index); } packet.ReadSingle("Fall Z Speed", index); packet.ReadUInt32("Time Fallen", index); } if (moveInfo.HasSplineData) { if (bit216) { packet.ReadSingle("Spline Duration Multiplier Next", index); for (var i = 0u; i < splineCount; ++i) { var wp = new Vector3 { Z = packet.ReadSingle(), X = packet.ReadSingle(), Y = packet.ReadSingle(), }; packet.WriteLine("[{0}][{1}] Spline Waypoint: {2}", index, i, wp); } splineType = packet.ReadEnum <SplineType>("Spline Type", TypeCode.Byte, index); packet.ReadSingle("Spline Duration Multiplier", index); //unk part goes here if (splineType == SplineType.FacingSpot) { var point = new Vector3 { X = packet.ReadSingle(), Z = packet.ReadSingle(), Y = packet.ReadSingle(), }; packet.WriteLine("[{0}] Facing Spot: {1}", index, point); } if (hasSplineVerticalAcceleration) { packet.ReadSingle("Spline Vertical Acceleration", index); } if (splineType == SplineType.FacingAngle) { packet.ReadSingle("Facing Angle", index); } packet.ReadUInt32("Spline Full Time", index); if (hasSplineStartTime) { packet.ReadUInt32("Spline Start time", index); } packet.ReadUInt32("Spline Time", index); } packet.ReadUInt32("Spline Id", index); var endPoint = new Vector3 { Z = packet.ReadSingle(), X = packet.ReadSingle(), Y = packet.ReadSingle(), }; packet.WriteLine("[{0}] Spline Endpoint: {1}", index, endPoint); } moveInfo.Position.Z = packet.ReadSingle(); /*if (IsLivingUnkCountLoop > 0) * { * for (int i = 0; i < IsLivingUnkCountLoop; ++i) * { * packet.ReadSingle("Unk Float14", index, (int)i); * packet.ReadInt32("Unk DWORD10", index, (int)i); * packet.ReadInt32("Unk DWORD0", index, (int)i); * packet.ReadSingle("Unk FloatC", index, (int)i); * packet.ReadSingle("Unk Float4", index, (int)i); * packet.ReadSingle("Unk Float8", index, (int)i); * } * }*/ moveInfo.Position.Y = packet.ReadSingle(); packet.ReadSingle("Fly Speed", index); packet.ReadXORByte(guid2, 6); packet.ReadSingle("FlyBack Speed", index); if (hasTransportData) { packet.ReadXORByte(transportGuid, 7); packet.ReadXORByte(transportGuid, 4); if (hasTransportTime3) { packet.ReadUInt32("Transport Time 3", index); } packet.ReadUInt32("Transport Time", index); if (hasTransportTime2) { packet.ReadUInt32("Transport Time 2", index); } moveInfo.TransportOffset.O = packet.ReadSingle(); moveInfo.TransportOffset.X = packet.ReadSingle(); packet.ReadXORByte(transportGuid, 6); packet.ReadXORByte(transportGuid, 3); packet.ReadXORByte(transportGuid, 2); moveInfo.TransportOffset.Z = packet.ReadSingle(); moveInfo.TransportOffset.Y = packet.ReadSingle(); packet.ReadSByte("Transport Seat", index); packet.ReadXORByte(transportGuid, 1); packet.ReadXORByte(transportGuid, 0); packet.ReadXORByte(transportGuid, 5); moveInfo.TransportGuid = new Guid(BitConverter.ToUInt64(transportGuid, 0)); packet.WriteLine("[{0}] Transport GUID {1}", index, moveInfo.TransportGuid); packet.WriteLine("[{0}] Transport Position: {1}", index, moveInfo.TransportOffset); } moveInfo.Position.X = packet.ReadSingle(); packet.ReadXORByte(guid2, 2); if (hasPitch) { packet.ReadSingle("Pitch", index); } packet.ReadSingle("Swim Speed", index); packet.ReadXORByte(guid2, 1); packet.ReadSingle("RunBack Speed", index); packet.ReadSingle("SwimBack Speed", index); packet.ReadXORByte(guid2, 5); if (hasSplineElevation) { packet.ReadSingle("Spline Elevation", index); } if (hasMovementCounter) { packet.ReadUInt32("Movement Counter", index); } moveInfo.RunSpeed = packet.ReadSingle("Run Speed", index) / 7.0f; packet.ReadXORByte(guid2, 7); moveInfo.WalkSpeed = packet.ReadSingle("Walk Speed", index) / 2.5f; packet.ReadSingle("Pitch Rate", index); if (IsLivingUnkCounter > 0) { for (uint i = 0; i < IsLivingUnkCounter; ++i) { packet.ReadUInt32("Unk DWORD148", index, (int)i); } } if (hasTimestamp) { packet.ReadUInt32("Timestamp", index); } packet.ReadXORByte(guid2, 4); packet.ReadXORByte(guid2, 0); if (hasOrientation) { moveInfo.Orientation = packet.ReadSingle(); } packet.WriteLine("[{0}] GUID 2: {1}", index, new Guid(BitConverter.ToUInt64(guid2, 0))); packet.WriteLine("[{0}] Position: {1}", index, moveInfo.Position); packet.WriteLine("[{0}] Orientation: {1}", index, moveInfo.Orientation); } if (hasAttackingTarget) { packet.ParseBitStream(attackingTargetGuid, 5, 1, 2, 0, 3, 4, 6, 7); packet.WriteGuid("Attacking Target GUID", attackingTargetGuid, index); } if (hasStationaryPosition) { moveInfo.Orientation = packet.ReadSingle("Stationary Orientation", index); moveInfo.Position = packet.ReadVector3("Stationary Position", index); } if (hasGameObjectPosition) { packet.ReadByte("GO Transport Seat", index); moveInfo.TransportOffset.X = packet.ReadSingle(); packet.ReadXORByte(goTransportGuid, 1); packet.ReadXORByte(goTransportGuid, 0); packet.ReadXORByte(goTransportGuid, 2); packet.ReadXORByte(goTransportGuid, 6); packet.ReadXORByte(goTransportGuid, 5); packet.ReadXORByte(goTransportGuid, 4); if (hasGOTransportTime3) { packet.ReadUInt32("GO Transport Time 3", index); } packet.ReadXORByte(goTransportGuid, 7); moveInfo.TransportOffset.O = packet.ReadSingle(); moveInfo.TransportOffset.Z = packet.ReadSingle(); moveInfo.TransportOffset.Y = packet.ReadSingle(); if (hasGOTransportTime2) { packet.ReadUInt32("GO Transport Time 2", index); } packet.ReadXORByte(goTransportGuid, 3); packet.ReadUInt32("GO Transport Time", index); moveInfo.TransportGuid = new Guid(BitConverter.ToUInt64(goTransportGuid, 0)); packet.WriteLine("[{0}] GO Transport GUID {1}", index, moveInfo.TransportGuid); packet.WriteLine("[{0}] GO Transport Position: {1}", index, moveInfo.TransportOffset); } if (transport) { packet.ReadUInt32("Transport path timer", index); } if (hasUnkDword676) { packet.ReadUInt32("Unk DWORD676", index); } if (hasUnkString) { packet.ReadWoWString("Unk String", UnkStringLen, index); } if (hasGameObjectRotation) { packet.ReadPackedQuaternion("GameObject Rotation", index); } if (hasVehicleData) { moveInfo.VehicleId = packet.ReadUInt32("Vehicle Id", index); packet.ReadSingle("Vehicle Orientation", index); } if (hasUnkDword1044) { packet.ReadUInt32("Unk DWORD1044", index); } if (hasAnimKits) { if (hasAnimKit1) { packet.ReadUInt16("Anim Kit 1", index); } if (hasAnimKit2) { packet.ReadUInt16("Anim Kit 2", index); } if (hasAnimKit3) { packet.ReadUInt16("Anim Kit 3", index); } } /*if (bit456) * { * // float[] arr = new float[16]; * // ordering: 13, 4, 7, 15, BYTE, 10, 11, 3, 5, 14, 6, 1, 8, 12, 0, 2, 9 * packet.ReadBytes(4 * 16 + 1); * }*/ if (living && moveInfo.HasSplineData && bit216) { if (splineType == SplineType.FacingTarget) { SplineFacingTargetGuid = packet.StartBitStream(6, 7, 3, 0, 5, 1, 4, 2); packet.ParseBitStream(SplineFacingTargetGuid, 4, 2, 5, 6, 0, 7, 1, 3); packet.WriteGuid("Spline Facing Target GUID", SplineFacingTargetGuid, index); } } return(moveInfo); }
/// <summary> /// Return a new <see cref="NetMQMessage"/> that contains the decrypted content of the give message. /// </summary> /// <param name="contentType">This identifies the type of content: ChangeCipherSpec, Handshake, or ApplicationData.</param> /// <param name="cipherMessage">the message to decrypt</param> /// <returns>a new NetMQMessage with the contents decrypted</returns> /// <exception cref="NetMQSecurityException"><see cref="NetMQSecurityErrorCode.InvalidFramesCount"/>: Cipher message must have at least 2 frames, iv and sequence number.</exception> /// <exception cref="NetMQSecurityException"><see cref="NetMQSecurityErrorCode.ReplayAttack"/>: Message already handled or very old message, might be under replay attack.</exception> /// <exception cref="NetMQSecurityException"><see cref="NetMQSecurityErrorCode.EncryptedFramesMissing"/>: Frames were removed from the encrypted message.</exception> public NetMQMessage DecryptMessage(ContentType contentType, NetMQMessage cipherMessage) { if (SecurityParameters.BulkCipherAlgorithm == BulkCipherAlgorithm.Null && SecurityParameters.MACAlgorithm == MACAlgorithm.Null) { return(cipherMessage); } if (cipherMessage.FrameCount < 2) { throw new NetMQSecurityException(NetMQSecurityErrorCode.InvalidFramesCount, "cipher message should have at least 2 frames, iv and sequence number"); } NetMQFrame ivFrame = cipherMessage.Pop(); m_decryptionBulkAlgorithm.IV = ivFrame.ToByteArray(); using (var decryptor = m_decryptionBulkAlgorithm.CreateDecryptor()) { NetMQMessage plainMessage = new NetMQMessage(); NetMQFrame seqNumFrame = cipherMessage.Pop(); byte[] frameBytes; byte[] seqNumMAC; byte[] padding; DecryptBytes(decryptor, seqNumFrame.ToByteArray(), out frameBytes, out seqNumMAC, out padding); ulong seqNum = BitConverter.ToUInt64(frameBytes, 0); int frameCount = BitConverter.ToInt32(frameBytes, 8); int frameIndex = 0; ValidateBytes(contentType, seqNum, frameIndex, frameBytes, seqNumMAC, padding); if (CheckReplayAttack(seqNum)) { throw new NetMQSecurityException(NetMQSecurityErrorCode.ReplayAttack, "Message already handled or very old message, might be under replay attack"); } if (frameCount != cipherMessage.FrameCount) { throw new NetMQSecurityException(NetMQSecurityErrorCode.EncryptedFramesMissing, "Frames was removed from the encrypted message"); } frameIndex++; foreach (NetMQFrame cipherFrame in cipherMessage) { byte[] data; byte[] mac; DecryptBytes(decryptor, cipherFrame.ToByteArray(), out data, out mac, out padding); ValidateBytes(contentType, seqNum, frameIndex, data, mac, padding); frameIndex++; plainMessage.Append(data); } return(plainMessage); } }
/// <summary>Construct the data by giving the Byte Array data. This is for reading index data from storage</summary> public IndexCache(Byte[] Data) { Time = BitConverter.ToUInt64(Data, 0); Offset = BitConverter.ToUInt64(Data, 8); Size = BitConverter.ToUInt32(Data, 16); }
[Parser(Opcode.SMSG_VOID_STORAGE_TRANSFER_CHANGES)] // 4.3.4 public static void HandleVoidStorageTransferChanges(Packet packet) { var count1 = packet.ReadBits("Count 1", 5); var count2 = packet.ReadBits("Count 2", 5); var id1 = new byte[count1][]; var guid = new byte[count1][]; for (int i = 0; i < count1; ++i) { id1[i] = new byte[8]; guid[i] = new byte[8]; guid[i][7] = packet.ReadBit(); id1[i][7] = packet.ReadBit(); id1[i][4] = packet.ReadBit(); guid[i][6] = packet.ReadBit(); guid[i][5] = packet.ReadBit(); id1[i][3] = packet.ReadBit(); id1[i][5] = packet.ReadBit(); guid[i][4] = packet.ReadBit(); guid[i][2] = packet.ReadBit(); guid[i][0] = packet.ReadBit(); guid[i][3] = packet.ReadBit(); guid[i][1] = packet.ReadBit(); id1[i][2] = packet.ReadBit(); id1[i][0] = packet.ReadBit(); id1[i][1] = packet.ReadBit(); id1[i][6] = packet.ReadBit(); } var id2 = new byte[count2][]; for (int i = 0; i < count2; ++i) { id2[i] = packet.StartBitStream(1, 7, 3, 5, 6, 2, 4, 0); } for (int i = 0; i < count2; ++i) { packet.ParseBitStream(id2[i], 3, 1, 0, 2, 7, 5, 6, 4); packet.WriteLine("[{1}] Item Id 2: {0}", BitConverter.ToUInt64(id2[i], 0), i); } for (int i = 0; i < count1; ++i) { packet.ReadInt32("Item Suffix Factor", i); packet.ReadXORByte(id1[i], 6); packet.ReadXORByte(id1[i], 4); packet.ReadXORByte(guid[i], 4); packet.ReadXORByte(id1[i], 2); packet.ReadXORByte(guid[i], 1); packet.ReadXORByte(guid[i], 3); packet.ReadXORByte(id1[i], 3); packet.ReadXORByte(guid[i], 0); packet.ReadXORByte(id1[i], 0); packet.ReadXORByte(guid[i], 6); packet.ReadXORByte(id1[i], 5); packet.ReadXORByte(guid[i], 5); packet.ReadXORByte(guid[i], 7); packet.ReadEntryWithName <UInt32>(StoreNameType.Item, "Item Entry", i); packet.ReadXORByte(id1[i], 1); packet.ReadInt32("Item Slot", i); packet.ReadXORByte(guid[i], 2); packet.ReadXORByte(id1[i], 7); packet.ReadInt32("Item Random Property ID", i); packet.WriteLine("[{1}] Item Id 1: {0}", BitConverter.ToUInt64(id1[i], 0), i); packet.WriteGuid("Item Player Creator Guid", guid[i], i); } }
/// <summary> /// 从缓存中提取ulong结果 /// </summary> /// <param name="buffer">缓存数据</param> /// <param name="index">索引位置</param> /// <returns>ulong对象</returns> public virtual ulong TransUInt64( byte[] buffer, int index ) { return BitConverter.ToUInt64( ByteTransDataFormat8( buffer, index ), 0 ); }
[Parser(Opcode.SMSG_VOID_STORAGE_CONTENTS)] // 4.3.4 public static void HandleVoidStorageContents(Packet packet) { var count = packet.ReadBits("Count", 8); var id = new byte[count][]; var guid = new byte[count][]; for (int i = 0; i < count; ++i) { id[i] = new byte[8]; guid[i] = new byte[8]; guid[i][3] = packet.ReadBit(); id[i][5] = packet.ReadBit(); guid[i][6] = packet.ReadBit(); guid[i][1] = packet.ReadBit(); id[i][1] = packet.ReadBit(); id[i][3] = packet.ReadBit(); id[i][6] = packet.ReadBit(); guid[i][5] = packet.ReadBit(); guid[i][2] = packet.ReadBit(); id[i][2] = packet.ReadBit(); guid[i][4] = packet.ReadBit(); id[i][0] = packet.ReadBit(); id[i][4] = packet.ReadBit(); id[i][7] = packet.ReadBit(); guid[i][0] = packet.ReadBit(); guid[i][7] = packet.ReadBit(); } for (int i = 0; i < count; ++i) { packet.ReadXORByte(guid[i], 3); packet.ReadInt32("Item Suffix Factor", i); packet.ReadXORByte(guid[i], 4); packet.ReadInt32("Item Slot", i); packet.ReadXORByte(id[i], 0); packet.ReadXORByte(id[i], 6); packet.ReadXORByte(guid[i], 0); packet.ReadXORByte(guid[i], 1); packet.ReadInt32("Item Random Property ID", i); packet.ReadXORByte(id[i], 4); packet.ReadXORByte(id[i], 5); packet.ReadXORByte(id[i], 2); packet.ReadXORByte(guid[i], 2); packet.ReadXORByte(guid[i], 6); packet.ReadXORByte(id[i], 1); packet.ReadXORByte(id[i], 3); packet.ReadXORByte(guid[i], 5); packet.ReadXORByte(guid[i], 7); packet.ReadEntryWithName <UInt32>(StoreNameType.Item, "Item Entry", i); packet.ReadXORByte(id[i], 7); packet.WriteLine("[{1}] Item Id: {0}", BitConverter.ToUInt64(id[i], 0), i); packet.WriteGuid("Item Player Creator Guid", guid[i], i); } }
/// <summary> /// Generates a cryptographically strong random <see cref="ulong" /> value that is greater than or equal to 0UL, and less than or equal to <see cref="ulong.MaxValue" />. /// </summary> /// <param name="randomNumberGenerator">The <see cref="RandomNumberGenerator" /> object to be used for random number generation.</param> /// <returns> /// A cryptographically strong random <see cref="ulong" /> value that is greater than or equal to 0UL, and less than or equal to <see cref="ulong.MaxValue" />. /// </returns> public static ulong GetUInt64(this RandomNumberGenerator randomNumberGenerator) { Check.ArgumentNull(randomNumberGenerator, nameof(randomNumberGenerator)); return(BitConverter.ToUInt64(randomNumberGenerator.GetBytes(8), 0)); }
public static UInt64 ReadUInt64(byte[] bytes, int offset) { var _bytes = CopyBytes(bytes, offset, 8); return(BitConverter.ToUInt64(_bytes.Reverse().ToArray(), 0)); }
uint ReadHeader(byte[] buffer, uint offset, uint numBytesAvailable) { // we need at least the first 2 bytes of the message frame to be able to decode the header size if (numBytesAvailable < 2) { return(0); } // read first two bytes var codeByte = buffer[offset + 0]; var payloadByte = buffer[offset + 1]; // calculate header size IsMasked = (byte)(payloadByte & (byte)Flag.Mask) == (byte)Flag.Mask; uint payload = (uint)(payloadByte & (byte)Flag.Payload); uint headerSize = 2; if (IsMasked) { headerSize += 4; } if (payload == 126) { headerSize += 2; } else if (payload == 127) { headerSize += 8; } // wait until we have the whole header available // ... this saves trying to track state, but does mean we need at least enough buffer space for the whole header if (numBytesAvailable < headerSize) { return(0); } // we have the whole header, so get the length of the payload if (payload < 126) { mPayloadLen = (uint)payload; } else if (payload == 126) { var size = Endian.NetworkToHost(BitConverter.ToUInt16(buffer, (int)offset + 2)); if (size > WebSocket.MaxPayload) { throw new WebSocketException(WebSocketStatus.PayloadTooLarge); } mPayloadLen = (uint)size; } else // payload == 127 { var size = Endian.NetworkToHost(BitConverter.ToUInt64(buffer, (int)offset + 2)); if (size > WebSocket.MaxPayload) { throw new WebSocketException(WebSocketStatus.PayloadTooLarge); } mPayloadLen = (uint)size; } // decode all the control bits IsFinal = (codeByte & (byte)Flag.Fin) == (byte)Flag.Fin; OpCode = (WebSocketOpCode)(codeByte & (byte)Flag.Op); if ((codeByte & (byte)Flag.Rsv) != 0) { throw new WebSocketException(WebSocketStatus.ProtocolError); } // read mask key if (IsMasked) { Array.Copy(buffer, offset + headerSize - 4, mMask, 0, 4); } // if no payload for this message then we're done (presumably this is a control frame) if (mPayloadLen == 0) { mState = Reading.Complete; return(headerSize); } // otherwise start reading the payload body mState = Reading.Payload; Payload = new byte[mPayloadLen]; // return total number of bytes consumed from the buffer var numBytesOfBodyRead = ReadPayload(buffer, offset + headerSize, numBytesAvailable - headerSize); return(headerSize + numBytesOfBodyRead); }
/// <summary> /// Marshals an array of byte to a managed object. /// </summary> /// <param name="byteArray">The array of bytes corresponding to a managed object.</param> /// <returns>A managed object.</returns> public unsafe static T ByteArrayToObject(byte[] byteArray) { var requiresMarshal = MarshalCache <T> .TypeRequiresMarshal; var size = requiresMarshal ? MarshalCache <T> .Size : Unsafe.SizeOf <T>(); fixed(byte *b = byteArray) { if (requiresMarshal) { return(Marshal.PtrToStructure <T>(new IntPtr(b))); } return(Unsafe.Read <T>(b)); } #if false // We'll tried to avoid marshalling as it really slows the process // First, check if the type can be converted without marhsalling switch (TypeCode) { case TypeCode.Object: if (IsIntPtr) { switch (byteArray.Length) { case 1: return ((T) (object) new IntPtr(BitConverter.ToInt32(new byte[] { byteArray[0], 0x0, 0x0, 0x0 }, 0))); case 2: return ((T) (object) new IntPtr( BitConverter.ToInt32(new byte[] { byteArray[0], byteArray[1], 0x0, 0x0 }, 0))); case 4: return((T)(object)new IntPtr(BitConverter.ToInt32(byteArray, 0))); case 8: return((T)(object)new IntPtr(BitConverter.ToInt64(byteArray, 0))); } } break; case TypeCode.Boolean: return((T)(object)BitConverter.ToBoolean(byteArray, 0)); case TypeCode.Byte: return((T)(object)byteArray[0]); case TypeCode.Char: return((T)(object)Encoding.UTF8.GetChars(byteArray)[0]); //BitConverter.ToChar(byteArray, 0); case TypeCode.Double: return((T)(object)BitConverter.ToDouble(byteArray, 0)); case TypeCode.Int16: return((T)(object)BitConverter.ToInt16(byteArray, 0)); case TypeCode.Int32: return((T)(object)BitConverter.ToInt32(byteArray, 0)); case TypeCode.Int64: return((T)(object)BitConverter.ToInt64(byteArray, 0)); case TypeCode.Single: return((T)(object)BitConverter.ToSingle(byteArray, 0)); case TypeCode.String: throw new InvalidCastException("This method doesn't support string conversion."); case TypeCode.UInt16: return((T)(object)BitConverter.ToUInt16(byteArray, 0)); case TypeCode.UInt32: return((T)(object)BitConverter.ToUInt32(byteArray, 0)); case TypeCode.UInt64: return((T)(object)BitConverter.ToUInt64(byteArray, 0)); } // Check if it's not a common type // Allocate a block of unmanaged memory using (var unmanaged = new LocalUnmanagedMemory(Size)) { // Write the array of bytes inside the unmanaged memory unmanaged.Write(byteArray); // Return a managed object created from the block of unmanaged memory return(unmanaged.Read <T>()); } #endif }
/// <summary> /// Changes the endianness of the value. /// </summary> /// <param name="value">The value to change the endianness of.</param> /// <returns>The value with endianness changed.</returns> public static ulong ChangeEndianness(this ulong value) { byte[] bytes = BitConverter.GetBytes(value); Array.Reverse(bytes); return(BitConverter.ToUInt64(bytes, 0)); }
public static void HandleAllAchievementCriteriaDataAccount(Packet packet) { var count = packet.ReadBits("Criteria count", 19); var counter = new byte[count][]; var accountId = new byte[count][]; var flags = new byte[count]; for (var i = 0; i < count; ++i) { counter[i] = new byte[8]; accountId[i] = new byte[8]; counter[i][2] = packet.ReadBit(); accountId[i][0] = packet.ReadBit(); counter[i][0] = packet.ReadBit(); accountId[i][1] = packet.ReadBit(); flags[i] = (byte)(packet.ReadBits(4) & 0xFFu); accountId[i][5] = packet.ReadBit(); accountId[i][7] = packet.ReadBit(); counter[i][7] = packet.ReadBit(); counter[i][6] = packet.ReadBit(); accountId[i][4] = packet.ReadBit(); accountId[i][2] = packet.ReadBit(); counter[i][4] = packet.ReadBit(); accountId[i][3] = packet.ReadBit(); accountId[i][6] = packet.ReadBit(); counter[i][3] = packet.ReadBit(); counter[i][5] = packet.ReadBit(); counter[i][1] = packet.ReadBit(); } for (var i = 0; i < count; ++i) { packet.ReadXORByte(accountId[i], 0); packet.ReadXORByte(counter[i], 4); packet.ReadXORByte(accountId[i], 2); packet.ReadXORByte(counter[i], 0); packet.ReadPackedTime("Time", i); packet.ReadXORByte(accountId[i], 6); packet.ReadInt32("Criteria ID", i); packet.ReadXORByte(accountId[i], 5); packet.ReadXORByte(counter[i], 1); packet.ReadXORByte(counter[i], 2); packet.ReadXORByte(counter[i], 3); packet.ReadXORByte(accountId[i], 4); packet.ReadXORByte(accountId[i], 1); packet.ReadXORByte(accountId[i], 7); packet.ReadXORByte(counter[i], 5); packet.ReadUInt32("Timer 1", i); packet.ReadXORByte(counter[i], 7); packet.ReadXORByte(accountId[i], 3); packet.ReadUInt32("Timer 2", i); packet.ReadXORByte(counter[i], 6); packet.AddValue("Criteria Flags", flags[i], i); packet.AddValue("Criteria Counter", BitConverter.ToUInt64(counter[i], 0), i); packet.AddValue("Account", i, BitConverter.ToUInt64(accountId[i], 0), i); } }
public static ulong ToUnsignedLong(object value) { var resultBytes = GetBytes(value, 8, false); return(BitConverter.ToUInt64(resultBytes, 0)); }
public static void HandleInspectAchievementDataResponse(Packet packet) { var guid = new byte[8]; var criterias = packet.ReadBits("Criterias", 19); var achievements = packet.ReadBits("Achievements", 20); var flags = new uint[criterias]; var counter = new byte[criterias][]; var guid2 = new byte[criterias][]; for (var i = 0; i < criterias; ++i) { counter[i] = new byte[8]; guid2[i] = new byte[8]; counter[i][5] = packet.ReadBit(); flags[i] = packet.ReadBits(4); guid2[i][4] = packet.ReadBit(); counter[i][6] = packet.ReadBit(); guid2[i][6] = packet.ReadBit(); guid2[i][1] = packet.ReadBit(); counter[i][0] = packet.ReadBit(); guid2[i][5] = packet.ReadBit(); counter[i][7] = packet.ReadBit(); guid2[i][2] = packet.ReadBit(); counter[i][1] = packet.ReadBit(); guid2[i][7] = packet.ReadBit(); counter[i][2] = packet.ReadBit(); counter[i][3] = packet.ReadBit(); guid2[i][0] = packet.ReadBit(); counter[i][4] = packet.ReadBit(); guid2[i][3] = packet.ReadBit(); } guid[1] = packet.ReadBit(); guid[7] = packet.ReadBit(); var guid5 = new byte[achievements][]; for (var i = 0; i < achievements; ++i) { guid5[i] = new byte[8]; guid5[i][4] = packet.ReadBit(); guid5[i][3] = packet.ReadBit(); guid5[i][0] = packet.ReadBit(); guid5[i][6] = packet.ReadBit(); guid5[i][2] = packet.ReadBit(); guid5[i][5] = packet.ReadBit(); guid5[i][1] = packet.ReadBit(); guid5[i][7] = packet.ReadBit(); } guid[3] = packet.ReadBit(); guid[5] = packet.ReadBit(); guid[6] = packet.ReadBit(); guid[0] = packet.ReadBit(); guid[4] = packet.ReadBit(); guid[2] = packet.ReadBit(); packet.ReadXORByte(guid, 2); for (var i = 0; i < achievements; ++i) { packet.ReadXORByte(guid5[i], 3); packet.ReadXORByte(guid5[i], 0); packet.ReadInt32("Realm Id", i); packet.ReadInt32("Realm Id", i); packet.ReadXORByte(guid5[i], 4); packet.ReadUInt32("Achievement Id", i); packet.ReadPackedTime("Achievement Time", i); packet.ReadXORByte(guid5[i], 7); packet.ReadXORByte(guid5[i], 5); packet.ReadXORByte(guid5[i], 1); packet.ReadXORByte(guid5[i], 6); packet.ReadXORByte(guid5[i], 2); packet.WriteGuid("Player GUID", guid2[i], i); } for (var i = 0; i < criterias; ++i) { packet.ReadUInt32("Criteria Timer 2", i); packet.ReadXORByte(guid2[i], 3); packet.ReadXORByte(counter[i], 5); packet.ReadXORByte(guid2[i], 6); packet.ReadXORByte(guid2[i], 4); packet.ReadXORByte(counter[i], 4); packet.ReadXORByte(counter[i], 7); packet.ReadUInt32("Criteria Id", i); packet.ReadXORByte(counter[i], 0); packet.ReadXORByte(counter[i], 1); packet.ReadXORByte(guid2[i], 0); packet.ReadXORByte(guid2[i], 1); packet.ReadUInt32("Criteria Timer 1", i); packet.ReadXORByte(guid2[i], 2); packet.ReadXORByte(guid2[i], 7); packet.ReadXORByte(guid2[i], 5); packet.ReadXORByte(counter[i], 2); packet.ReadPackedTime("Criteria Time", i); packet.ReadXORByte(counter[i], 6); packet.ReadXORByte(counter[i], 3); packet.AddValue("Criteria Flags", flags[i], i); packet.AddValue("Criteria Counter", BitConverter.ToUInt64(counter[i], 0), i); packet.WriteGuid("Criteria GUID", guid2[i], i); } packet.ReadXORByte(guid, 1); packet.ReadXORByte(guid, 4); packet.ReadXORByte(guid, 5); packet.ReadXORByte(guid, 3); packet.ReadXORByte(guid, 6); packet.ReadXORByte(guid, 0); packet.ReadXORByte(guid, 7); packet.WriteGuid("GUID", guid); }
public static void DecompressDxt5Block(byte[] Data, int Width, int Height, int pos, byte[] output, int xPos, int yPos) { if (pos >= Data.Length) return; Color[] c = new Color[4]; byte[] alpha = new byte[8]; var alpha0 = Data[pos]; var alpha1 = Data[pos + 1]; var alphaMask = BitConverter.ToUInt64(Data, pos) >> 16; var color0 = BitConverter.ToUInt16(Data, pos + 8); var color1 = BitConverter.ToUInt16(Data, pos + 10); var mask = BitConverter.ToUInt32(Data, pos + 12); alpha[0] = alpha0; alpha[1] = alpha1; if (alpha[0] > alpha[1]) { alpha[2] = (byte)((6 * alpha[0] + 1 * alpha[1] + 3) / 7); alpha[3] = (byte)((5 * alpha[0] + 2 * alpha[1] + 3) / 7); alpha[4] = (byte)((4 * alpha[0] + 3 * alpha[1] + 3) / 7); alpha[5] = (byte)((3 * alpha[0] + 4 * alpha[1] + 3) / 7); alpha[6] = (byte)((2 * alpha[0] + 5 * alpha[1] + 3) / 7); alpha[7] = (byte)((1 * alpha[0] + 6 * alpha[1] + 3) / 7); } else { alpha[2] = (byte)((4 * alpha[0] + 1 * alpha[1] + 2) / 5); alpha[3] = (byte)((3 * alpha[0] + 2 * alpha[1] + 2) / 5); alpha[4] = (byte)((2 * alpha[0] + 3 * alpha[1] + 2) / 5); alpha[5] = (byte)((1 * alpha[0] + 4 * alpha[1] + 2) / 5); alpha[6] = 0; alpha[7] = 255; } Color(color0, ref c[0]); Color(color1, ref c[1]); c[2].R = (byte)((2 * c[0].R + c[1].R) / 3); c[2].G = (byte)((2 * c[0].G + c[1].G) / 3); c[2].B = (byte)((2 * c[0].B + c[1].B) / 3); c[3].R = (byte)((c[0].R + 2 * c[1].R) / 3); c[3].G = (byte)((c[0].G + 2 * c[1].G) / 3); c[3].B = (byte)((c[0].B + 2 * c[1].B) / 3); for (int y = 0; y < 4; y++) { for (int x = 0; x < 4; x++) { var index = mask & 3; mask >>= 2; var alphaIndex = alphaMask & 7; alphaMask >>= 3; var col = c[index]; var x2 = xPos + x; var y2 = yPos + y; var offset = (x2 + y2 * Width) * 4; output[offset] = col.B; output[offset + 1] = col.G; output[offset + 2] = col.R; output[offset + 3] = alpha[alphaIndex]; } } }
public static void HandleAllAchievementDataPlayer(Packet packet) { var bits20 = packet.ReadBits("Criteria count", 19); var counter = new byte[bits20][]; var guid2 = new byte[bits20][]; var flags = new byte[bits20]; for (var i = 0; i < bits20; ++i) { counter[i] = new byte[8]; guid2[i] = new byte[8]; counter[i][3] = packet.ReadBit(); counter[i][6] = packet.ReadBit(); guid2[i][0] = packet.ReadBit(); guid2[i][7] = packet.ReadBit(); counter[i][7] = packet.ReadBit(); counter[i][0] = packet.ReadBit(); counter[i][5] = packet.ReadBit(); flags[i] = (byte)(packet.ReadBits(4) & 0xFFu); counter[i][4] = packet.ReadBit(); guid2[i][3] = packet.ReadBit(); guid2[i][6] = packet.ReadBit(); guid2[i][4] = packet.ReadBit(); guid2[i][5] = packet.ReadBit(); guid2[i][1] = packet.ReadBit(); counter[i][2] = packet.ReadBit(); counter[i][1] = packet.ReadBit(); guid2[i][2] = packet.ReadBit(); } var bits10 = packet.ReadBits("Achievement count", 20); var guid1 = new byte[bits10][]; for (var i = 0; i < bits10; ++i) { guid1[i] = new byte[8]; packet.StartBitStream(guid1[i], 4, 7, 2, 3, 1, 5, 6, 0); } for (var i = 0; i < bits10; ++i) { packet.ReadXORByte(guid1[i], 6); packet.ReadXORByte(guid1[i], 5); packet.ReadXORByte(guid1[i], 3); packet.ReadXORByte(guid1[i], 0); packet.ReadXORByte(guid1[i], 2); packet.ReadXORByte(guid1[i], 1); packet.ReadUInt32("Achievement Id", i); packet.ReadInt32("Realm Id", i); packet.ReadInt32("Realm Id", i); packet.ReadXORByte(guid1[i], 4); packet.ReadPackedTime("Time", i); packet.ReadXORByte(guid1[i], 7); packet.WriteGuid("Guid3", guid1[i], i); } for (var i = 0; i < bits20; ++i) { packet.ReadPackedTime("Time", i); packet.ReadXORByte(counter[i], 2); packet.ReadXORByte(guid2[i], 2); packet.ReadXORByte(guid2[i], 3); packet.ReadInt32("Criteria ID", i); packet.ReadXORByte(guid2[i], 5); packet.ReadXORByte(counter[i], 4); packet.ReadXORByte(counter[i], 7); packet.ReadXORByte(counter[i], 0); packet.ReadXORByte(guid2[i], 0); packet.ReadUInt32("Timer 1", i); packet.ReadXORByte(counter[i], 1); packet.ReadXORByte(counter[i], 3); packet.ReadXORByte(counter[i], 6); packet.ReadXORByte(counter[i], 5); packet.ReadXORByte(guid2[i], 4); packet.ReadXORByte(guid2[i], 6); packet.ReadXORByte(guid2[i], 1); packet.ReadXORByte(guid2[i], 7); packet.ReadUInt32("Timer 2", i); packet.WriteGuid("Guid2", guid2[i], i); packet.AddValue("Criteria Flags", flags[i], i); packet.AddValue("Criteria Counter", BitConverter.ToUInt64(counter[i], 0), i); packet.WriteGuid("Criteria GUID", guid2[i], i); } }
public static UInt64 ReadUInt64BE(this BinaryReader binRdr) { return(BitConverter.ToUInt64(binRdr.ReadBytesRequired(sizeof(UInt64)).Reverse(), 0)); }
protected override void HandleData(byte[] data) { byte b; long len; for (long i = 0; i < data.LongLength;) { switch (State) { case FrameParserState.Head1: b = data[i++]; bool fin = Incoming.FIN = (b & 128) == 128; bool rsv1 = Incoming.RSV1 = (b & 64) == 64; bool rsv2 = Incoming.RSV2 = (b & 32) == 32; bool rsv3 = Incoming.RSV3 = (b & 16) == 16; Incoming.Opcode = (byte)(b - (fin ? 128 : 0) - (rsv1 ? 64 : 0) - (rsv2 ? 32 : 0) - (rsv3 ? 16 : 0)); State = FrameParserState.Head2; break; case FrameParserState.Head2: b = data[i++]; bool masked = (b & 128) == 128; if (masked) { Incoming.Mask = new byte[4]; } long payloadLen = b - (masked ? 128 : 0); if (payloadLen > 125) { Temp2 = new byte[payloadLen == 126 ? 2 : 8]; State = FrameParserState.ExtendedLen; } else { Incoming.Payload = new byte[payloadLen]; State = Incoming.Masked ? FrameParserState.Mask : FrameParserState.Payload; } break; case FrameParserState.ExtendedLen: len = Math.Min(Temp2.LongLength - Temp1, data.LongLength - i); Frame.ArrayCopy(data, i, Temp2, Temp1, len); Temp1 += len; i += len; if (Temp2.LongLength != Temp1) { break; } Incoming.Payload = new byte[Temp1 == 8 ? BitConverter.ToUInt64(Temp2, 0) : BitConverter.ToUInt16(Temp2, 0)]; Temp1 = 0; Temp2 = null; State = Incoming.Masked ? FrameParserState.Mask : FrameParserState.Payload; break; case FrameParserState.Mask: len = Math.Min(4 - Temp1, data.LongLength - i); Frame.ArrayCopy(data, i, Incoming.Mask, Temp1, len); Temp1 += len; i += len; if (Temp1 != 4) { break; } Temp1 = 0; State = FrameParserState.Payload; break; case FrameParserState.Payload: len = Math.Min(Incoming.PayloadLength - Temp1, data.LongLength - i); Frame.ArrayCopy(data, i, Incoming.Payload, Temp1, len); Temp1 += len; i += len; if (Temp1 != Incoming.PayloadLength) { break; } if (Incoming.Masked) { Incoming.FlipMask(); } PushIncoming(); State = FrameParserState.Head1; Temp1 = 0; break; } } }