public void TransmitStream(BKSystem.IO.BitStream data, int player) { if (m_clients[player] != null && m_clients[player].Connected) { // Pad the data by 1 bit ??? data.Write(0); // Send how large the data is in the first 32 bits byte[] sendData = data.ToByteArray(); int sendLength = IPAddress.HostToNetworkOrder(sendData.Length); byte[] lengthData = BitConverter.GetBytes(sendLength); // Choose the stream to use NetworkStream stream; stream = m_clients[player].GetStream(); stream.Flush(); stream.Write(lengthData, 0, lengthData.Length); //Debug.Log("Sending " + sendData.Length + " bytes to player " + player); // Then send the data stream.Write(sendData, 0, sendData.Length); } else { Debug.LogWarning("Attempting to transmit data while disconnected"); } }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.SET_PLAYER_ID, 0, 16); packet.Write((byte)m_playerID); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)SGCommandID.SEND_DECK, 0, 16); packet.Write(m_deck); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)SGCommandID.PLAY_CARD_FROM_HAND, 0, 16); packet.Write((ushort)m_cardID, 0, 16); return(packet); }
public CGCommand ReceiveCommand() { NetworkStream stream = m_client.GetStream(); while (stream.DataAvailable) { //Debug.Log("Data available! Reading stream..."); // Decode the first 32 bits to find the length of the remaining data byte[] dataSizeBytes = new byte[4]; stream.Read(dataSizeBytes, 0, 4); int dataSize = BitConverter.ToInt32(dataSizeBytes, 0); dataSize = IPAddress.NetworkToHostOrder(dataSize); //Debug.Log("Received data of size " + dataSize + " bytes"); // Receive the data // Convert size to bytes byte[] data = new byte[dataSize]; stream.Read(data, 0, dataSize); // Put the data into a BitStream BKSystem.IO.BitStream serverStream = new BKSystem.IO.BitStream(dataSize * 8); serverStream.Write(data); if (serverStream.Length > 0) { return(CGCommand.CreateCommandFromPacket(serverStream)); } } return(null); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.CAST_SPELL, 0, 16); packet.Write((ushort)m_cardID, 0, 16); packet.Write((byte)m_casterID); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.MOVE_CARD_TO_GRAVEYARD, 0, 16); packet.Write((byte)m_playerID); packet.Write((ushort)m_cardID, 0, 16); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.PHASE_TRANSITION, 0, 16); packet.Write(m_text.Length, 0, 8); packet.Write(m_text.ToCharArray(), 0, m_text.Length); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.OPPONENT_PLAY_CARD_FROM_HAND, 0, 16); packet.Write(m_cardData); packet.Write((ushort)m_cardID, 0, 16); packet.Write((ushort)m_channel, 0, 5); return(packet); }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { int textLength; packet.Read(out textLength, 0, 8); char[] text = new char[textLength]; packet.Read(text, 0, textLength); m_text = new string(text); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.PLAYER_DRAW_CARD, 0, 16); packet.Write(m_cardData); packet.Write((ushort)m_cardID, 0, 16); Debug.Log("Sending card " + m_cardData.cardName + " with ID " + m_cardID); return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.WAIT_FOR_CAST_SELECTION, 0, 16); packet.Write((ushort)m_castableCards.Count, 0, 16); foreach (CastableCard card in m_castableCards) { packet.Write(card); } return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)SGCommandID.CAST_SPELL_FROM_0, 0, 16); packet.Write((ushort)m_cardID, 0, 16); packet.Write(m_targetID >= 0); if (m_targetID >= 0) { packet.Write((ushort)m_targetID, 0, 16); } return(packet); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.WAIT_FOR_PLAY_FROM_HAND, 0, 16); packet.Write((byte)m_playerID); packet.Write((ushort)m_playableCards.Count, 0, 16); foreach (int card in m_playableCards) { packet.Write((ushort)card, 0, 16); } return(packet); }
public Item(byte[] itemData) { if (itemData[0] != 'J' || itemData[1] != 'M') { throw new Exception("Item data missing JM header"); } bs = new BitStream(itemData); ReadItemData(); ReadRemainingBits(); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.CHANNEL_SPELL, 0, 16); packet.Write(m_data.Count, 0, 16); foreach (SpellChannelData data in m_data) { packet.Write((ushort)data.cardID, 0, 16); packet.Write((byte)data.playerID); packet.Write((ushort)data.newChannel, 0, 5); } return(packet); }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { int dataCount; packet.Read(out dataCount, 0, 16); for (int i = 0; i < dataCount; i++) { SpellChannelData data = new SpellChannelData(); packet.Read(out data.cardID, 0, 16); packet.Read(out data.playerID, 0, 8); packet.Read(out data.newChannel, 0, 5); m_data.Add(data); } }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { m_castableCards = new List <CastableCard>(); int numCards; packet.Read(out numCards, 0, 16); for (int i = 0; i < numCards; i++) { CastableCard card; packet.Read(out card); m_castableCards.Add(card); } }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { m_playableCards = new List <int>(); int numCards; packet.Read(out m_playerID, 0, 8); packet.Read(out numCards, 0, 16); for (int i = 0; i < numCards; i++) { int cardID; packet.Read(out cardID, 0, 16); m_playableCards.Add(cardID); } }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { packet.Read(out m_cardID, 0, 16); bool hasTarget; packet.Read(out hasTarget); if (hasTarget) { packet.Read(out m_targetID, 0, 16); } else { m_targetID = -1; } }
public static SGCommand CreateCommandFromPacket(BKSystem.IO.BitStream packet, int playerID) { if (packet.Length < 0) { return(null); } ushort commandID; packet.Position = 0; packet.Read(out commandID, 0, 16); Debug.Log("Read packet with server command ID: " + commandID); SGCommand command; switch (commandID) { case 1: command = new SGC_CastSpellFromChannel0(packet, playerID); break; case 2: command = new SGC_PlayCardFromHand(packet, playerID); break; case 3: command = new SGC_SendDeck(packet, playerID); break; case 4: command = new SGC_RefreshTimeout(packet, playerID); break; default: command = null; break; } command.m_ID = (SGCommandID)commandID; return(command); }
public void TransmitStream(BKSystem.IO.BitStream data) { if (m_client.Connected) { // Pad the data by 1 bit ??? data.Write(0); // Send how large the data is in the first 32 bits byte[] sendData = data.ToByteArray(); int sendLength = IPAddress.HostToNetworkOrder(sendData.Length); byte[] lengthData = BitConverter.GetBytes(sendLength); m_client.GetStream().Flush(); m_client.GetStream().Write(lengthData, 0, lengthData.Length); Debug.Log("Sending " + sendData.Length + " bytes to server"); // Then send the data m_client.GetStream().Write(sendData, 0, sendData.Length); } }
public Item(byte[] itemData) { if (!IsPacketData && itemData[0] != 'J' && itemData[1] != 'M') { throw new Exception("Item data missing JM header"); } if(IsPacketData && itemData[0] != 0x9c && itemData[0] != 0x9d) { throw new Exception("Attempting to parse a non-item packet!"); } bs = new BitStream(itemData); if (!IsPacketData) { // Skip 'JM' Header bs.SkipBits(16); } ReadItemData(); ReadRemainingBits(); }
public SGCommand ReceiveStream(int player) { NetworkStream stream; if (m_clients[player] != null && m_clients[player].Connected) { stream = m_clients[player].GetStream(); } else { Debug.LogWarning("Trying to receive stream from disconnected player " + player); return(null); } if (stream.DataAvailable) { // Decode the first 32 bits to find the length of the remaining data byte[] dataSizeBytes = new byte[4]; stream.Read(dataSizeBytes, 0, 4); int dataSize = BitConverter.ToInt32(dataSizeBytes, 0); dataSize = IPAddress.NetworkToHostOrder(dataSize); //Debug.Log("Received data of size " + dataSize + " bytes"); // Receive the data // Convert size to bytes byte[] data = new byte[dataSize]; stream.Read(data, 0, dataSize); // Put the data into a BitStream BKSystem.IO.BitStream clientStream = new BKSystem.IO.BitStream(dataSize * 8); clientStream.Write(data); if (clientStream.Length > 0) { return(SGCommand.CreateCommandFromPacket(clientStream, player)); } } return(null); }
public PayloadTelemetryValue(BitStream bs) : base(bs) { }
public CGC_ChannelSpell(BKSystem.IO.BitStream packet) { UnpackCommand(packet); }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { // Nothing to unpack }
public CGC_OpponentDrawCard(BKSystem.IO.BitStream packet) { UnpackCommand(packet); }
public Telemetry(byte[] raw) { this.originalpacketlength = raw.Length; if (Telemetry.logHeaderLine) { Console.WriteLine("UTCTime,"); } else if (this.originalpacketlength > 0) { Console.WriteLine(string.Format("{0} {1},", System.DateTime.UtcNow.ToShortDateString(), System.DateTime.UtcNow.ToLongTimeString())); } if (raw.Length == 0) { return; } BitStream bitStream = new BitStream(); bitStream.Write(raw); bitStream.Position = 0L; this.Set(Telemetry.DataIndex.SatelliteId, new SatelliteIdTelemetryValue(this.Get2bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.FrameId, new FrameIdTelemetryValue(this.Get6bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.PanelVoltX, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PanelVoltY, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PanelVoltZ, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PanelCurrentTotal, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.BattVolt0, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.BattCurrentBus, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RebootCount, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.EpsErrorCount, new RawTelemetryValue(this.Get16bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.EpsTemp1, new RawTelemetryValue(this.Get8bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.EpsTemp2, new RawTelemetryValue(this.Get8bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.EpsTemp3, new RawTelemetryValue(this.Get8bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.BattTemp0, new RawTelemetryValue(this.Get8bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.LatchCount5_0, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.LatchCount3_3, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.ResetCause, new EPSResetcauseTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PptTrackingMode, new EPSPowerTrackingTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.AsibSunSensorX1, new SunSensorTelemetryValue(this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibSunSensorY1, new SunSensorTelemetryValue(this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibSunSensorZ1, new SunSensorTelemetryValue(this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibPanelTempX1, new MultiplierOffsetTelemetryValue(-0.2073, 158.239, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibPanelTempX2, new MultiplierOffsetTelemetryValue(-0.2083, 159.227, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibPanelTempY1, new MultiplierOffsetTelemetryValue(-0.2076, 158.656, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibPanelTempY2, new MultiplierOffsetTelemetryValue(-0.2087, 159.045, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibBusVolt3_3, new MultiplierTelemetryValue(4.0, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibBusCurrent3_3, new MultiplierTelemetryValue(1.0, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.AsibBusVolt5_0, new MultiplierTelemetryValue(6.0, this.Get10bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.RfReceiverDoppler, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RfReceiverRSSI, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RfTemp, new MultiplierOffsetTelemetryValue(-0.857, 193.672, this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RfReceiveCurrent, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RfTransmitCurrent3_3, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.RfTransmitCurrent5_0, new RawTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PaReversePower, new PaPowerTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PaForwardPower, new PaPowerTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PaTemperature, new PaTemperatureTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.PaCurrent, new PaCurrentTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.AntTempA, new AntsTemperatureTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.AntTempB, new AntsTemperatureTelemetryValue(this.Get8bitsAsUInt(bitStream))); this.Set(Telemetry.DataIndex.AntDeploy1, new AntsDeployTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.AntDeploy2, new AntsDeployTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.AntDeploy3, new AntsDeployTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.AntDeploy4, new AntsDeployTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.SequenceNumber, new RawTelemetryValue(this.Get24bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.DtmfCommandCount, new RawTelemetryValue(this.Get6bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.DtmfLastCommand, new RawTelemetryValue(this.Get5bitsAsInt(bitStream))); this.Set(Telemetry.DataIndex.DtmfCommandSuccess, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidBob, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidEps, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidPa, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidRf, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidMse, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidAnts2, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DataValidAnts1, new DeviceDataValidTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.InEclipse, new RawTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.InSafeMode, new RawTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.HardwareABF, new BoolOnOffTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.SoftwareABF, new SoftwareAbfTelemetryValue(this.Get1bitAsInt(bitStream))); this.Set(Telemetry.DataIndex.DeployWait, new BoolOnOffTelemetryValue(this.Get1bitAsInt(bitStream))); bitStream.Position = 448L; BitStream bitStream2 = new BitStream(1600L); for (int i = 0; i < 200; i++) { bitStream2.WriteByte((byte)bitStream.ReadByte()); } bitStream2.Position = 0L; this.Set(Telemetry.DataIndex.Payload, new PayloadTelemetryValue(bitStream2)); if (this.originalpacketlength > 0) { Console.WriteLine(string.Empty); } if (Settings.Default.LoggingEnabled) { Telemetry.logHeaderLine = false; } }
public override void UnpackCommand(BKSystem.IO.BitStream packet) { // Nothing to unpack (in the future this could include deck restrictions) }
/// <summary> /// Performs a bitwise <b>NOT</b> operation on the <b>bits</b> in the /// current stream. /// </summary> /// <exception cref="System.ObjectDisposedException"> /// The current stream is closed. /// </exception> /// <remarks> /// . /// </remarks> /// <returns> /// A <see cref="BitStream"/> object containing the result of the bitwise /// <b>NOT</b> operation on the <b>bits</b> in the current stream. /// </returns> /// <seealso cref="BitStream"/> public virtual BitStream Not() { if (!_blnIsOpen) throw new ObjectDisposedException(BitStreamResources.GetString("ObjectDisposed_BitStreamClosed")); // Create the new BitStream var bstrmNew = new BitStream(_uiBitBuffer_Length); uint uiWholeUInt32Lengths = _uiBitBuffer_Length >> BitBuffer_SizeOfElement_Shift; uint uiCounter = 0; for (uiCounter = 0; uiCounter < uiWholeUInt32Lengths; uiCounter++) bstrmNew._auiBitBuffer[uiCounter] = ~_auiBitBuffer[uiCounter]; // Are there any further bits in the buffer? if ((_uiBitBuffer_Length & BitBuffer_SizeOfElement_Mod) > 0) { uint uiBitMask = uint.MaxValue << (int) (BitBuffer_SizeOfElement - (_uiBitBuffer_Length & BitBuffer_SizeOfElement_Mod)); bstrmNew._auiBitBuffer[uiCounter] = ~_auiBitBuffer[uiCounter] & uiBitMask; } return bstrmNew; }
private static void writeCellData(byte[] cell, byte[] lastframecell, uint[] palette, BitStream cellDeltaEncoding, BitStream pixelData) { int count = 0; int numpixels = cell.Length; int delta = 0; byte[] pixels = new byte[16]; for (int i = 0; i < numpixels; i++) { if (isPixelDifferent(cell[i], lastframecell[i], palette, maxBitsDifferentForPalette)) { delta |= (1 << i); pixels[count] = cell[i]; count++; } } cellDeltaEncoding.Write(delta, 0, numpixels); bitswrittenCellDelta += numpixels; pixelData.Write(pixels, 0, count); bitswrittenCellData += count * 8; if (count == 0) emptycellswritten++; }
public virtual BitStream Not() { if (!this._blnIsOpen) { throw new System.ObjectDisposedException(BitStream.BitStreamResources.GetString("ObjectDisposed_BitStreamClosed")); } BitStream bitStream = new BitStream((long)((ulong)this._uiBitBuffer_Length)); uint num = this._uiBitBuffer_Length >> 5; uint num2; for (num2 = 0u; num2 < num; num2 += 1u) { bitStream._auiBitBuffer[(int)((System.UIntPtr)num2)] = ~this._auiBitBuffer[(int)((System.UIntPtr)num2)]; } if ((this._uiBitBuffer_Length & 31u) > 0u) { uint num3 = 4294967295u << (int)(32u - (this._uiBitBuffer_Length & 31u)); bitStream._auiBitBuffer[(int)((System.UIntPtr)num2)] = (~this._auiBitBuffer[(int)((System.UIntPtr)num2)] & num3); } return bitStream; }
/// <summary> /// Performs a bitwise e<b>X</b>clusive <b>OR</b> operation on the /// <b>bits</b> in the current stream against the corresponding <b>bits</b> /// in the specified stream. /// </summary> /// <exception cref="System.ObjectDisposedException"> /// The current stream is closed. /// </exception> /// <exception cref="System.ArgumentNullException"> /// <i>bits</i> is a null reference (<b>Nothing</b> in Visual Basic). /// </exception> /// <exception cref="System.ArgumentException"> /// The stream specified by the <i>bits</i> parameter and the current /// stream do not have the same number of <b>bits</b>. /// </exception> /// <remarks> /// . /// </remarks> /// <param name="bits"> /// A <see cref="BitStream"/> object with which to perform the bitwise /// e<b>X</b>clusive <b>OR</b> operation. /// </param> /// <returns> /// A <see cref="BitStream"/> object containing the result of the bitwise /// e<b>X</b>clusive <b>OR</b> operation on the <b>bits</b> in the current /// stream against the corresponding <b>bits</b> in the specified stream. /// </returns> /// <seealso cref="BitStream"/> public virtual BitStream Xor(BitStream bits) { if (!_blnIsOpen) throw new ObjectDisposedException(BitStreamResources.GetString("ObjectDisposed_BitStreamClosed")); if (bits == null) throw new ArgumentNullException("bits", BitStreamResources.GetString("ArgumentNull_BitStream")); if (bits.Length != _uiBitBuffer_Length) throw new ArgumentException(BitStreamResources.GetString("Argument_DifferentBitStreamLengths")); // Create the new BitStream BitStream bstrmNew = new BitStream(_uiBitBuffer_Length); uint uiWholeUInt32Lengths = _uiBitBuffer_Length >> BitBuffer_SizeOfElement_Shift; uint uiCounter = 0; for (uiCounter = 0; uiCounter < uiWholeUInt32Lengths; uiCounter++) bstrmNew._auiBitBuffer[uiCounter] = _auiBitBuffer[uiCounter] ^ bits._auiBitBuffer[uiCounter]; // Are there any further bits in the buffer? if ((_uiBitBuffer_Length & BitBuffer_SizeOfElement_Mod) > 0) { uint uiBitMask = uint.MaxValue << (int)(BitBuffer_SizeOfElement - (_uiBitBuffer_Length & BitBuffer_SizeOfElement_Mod)); bstrmNew._auiBitBuffer[uiCounter] = _auiBitBuffer[uiCounter] ^ bits._auiBitBuffer[uiCounter] & uiBitMask; } return bstrmNew; }
/// <summary> /// Writes an item property to the BitStream /// </summary> /// <param name="bs">Bitstream to write property to</param> /// <param name="property">Property to write</param> private void WriteItemProperty(BitStream bs, PropertyInfo property) { if (property.ID == 0x1ff) { bs.WriteReversed(property.ID, 9); return; } ItemStatCost statCost = ItemDefs.ItemStatCostsById[property.ID]; int fixedValue = property.Value + statCost.SaveAdd; if (!property.IsAdditionalProperty) { bs.WriteReversed(property.ID, 9); } bs.WriteReversed(fixedValue, statCost.SaveBits); if (statCost.SaveParamBits > 0) { bs.WriteReversed(property.ParamValue, statCost.SaveParamBits); } }
private static byte[] buildFrame(int width, int height, BitStream cellMatrix, BitStream cellDeltaEncoding, BitStream pixelData) { int cellWidth = width / 4 + ((width % 4 != 0) ? 1 : 0); int cellHeight = height / 4 + ((height % 4 != 0) ? 1 : 0); byte[] frame = new byte[width * height]; uint[] matrix = cellMatrix.GetBuffer(); uint[] delta = cellDeltaEncoding.GetBuffer(); uint[] pixels = pixelData.GetBuffer(); byte[] matrix2 = byteArrayFromUintArray(matrix); byte[] delta2 = byteArrayFromUintArray(delta); byte[] pixels2 = byteArrayFromUintArray(pixels); byte[] totaldata = new byte[matrix2.Length + delta2.Length + pixels2.Length]; Array.Copy(matrix2, 0, totaldata, 0, matrix2.Length); Array.Copy(delta2, 0, totaldata, matrix2.Length, delta2.Length); Array.Copy(pixels2, 0, totaldata, matrix2.Length + delta2.Length, pixels2.Length); byte[] compressed = new byte[0x1000000]; int compLength = 0x1000000; UltimaXNA.Network.Compression.Pack(compressed, ref compLength, totaldata, totaldata.Length); int matrixIndex = 0, matrixOffset = 0; int deltaIndex = 0, deltaOffset = 0; int pixelsIndex = 0, pixelsOffset = 0; int cellIndex = 0; bool inEmptyCellSpan = true; bool frameComplete = false; while (!frameComplete) { int matrixCode = valueFromBitStream(matrix, ref matrixIndex, ref matrixOffset, 4); if (inEmptyCellSpan) { cellIndex += matrixCode; inEmptyCellSpan = false; } else { for (int i = 0; i < matrixCode; i++) { int cellX = (cellIndex % cellWidth) * 4; int cellY = (cellIndex / cellWidth) * 4; int cellW = ((width - cellX) >= 4) ? 4 : width - cellX; int cellH = ((height - cellY) >= 4) ? 4 : height - cellY; int deltaCode = valueFromBitStream(delta, ref deltaIndex, ref deltaOffset, cellW * cellH); for (int j = 0; j < cellW * cellH; j++) { if ((deltaCode & deltaBits[j]) != 0) { frame[cellX + (j % cellW) + ((cellY + (j / cellW)) * width)] = (byte)valueFromBitStream(pixels, ref pixelsIndex, ref pixelsOffset, 8); } } cellIndex++; } inEmptyCellSpan = true; } if (cellIndex == cellWidth * cellHeight) frameComplete = true; } return frame; }
/// <summary> /// Converts all stat data into raw data for save file /// </summary> /// <returns>Raw stat data ready for insertion into save file</returns> public byte[] GetStatBytes() { BitStream bits = new BitStream(); bits.WriteReversed('g', 8); bits.WriteReversed('f', 8); var sortedValues = from n in statValues where true orderby n.Key select n; foreach (var stat in sortedValues) { bits.WriteReversed(stat.Key, 9); int valShift = 0; int bitCount = ItemDefs.ItemStatCostsById[stat.Key].CSvBits; if (ItemDefs.ItemStatCostsById.ContainsKey(stat.Key)) { valShift = ItemDefs.ItemStatCostsById[stat.Key].ValShift; } bits.WriteReversed((uint)((stat.Value << valShift)), bitCount); } // Write termining stat index bits.WriteReversed(0x1ff, 9); // Add 0 padding to align to byte, if needed int remainingBitsForAlignment = 8 - (int)(bits.Position % 8); if (remainingBitsForAlignment > 0) { bits.WriteReversed(0, remainingBitsForAlignment); } return bits.ToReversedByteArray(); }
private NetOutgoingMessage CreateAtmosUpdatePacket(BitStream records) { byte[] recs = Compress(records); if (recs == null) return null; NetOutgoingMessage msg = IoCManager.Resolve<ISS13NetServer>().CreateMessage(); msg.Write((byte) NetMessage.AtmosDisplayUpdate); msg.Write((int) records.Length); msg.Write(recs.Length); msg.Write(recs); return msg; }
private uint Get16bitsAsUInt(BitStream bs) { uint result; bs.Read(out result, 0, 16); return result; }
private void SendAtmosUpdatePacket(BitStream records) { NetOutgoingMessage msg = CreateAtmosUpdatePacket(records); if (msg == null) return; IoCManager.Resolve<ISS13NetServer>().SendToAll(msg, NetDeliveryMethod.Unreliable); }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.REQUEST_DECK, 0, 16); return(packet); }
public void SendAtmosStateTo(NetConnection client) { var m = IoCManager.Resolve<IMapManager>(); int numberOfGasTypes = Enum.GetValues(typeof (GasType)).Length; var records = new BitStream(m.GetMapHeight()*m.GetMapWidth()*numberOfGasTypes); int displayBitsWritten = 0; for (int x = 0; x < m.GetMapWidth(); x++) { for (int y = 0; y < m.GetMapHeight(); y++) { Tile t = (Tile)m.GetFloorAt(new Vector2(x * m.GetTileSpacing(), y * m.GetTileSpacing())); if (t == null) continue; displayBitsWritten = t.GasCell.PackDisplayBytes(records, true); } } NetOutgoingMessage msg = CreateAtmosUpdatePacket(records); if (msg == null) return; IoCManager.Resolve<ISS13NetServer>().SendMessage(msg, client, NetDeliveryMethod.ReliableUnordered); }
public SGC_CastSpellFromChannel0(BKSystem.IO.BitStream packet, int playerID) { m_playerID = playerID; UnpackCommand(packet); Debug.Log("Created SGC_CastSpellFromChannel0 with cardID " + m_cardID + "."); }
private static void transform(BinaryReader bin) { FrameXNA[] frames = AnimationsXNA.GetAnimation(bin); BitStream CellMatrixStream = new BitStream(); BitStream CellDeltaEncodingStream = new BitStream(); BitStream CellDataStream = new BitStream(); int width, height, xoffset, yoffset; getWidthHeight(frames, out width, out height, out xoffset, out yoffset); uint[][] pixeldata = new uint[frames.Length][]; for (int i = 0; i < frames.Length; i++) pixeldata[i] = getPixelData(frames[i], width, height, xoffset - frames[i].Center.X, (height + (yoffset - frames[i].Center.Y)) - frames[i].Texture.Height); uint[] palette = new uint[0x100]; uint[] palettesortvalues = new uint[0x100]; uint[] paletteSimilars = new uint[0x100]; for (int i = 0; i < frames.Length; i++) getPalette(pixeldata[i], palette, palettesortvalues); palettesortvalues[0] = int.MaxValue; sortPalette(palette, palettesortvalues); // findSimilarShadesInPalette(palette, ref paletteSimilars); // combinePalette(palette, paletteSimilars, palettesortvalues); // sortPalette(palette, palettesortvalues, paletteSimilars); // debug = count num of pixels using top 16 colors. int topsixteen = 0; int others = 0; for (int i = 1; i < 17; i++) topsixteen += (int)palettesortvalues[i]; for (int i = 17; i < 256; i++) others += (int)palettesortvalues[i]; byte[][] framedata = new byte[frames.Length][]; for (int i = 0; i < frames.Length; i++) framedata[i] = palettedFrame(pixeldata[i], palette, paletteSimilars); for (int i = 0; i < frames.Length; i++) { byte[][] framecells = getCells(framedata[i], width); byte[][] lastFrameCells; if (i > 0) lastFrameCells = getCells(buildFrame(width, height, CellMatrixStream, CellDeltaEncodingStream, CellDataStream), width); else lastFrameCells = new byte[0][]; getStreams(framecells, lastFrameCells, i, width, palette, CellMatrixStream, CellDeltaEncodingStream, CellDataStream); byte[] newframedata = buildFrame(width, height, CellMatrixStream, CellDeltaEncodingStream, CellDataStream); FrameXNA frame = new FrameXNA(AnimationsXNA.DEBUG_GFX, palette, newframedata, width, height, 0, 0); frame.Texture.Save("test.bmp", Microsoft.Xna.Framework.Graphics.ImageFileFormat.Bmp); } int size = (int)(CellMatrixStream.Length >> 3) + (int)(CellDeltaEncodingStream.Length >> 3) + (int)(CellDataStream.Length >> 3); }
/// <summary> /// Function to pack an array of one-byte representations of a given gas's visibility. /// </summary> /// <param name="all">send em all anyway?</param> /// <returns></returns> /// public int PackDisplayBytes(BitStream bits, bool all = false) { int changedTypes = 0; //How many gas types we have! int typesCount = Enum.GetValues(typeof (GasType)).Length; var gasChanges = new byte[typesCount]; int bitCount = typesCount; for (int i = typesCount - 1; i >= 0; i--) { byte amount; var t = (GasType) i; switch (t) { case GasType.Toxin: if (gasMixture.gasses[(int)GasType.Toxin] > 0.00005f && (checkUpdateThreshold(GasType.Toxin) || all)) { amount = (byte)normalizeGasAmount(gasMixture.gasses[(int)GasType.Toxin]); gasChanges[i] = amount; changedTypes = (changedTypes | (1 << i)); lastSentGasses[GasType.Toxin] = gasMixture.gasses[(int)GasType.Toxin]; bitCount += 4; } else { lastSentGasses[GasType.Toxin] = 0; } break; case GasType.WVapor: //if (gasMixture.gasses[GasType.WVapor] > 0.005f && (checkUpdateThreshold(GasType.WVapor) || all)) if (gasMixture.Burning) { amount = 15; // normalizeGasAmount(gasMixture.gasses[GasType.WVapor]); gasChanges[i] = amount; changedTypes = (changedTypes | (1 << i)); lastSentGasses[GasType.WVapor] = gasMixture.gasses[(int)GasType.WVapor]; bitCount += 4; } else { amount = 0; // normalizeGasAmount(gasMixture.gasses[GasType.WVapor]); gasChanges[i] = amount; changedTypes = (changedTypes | (1 << i)); lastSentGasses[GasType.WVapor] = gasMixture.gasses[(int)GasType.WVapor]; bitCount += 4; //lastSentGasses[GasType.WVapor] = 0; } break; default: break; } } //Make a new bitstream with the number o bits we need. bits.Write(changedTypes, 0, typesCount); //write 8 bits for what gas types have changed... for (int i = typesCount - 1; i >= 0; i--) { int type = 1 << i; //Checks flags in the form of 00001011 -- each 1 is a gas type that needs sending... I know this is nuts but it works great! if ((changedTypes & type) == type) { bits.Write(gasChanges[i], 0, 4); } } return bitCount; }
private static void getStreams(byte[][] celldata, byte[][] lastCellData, int frame, int width, uint[] palette, BitStream cellMatrix, BitStream cellDeltaEncoding, BitStream pixelData) { bool newLine = true; int x = 0; bool emptyCellSpan = true; byte cellSpanLength = 0; int cellMatrixEntryMaxSizeBits = 4; int cellMatrixEntryMaxSize = (int)Math.Pow(2, cellMatrixEntryMaxSizeBits) - 1; byte[] emptyCell = new byte[16]; for (int i = 0; i < celldata.Length; i++) { if (newLine) { newLine = false; x = 0; } bool writeCell; if (frame == 0) writeCell = !isCellEmpty(celldata[i]); else writeCell = isCellDifferent(celldata[i], lastCellData[i], palette); if (writeCell) { if (!emptyCellSpan) { cellSpanLength++; if (cellSpanLength == cellMatrixEntryMaxSize) { cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); cellSpanLength = 0; cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); bitswrittenCellMatrix += 8; } } else { cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); bitswrittenCellMatrix += 4; cellSpanLength = 1; emptyCellSpan = false; } byte[] lastframecell = (frame == 0) ? emptyCell : lastCellData[i]; writeCellData(celldata[i], lastframecell, palette, cellDeltaEncoding, pixelData); cellswritten++; } else { if (emptyCellSpan) { cellSpanLength++; if (cellSpanLength == cellMatrixEntryMaxSize) { cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); cellSpanLength = 0; cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); bitswrittenCellMatrix += 8; } } else { cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); bitswrittenCellMatrix += 4; cellSpanLength = 1; emptyCellSpan = true; } } x += 4; if (x >= width) newLine = true; } if (cellSpanLength > 0) { cellMatrix.Write(cellSpanLength, 0, cellMatrixEntryMaxSizeBits); } }
public override BKSystem.IO.BitStream PackCommand() { BKSystem.IO.BitStream packet = new BKSystem.IO.BitStream(); packet.Write((ushort)CGCommandID.OPPONENT_DRAW_CARD, 0, 16); return(packet); }
private byte Get8bitsAsUInt(BitStream bs) { byte result; bs.Read(out result, 0, 8); return result; }
public static string GetFitterMessage(BitStream raw) { string msg = System.Text.Encoding.ASCII.GetString(raw.ToByteArray()); msg = msg.Replace("\0", ""); return msg; }
private int Get6bitsAsInt(BitStream bs) { int result; bs.Read(out result, 0, 6); return result; }
public void HandleAtmosDisplayUpdate(NetIncomingMessage message) { if (!_loaded) return; //Length of records in bits int lengthBits = message.ReadInt32(); int lengthBytes = message.ReadInt32(); var records = new byte[lengthBytes]; message.ReadBytes(records, 0, lengthBytes); byte[] decompressed = Decompress(records); var recordStream = new BitStream(lengthBits); int bitsWritten = 0; for (int i = 0; i < decompressed.Length; i++) { int toWrite = 8; if (toWrite > lengthBits - bitsWritten) toWrite = lengthBits - bitsWritten; recordStream.Write(decompressed[i], 0, toWrite); bitsWritten += toWrite; } int typesCount = Enum.GetValues(typeof (GasType)).Length; recordStream.Position = 0; int types = 0; byte amount = 0; for (int x = 0; x < _mapWidth; x++) { for (int y = 0; y < _mapHeight; y++) { recordStream.Read(out types, 0, typesCount); for (int i = typesCount - 1; i >= 0; i--) { if ((types & (1 << i)) == (1 << i)) { recordStream.Read(out amount, 0, 4); Tile t = (Tile)GetFloorAt(new Vector2D(x * TileSpacing, y * TileSpacing)); if (t == null) continue; t.SetAtmosDisplay((GasType) i, amount); } } } } var gameScreen = IoCManager.Resolve<IStateManager>().CurrentState as GameScreen; gameScreen.RecalculateScene(); }
private int Get1bitAsInt(BitStream bs) { int result; bs.Read(out result, 0, 1); return result; }
/// <summary> /// Creates a copy of the current stream. /// </summary> /// <remarks> /// This method works even when the current stream is closed. /// </remarks> /// <returns> /// A <see cref="BitStream"/> object representing the copy of the current /// stream. /// </returns> /// <seealso cref="BitStream"/> public virtual BitStream Copy() { BitStream bstrmCopy = new BitStream(this.Length); Buffer.BlockCopy(_auiBitBuffer, 0, bstrmCopy._auiBitBuffer, 0, bstrmCopy._auiBitBuffer.Length << 2); bstrmCopy._uiBitBuffer_Length = this._uiBitBuffer_Length; return bstrmCopy; }
/// <summary> /// Parses raw character stat data /// </summary> /// <param name="headerBytes">Raw characte stat data found between "gf" and "if" near offset 765 in save file</param> /// <remarks>Bit lengths of stat types are found in the CSvBits column of ItemStatCost.txt</remarks> /// Source: http://phrozenkeep.hugelaser.com/forum/viewtopic.php?f=8&t=9011&start=50 private void ReadStats() { BitStream bs = new BitStream(statsBytes); // Skip header bytes bs.SkipBits(8); bs.SkipBits(8); while (bs.RemainingBits >= 9) { // ID of stat (See ItemStatCost.txt) int statIndex = (int)bs.ReadReversed(9); // Value contains this many bits (See CSvBits in ItemStatCost.txt) int statValueBits = 0; // Value needs to be shifted by this amount int valShift = 0; // Terminating stat index if (statIndex == 0x1ff) { break; } statValueBits = ItemDefs.ItemStatCostsById[statIndex].CSvBits; if (statValueBits == 0) { break; } valShift = ItemDefs.ItemStatCostsById[(int)statIndex].ValShift; int statValue = (int)bs.ReadReversed(statValueBits); if (!statValues.ContainsKey(statIndex)) { statValues.Add(statIndex, (statValue >> valShift)); } } }
public abstract void UnpackCommand(BKSystem.IO.BitStream packet);
/// <summary> /// Converts specified item into item format for save file /// </summary> /// <returns>Byte representation of item for save file</returns> public byte[] GetItemBytes() { BitStream bs = new BitStream(); bs.WriteReversed('J', 8); bs.WriteReversed('M', 8); var ordered = dataEntries.OrderBy(n => n.Value.Index); foreach (var item in ordered) { if (item.Value.Value is string) { string value = item.Value.Value as string; if (item.Key == "ItemCode") { foreach (var ch in value) { bs.WriteReversed(ch, 8); } bs.WriteReversed(' ', 8); } else if (item.Key == "EarName" || item.Key == "PersonalizedName") { foreach (var ch in value) { bs.WriteReversed(ch, 7); } bs.WriteReversed(0, 7); } else { throw new Exception("Unknown string type in item data"); } } else if (item.Value.Value is ValueType) { // LAST key is the very last property added to the item data if (item.Key == "LAST") continue; TypeCode valueType = Type.GetTypeCode(item.Value.Value.GetType()); if (valueType == TypeCode.UInt32) { uint value = (uint)item.Value.Value; if (item.Key == "Defense") { value += (uint)ItemDefs.ItemStatCostsByName["armorclass"].SaveAdd; } else if (item.Key == "MaxDurability") { value += (uint)ItemDefs.ItemStatCostsByName["maxdurability"].SaveAdd; } else if (item.Key == "Durability") { value += (uint)ItemDefs.ItemStatCostsByName["durability"].SaveAdd; } bs.WriteReversed(value, item.Value.BitCount); } else if (valueType == TypeCode.Int32) { bs.WriteReversed((uint)((int)item.Value.Value), item.Value.BitCount); } else if (valueType == TypeCode.Boolean) { bs.Write((bool)item.Value.Value); } else { throw new Exception("Invalid ValueType!"); } } else { throw new Exception("Invalid data type in item dataEntries"); } } foreach (var item in properties) { WriteItemProperty(bs, item); } foreach (var item in propertiesSet) { WriteItemProperty(bs, item); } foreach (var item in propertiesRuneword) { WriteItemProperty(bs, item); } // Some simple items do have remaining data such as the soulstone if (IsSimpleItem) { //TODO: Enable renaming of ear and personlized names? if (remainingBytes != null) { bs.WriteReversed(remainingBytes); } if (dataEntries.ContainsKey("LAST")) { var lastEntry = dataEntries["LAST"]; bs.WriteReversed((uint)lastEntry.Value, lastEntry.BitCount); } } else { // Fill the last byte with 0 if it's not already full if ((bs.Position % 8) != 0) { int bitsToAdd = 8 - (int)(bs.Position % 8); if (bitsToAdd > 0) { bs.WriteReversed(0, bitsToAdd); } } } return bs.ToReversedByteArray(); }
public virtual BitStream Copy() { BitStream bitStream = new BitStream(this.Length); System.Buffer.BlockCopy(this._auiBitBuffer, 0, bitStream._auiBitBuffer, 0, bitStream._auiBitBuffer.Length << 2); bitStream._uiBitBuffer_Length = this._uiBitBuffer_Length; return bitStream; }
private void CheckNetworkUpdate() { var m = IoCManager.Resolve<IMapManager>(); if ((DateTime.Now - lastAtmosDisplayPush).TotalMilliseconds > 1000) { bool sendUpdate = false; int numberOfGasTypes = Enum.GetValues(typeof (GasType)).Length; var records = new BitStream(m.GetMapHeight()*m.GetMapWidth()*numberOfGasTypes); for (int x = 0; x < m.GetMapWidth(); x++) { for (int y = 0; y < m.GetMapHeight(); y++) { Tile t = (Tile)m.GetFloorAt(new Vector2(x * m.GetTileSpacing(), y * m.GetTileSpacing())); if (t == null) continue; int displayBitsWritten = t.GasCell.PackDisplayBytes(records); if (displayBitsWritten > numberOfGasTypes) sendUpdate = true; } } if (sendUpdate) { SendAtmosUpdatePacket(records); } lastAtmosDisplayPush = DateTime.Now; } }
public virtual BitStream Or(BitStream bits) { if (!this._blnIsOpen) { throw new System.ObjectDisposedException(BitStream.BitStreamResources.GetString("ObjectDisposed_BitStreamClosed")); } if (bits == null) { throw new System.ArgumentNullException("bits", BitStream.BitStreamResources.GetString("ArgumentNull_BitStream")); } if (bits.Length != (long)((ulong)this._uiBitBuffer_Length)) { throw new System.ArgumentException(BitStream.BitStreamResources.GetString("Argument_DifferentBitStreamLengths")); } BitStream bitStream = new BitStream((long)((ulong)this._uiBitBuffer_Length)); uint num = this._uiBitBuffer_Length >> 5; uint num2; for (num2 = 0u; num2 < num; num2 += 1u) { bitStream._auiBitBuffer[(int)((System.UIntPtr)num2)] = (this._auiBitBuffer[(int)((System.UIntPtr)num2)] | bits._auiBitBuffer[(int)((System.UIntPtr)num2)]); } if ((this._uiBitBuffer_Length & 31u) > 0u) { uint num3 = 4294967295u << (int)(32u - (this._uiBitBuffer_Length & 31u)); bitStream._auiBitBuffer[(int)((System.UIntPtr)num2)] = (this._auiBitBuffer[(int)((System.UIntPtr)num2)] | (bits._auiBitBuffer[(int)((System.UIntPtr)num2)] & num3)); } return bitStream; }
private byte[] Compress(BitStream rawStream) { rawStream.Position = 0; var raw = new byte[rawStream.Length8]; for (int i = 0; i < rawStream.Length8; i++) { rawStream.Read(out raw[i]); } var byteLength = (int) rawStream.Length8; if (byteLength == 0) { return null; } using (var memory = new MemoryStream()) { using (var gzip = new GZipStream(memory, CompressionMode.Compress, true)) { gzip.Write(raw, 0, raw.Length); } return memory.ToArray(); } }