public virtual void Serialize(BigEndianWriter writer)
 {
     writer.WriteVarInt(guildId);
     writer.WriteVarInt(leaderId);
     writer.WriteByte(guildLevel);
     writer.WriteByte(nbMembers);
 }
Esempio n. 2
0
        public void WriteVarShort(int value)
        {
            if (value > short.MaxValue || value < short.MinValue)
            {
                throw new Exception("Forbidden value");
            }

            BigEndianWriter buffer = new BigEndianWriter();

            if (value >= 0 && value <= 127)
            {
                buffer.WriteByte((byte)value);
                WriteBytes(buffer.Content);
                return;
            }

            short valueToWrite = (short)(value & 65535);

            while (valueToWrite != 0)
            {
                byte byteToWrite = Convert.ToByte(valueToWrite & 127);
                valueToWrite = (short)(valueToWrite >> 7);
                if (valueToWrite > 0)
                {
                    byteToWrite = Convert.ToByte(byteToWrite | 128);
                }
                buffer.WriteByte(byteToWrite);
            }
            WriteBytes(buffer.Content);
        }
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteVarInt(symbioteUID);
     writer.WriteByte(symbiotePos);
     writer.WriteVarInt(hostUID);
     writer.WriteByte(hostPos);
 }
        public void WriteVarShort(int value)
        {
            byte _loc5_ = 0;

            if (value > short.MaxValue || value < short.MinValue)
            {
                throw new Exception("Forbidden value");
            }
            else
            {
                BigEndianWriter buffer = new BigEndianWriter();
                if (value >= 0 && value <= 127)
                {
                    buffer.WriteByte((byte)value);
                    this.WriteBytes(buffer.Content);
                    return;
                }
                int             tampon    = value & 65535;
                BigEndianWriter subBuffer = new BigEndianWriter();
                while (tampon != 0)
                {
                    subBuffer.WriteByte(Convert.ToByte(tampon & 127));
                    subBuffer.m_BinaryWriter.Seek((int)subBuffer.m_BinaryWriter.BaseStream.Length, SeekOrigin.Begin);
                    _loc5_ = (byte)subBuffer.m_BinaryWriter.BaseStream.ReadByte();
                    tampon = tampon >> 7;
                    if (tampon > 0)
                    {
                        _loc5_ = Convert.ToByte(_loc5_ | 128);
                    }
                    buffer.WriteByte(_loc5_);
                }
                this.WriteBytes(buffer.Content);
                return;
            }
        }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(guildLevel);
     writer.WriteByte(nbMembers);
     writer.WriteBoolean(enabled);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteSByte(companionGenericId);
     writer.WriteByte(level);
     writer.WriteInt(masterId);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     byte flag1 = 0;
     flag1 = BooleanByteWrapper.SetFlag(flag1, 0, canChangeName);
     flag1 = BooleanByteWrapper.SetFlag(flag1, 1, canChangeEmblem);
     writer.WriteByte(flag1);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteVarInt(foodUID);
     writer.WriteByte(foodPos);
     writer.WriteBoolean(preview);
 }
Esempio n. 9
0
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(position);
     writer.WriteInt(spellId);
     writer.WriteSByte(spellLevel);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(level);
     guildInfo.Serialize(writer);
     writer.WriteInt(experienceForGuild);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteVarShort(firstNameId);
     writer.WriteVarShort(lastNameId);
     writer.WriteByte(level);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteVarInt(leaderId);
     writer.WriteByte(guildLevel);
     writer.WriteVarShort(nbMembers);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteSByte(deathState);
     writer.WriteVarShort(deathCount);
     writer.WriteByte(deathMaxLevel);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     byte flag1 = 0;
     flag1 = BooleanByteWrapper.SetFlag(flag1, 0, success);
     flag1 = BooleanByteWrapper.SetFlag(flag1, 1, session);
     writer.WriteByte(flag1);
     writer.WriteUTF(name);
 }
 public virtual void Serialize(BigEndianWriter writer)
 {
     writer.WriteVarInt(playerId);
     writer.WriteUTF(playerName);
     writer.WriteSByte(breed);
     writer.WriteBoolean(sex);
     writer.WriteByte(level);
 }
Esempio n. 16
0
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteUShort((ushort)emoteIds.Length);
     foreach (var entry in emoteIds)
     {
          writer.WriteByte(entry);
     }
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteShort(identification.TypeId);
     identification.Serialize(writer);
     writer.WriteByte(guildLevel);
     writer.WriteInt(taxCollectorAttack);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(level);
     alignmentInfos.Serialize(writer);
     writer.WriteSByte(breed);
     writer.WriteBoolean(sex);
 }
Esempio n. 19
0
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(grade);
     writer.WriteVarShort(minHonorForGrade);
     writer.WriteVarShort(maxHonorForGrade);
     writer.WriteVarShort(honor);
     writer.WriteVarShort(honorDelta);
 }
 public virtual void Serialize(BigEndianWriter writer)
 {
     byte _loc2_ = 0;
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,0,this.isSecret);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,1,this.isRestrictedToPartyOnly);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,2,this.isClosed);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,3,this.isAskingForHelp);
      writer.WriteByte(_loc2_);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteVarShort(initiative);
     writer.WriteVarInt(lifePoints);
     writer.WriteVarInt(maxLifePoints);
     writer.WriteVarShort(prospecting);
     writer.WriteByte(regenRate);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteSByte(presetId);
     writer.WriteSByte(code);
     writer.WriteUShort((ushort)unlinkedPosition.Length);
     foreach (var entry in unlinkedPosition)
     {
          writer.WriteByte(entry);
     }
 }
 public virtual void Serialize(BigEndianWriter writer)
 {
     byte b = 0;
      b = BooleanByteWrapper.SetFlag(b,0,this.sex);
      b = BooleanByteWrapper.SetFlag(b,1,this.alive);
      writer.WriteByte(b);
     writer.WriteInt(id);
     writer.WriteSByte(wave);
     writer.WriteVarShort(level);
     writer.WriteSByte(breed);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     byte flag1 = 0;
     flag1 = BooleanByteWrapper.SetFlag(flag1, 0, ssl);
     flag1 = BooleanByteWrapper.SetFlag(flag1, 1, canCreateNewCharacter);
     writer.WriteByte(flag1);
     writer.WriteVarShort(serverId);
     writer.WriteUTF(address);
     writer.WriteUShort(port);
     writer.WriteUTF(ticket);
 }
Esempio n. 25
0
 public override void Serialize(BigEndianWriter writer)
 {
     byte flag1 = 0;
     flag1 = BooleanByteWrapper.SetFlag(flag1, 0, canBeCancelled);
     flag1 = BooleanByteWrapper.SetFlag(flag1, 1, canSayReady);
     flag1 = BooleanByteWrapper.SetFlag(flag1, 2, isFightStarted);
     writer.WriteByte(flag1);
     //writer.WriteInt(timeMaxBeforeFightStart);
     writer.WriteShort((short)timeMaxBeforeFightStart);
     writer.WriteSByte(fightType);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteByte(level);
     writer.WriteUShort((ushort)additional.Length);
     foreach (var entry in additional)
     {
          writer.WriteShort(entry.TypeId);
          entry.Serialize(writer);
     }
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
        byte _loc2_ = 0;
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,0,this.hasFriend);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,1,this.hasGuildMember);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,2,this.hasAllianceMember);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,3,this.hasGroupMember);
      _loc2_ = BooleanByteWrapper.SetFlag(_loc2_,4,this.hasMyTaxCollector);
      writer.WriteByte(_loc2_);
     writer.WriteSByte(teamMembersCount);
     writer.WriteVarInt(meanLevel);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteSByte(presetId);
     writer.WriteSByte(symbolId);
     writer.WriteUShort((ushort)itemsPositions.Length);
     foreach (var entry in itemsPositions)
     {
          writer.WriteByte(entry);
     }
     writer.WriteUShort((ushort)itemsUids.Length);
     foreach (var entry in itemsUids)
     {
          writer.WriteVarInt(entry);
     }
 }
        public override void Serialize(BigEndianWriter writer)
        {
            //writer.WriteInt(this.data);
            //writer.WriteUShort((ushort)data.Length);
            //foreach (var entry in data)
            //{
            //     writer.WriteSByte(entry);
            //}
            writer.WriteVarInt(this.data.Count);
            int _loc_2 = 0;
            while (_loc_2 < this.data.Count)
            {

                writer.WriteByte((byte)this.data[_loc_2]);
                _loc_2 = _loc_2 + 1;
            }
        }
Esempio n. 30
0
        public void WriteVarInt(int value)
        {
            BigEndianWriter buffer = new BigEndianWriter();

            if (value >= 0 && value <= 127)
            {
                WriteBytes(BitConverter.GetBytes(value));
                return;
            }
            int valueToWrite = value;

            while (valueToWrite != 0)
            {
                byte desiredValue = Convert.ToByte(valueToWrite & 127); // extract the first 7 bits
                valueToWrite = valueToWrite >> 7;                       //get the next 7 bits
                if (valueToWrite > 0)                                   //we're not finished
                {
                    desiredValue = (byte)(desiredValue | 128);          //Set the continuation flag
                }
                buffer.WriteByte(desiredValue);
            }
            WriteBytes(buffer.Content);
        }
        public void WriteVarInt(int value)
        {
            //byte _loc5_ = 0;
            //Byte[] _loc2_ = new Byte[1];
            //if (VarToWrite >= 0 && VarToWrite <= 127)
            //{
            //    this.WriteInt(VarToWrite);
            //    return;
            //}
            //int _loc3_ = VarToWrite;
            //Byte[] _loc4_ = new Byte[1];
            //while (_loc3_ != 0)
            //{
            //    _loc4_[_loc4_.Length -1] = (byte)(_loc3_ & 127);
            //    _loc5_ = _loc4_[_loc4_.Length - 1];
            //    _loc3_ = Convert.ToInt32(Convert.ToUInt32(_loc3_) >> 7);
            //    if (_loc3_ > 0)
            //    {
            //        _loc5_ = (byte)(_loc5_ | 128);
            //    }
            //    _loc2_[_loc4_.Length - 1] = _loc5_;
            //}
            //this.WriteBytes(_loc2_);

            //byte _loc_5 = 0;
            //List<byte> result = new List<byte>();
            //if ((VarToWrite >= 0 & VarToWrite <= 127))
            //{
            //    this.WriteBytes(new Byte[] {Convert.ToByte(VarToWrite)});
            //    return;
            //}
            //int _loc_3 = VarToWrite & 65535;
            //List<byte> _loc_4 = new List<byte>();
            //while ((_loc_3 != 0))
            //{
            //    _loc_4.Add(Convert.ToByte(_loc_3 & 127));
            //    //     _loc_4.BaseStream.Position = _loc_4.BytesToSend.Count - 1
            //    _loc_5 = _loc_4[_loc_4.Count - 1];
            //    _loc_4.RemoveAt(_loc_4.Count - 1);
            //    _loc_3 = _loc_3 >> 7;
            //    if ((_loc_3 > 0))
            //    {
            //        _loc_5 = Convert.ToByte(_loc_5 | 128);
            //    }
            //    result.Add(_loc_5);
            //}
            //this.WriteBytes(result.ToArray());

            var             _loc5_ = 0;
            BigEndianWriter buffer = new BigEndianWriter();

            if (value >= 0 && value <= 127)
            {
                buffer.WriteByte((byte)value);
                this.WriteBytes(BitConverter.GetBytes(value));
                return;
            }
            int             _loc3_    = value;
            BigEndianWriter subBuffer = new BigEndianWriter();

            while (_loc3_ != 0)
            {
                subBuffer.WriteByte(Convert.ToByte(_loc3_ & 127));
                subBuffer.m_BinaryWriter.Seek(0, SeekOrigin.End);
                //subBuffer.Seek((int)subBuffer.BaseStream.Length, SeekOrigin.Begin);
                _loc5_ = subBuffer.m_BinaryWriter.BaseStream.ReadByte();
                _loc3_ = _loc3_ >> 7;
                if (_loc3_ > 0)
                {
                    _loc5_ = _loc5_ | 128;
                }
                //buffer.WriteBytes(BitConverter.GetBytes(_loc5_));
                buffer.WriteByte((byte)_loc5_);
            }
            this.WriteBytes(buffer.Content);
        }
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteByte(emoteId);
 }
 public override void Serialize(BigEndianWriter writer)
 {
     base.Serialize(writer);
     writer.WriteUTF(ownerName);
     writer.WriteByte(level);
 }
Esempio n. 34
0
 public override void Serialize(BigEndianWriter writer)
 {
     writer.WriteByte(lockDuration);
     writer.WriteUTF(author);
     writer.WriteUTF(content);
 }