public void Save(string uri)
{
using (var writer = new BigEndianWriter(new StreamWriter(uri).BaseStream))
{
var indexTable = new BigEndianWriter();
writer.Seek(4, SeekOrigin.Begin);
foreach (var index in m_indexes)
{
indexTable.WriteInt(index.Key);
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
}
var indexLen = (int)indexTable.Position;
foreach (var index in m_textIndexes)
{
indexTable.WriteUTF(index.Key);
indexTable.WriteInt((int)writer.Position);
writer.WriteUTF(index.Value);
}
var indexPos = (int)writer.Position;
/* write index at end */
var indexData = indexTable.Data;
writer.WriteInt(indexLen);
writer.WriteBytes(indexData);
/* write index pos at begin */
writer.Seek(0, SeekOrigin.Begin);
writer.WriteInt(indexPos);
}
}
public void FixChannels(string BRSTMPath, int amount)
{
BinaryReader br = new BinaryReader(File.Open(BRSTMPath, FileMode.Open), Encoding.ASCII);
const string Magic = "DATA";
int position = 0;
for (int i = 0; i < br.BaseStream.Length; i += 4)
{
if (new String(br.ReadChars(4)) == Magic) //if we find the magic we can stop and we have our position
{
position = i + 4;
br.Dispose();
br.Close();
break;
}
}
BigEndianReader ber = new BigEndianReader(File.Open(BRSTMPath, FileMode.Open));
ber.BaseStream.Seek(position, SeekOrigin.Begin);
uint value = ber.ReadUInt32() + 0x20;
ber.Dispose(); ber.Close();
BigEndianWriter bw = new BigEndianWriter(File.Open(BRSTMPath, FileMode.Open));
bw.Seek(position, SeekOrigin.Begin);
bw.Write(value); bw.Flush(); bw.Close();
BRSTMPath = '"' + BRSTMPath + '"'; //fix path
DecodeBRSTM brstm = new DecodeBRSTM();
brstm.DecodeBRSTMDSP(BRSTMPath, amount); //pass value
}
public TorControlConnection0(BigEndianReader i, BigEndianWriter o)
{
this.output = o;
this.input = i;
// Synchronize the internal queue by default
this.waiters = Queue.Synchronized(new Queue());
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteInt(Files.Length);
foreach (var file in Files)
{
writer.WriteUTF(file);
}
}
public NbtWriter(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
if (!stream.CanWrite)
throw new ArgumentException("Can't write to stream.", "stream");
_writer = new BigEndianWriter(stream);
}
public static void RawDataMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
//TODO : Bypass this f*****g anti-bot
Random random = new Random();
int randomNumber = (int)Math.Floor(random.NextDouble() * 16777215);
CheckIntegrityMessage checkIntegrityMessage = new CheckIntegrityMessage(new List<int>() {randomNumber} );
using (BigEndianWriter writer = new BigEndianWriter())
{
checkIntegrityMessage.Serialize(writer);
MessagePackaging messagePackaging = new MessagePackaging(writer);
messagePackaging.Pack((int)checkIntegrityMessage.ProtocolID);
account.SocketManager.Send(messagePackaging.Writer.Content);
}
//using (BigEndianReader reader = new BigEndianReader(packetDatas))
//{
// byte[] content = reader.ReadBytes((int)reader.BytesAvailable);
// string d = DateTime.Now.ToShortDateString().Replace('\\', '-').Replace('/', '-');
// File.WriteAllBytes(@"F:\RDMs\" + d + "_RDM.swf", content);
// //account.SocketManager.Disconnect();
//}
//using (BigEndianWriter writer = new BigEndianWriter())
//{
// TrustStatusMessage tsm = new TrustStatusMessage(true);
// tsm.Serialize(writer);
// writer.WriteUTF(account.Ticket);
// MessagePackaging pack = new MessagePackaging(writer);
// pack.Pack((int)tsm.ProtocolID);
// account.SocketManager.SendRaw(pack.Writer.Content);
//}
//using (BigEndianWriter writer = new BigEndianWriter())
//{
// writer.WriteBytes(packetDatas);
// MessagePackaging pack = new MessagePackaging(writer);
// pack.Pack(6253);
// account.SocketManager.SendRaw(pack.Writer.Content);
//}
// System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
// byte[] hash = md5.ComputeHash(pack.Writer.Content);
// StringBuilder sb = new StringBuilder();
// for (int i = 0; i < hash.Length; i++)
// {
// sb.Append(hash[i].ToString("X2"));
// }
// System.Windows.Forms.MessageBox.Show(sb.ToString());
//}
}
public void ParseBuffer(byte[] data)
{
m_Reader.Add(data, 0, data.Length);
if (m_Reader.BytesAvailable <= 0)
return;
while (m_Reader.BytesAvailable != 0)
{
if (Build())
{
if ((account.IsMITM) && (!ForbiddenHeaders.Contains((int)m_ProtocolID)))
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)m_ProtocolID);
account.SocketManager.SendToDofusClient(pack.Writer.Content);
account.Log(new BotTextInformation("SND (-> Dof) " + m_ProtocolID), 0);
}
}
//using (
// StreamWriter fileWriter =
// new StreamWriter(
// Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) +
// @"\BlueSheep\Packets.txt", true))
// fileWriter.WriteLine("[" + DateTime.Now.ToShortTimeString() + "] Paquet reçu : " + m_ProtocolID);
Treatment.Treatment treatment = new Treatment.Treatment(account);
if (m_ProtocolID == 6372)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(m_Data);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack(6372);
account.SocketManager.Send(pack.Writer.Content);
}
}
if (m_ProtocolID != null)
treatment.Treat(m_ProtocolID.Value, m_Data);
m_Header = null;
m_Length = null;
m_Data = null;
m_LenghtType = null;
m_ProtocolID = null;
}
else
break;
}
}
public void SendMessage(int channel, string content)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
ChatClientMultiMessage msg = new ChatClientMultiMessage(content, (sbyte)channel);
msg.Serialize(writer);
writer.Content = account.HumanCheck.hash_function(writer.Content);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)msg.ProtocolID);
account.SocketManager.Send(pack.Writer.Content);
if (account.DebugMode.Checked)
account.Log(new DebugTextInformation("[SND] 861 (ChatClientMultiMessage)"), 0);
account.FloodUC.Increase(false);
}
}
public byte[] hash_function(byte[] packet)
{
/* Hello Mr.Fourbasse :hap: */
if (this._hashKey == null)
return packet;
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteBytes(packet);
BigEndianWriter writer2 = new BigEndianWriter();
writer2.WriteBytes(this.hash(packet));
using (RijndaelManaged myRijndael = new RijndaelManaged())
{
myRijndael.GenerateIV();
// Encrypt the string to an array of bytes.
byte[] encrypted = EncryptStringToBytes(writer2.Content.ToString(), this._hashKey, myRijndael.IV);
}
writer.WriteBytes(writer2.Content);
return writer.Content;
}
}
public void WriteTest()
{
List<byte> m = new List<byte>();
MemoryStream ms = new MemoryStream();
using (BigEndianWriter w = new BigEndianWriter(ms)) {
w.Write((int)0x12345678);
m.Add(0x12);
m.Add(0x34);
m.Add(0x56);
m.Add(0x78);
w.Write((short)0x2345);
m.Add(0x23);
m.Add(0x45);
w.WriteBCD(12345678,4);
m.Add(0x12);
m.Add(0x34);
m.Add(0x56);
m.Add(0x78);
}
Assert.AreEqual(m.ToArray(), ms.ToArray());
}
public BigEndianStream(Stream stream)
{
_reader = new BigEndianReader(stream);
_writer = new BigEndianWriter(stream);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteShort(ignoreAdded.TypeId);
ignoreAdded.Serialize(writer);
writer.WriteBoolean(session);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteUTF(loginToken);
}
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.WriteUTF(name);
writer.WriteByte(level);
}
public override void Serialize(BigEndianWriter writer)
{
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteVarShort(subAreaId);
writer.WriteBoolean(join);
}
public override void Serialize(BigEndianWriter writer)
{
fight.Serialize(writer);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteShort(memberInformations.TypeId);
memberInformations.Serialize(writer);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteSByte(powerLevel);
}
public virtual void Serialize(BigEndianWriter writer)
{
writer.WriteInt(modelId);
writer.WriteUTF(name);
writer.WriteUTF(ownerName);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteInt(humanVendorId);
writer.WriteInt(humanVendorCell);
}
public MessagePackaging(BigEndianWriter writer)
{
m_Writer = writer;
}
public byte[] GetBytes()
{
byte[] buffer = new byte[96];
buffer[0] |= (byte)(PeripheralQualifier << 5);
buffer[0] |= (byte)(PeripheralQualifier & 0x1F);
if (RMB)
{
buffer[1] |= 0x80;
}
buffer[2] = Version;
if (NormACA)
{
buffer[3] |= 0x20;
}
if (HiSup)
{
buffer[3] |= 0x10;
}
buffer[3] |= (byte)(ResponseDataFormat & 0x0F);
buffer[4] = AdditionalLength;
if (SCCS)
{
buffer[5] |= 0x80;
}
if (ACC)
{
buffer[5] |= 0x40;
}
buffer[5] |= (byte)((TPGS & 0x03) << 4);
if (ThirdPartyCopy)
{
buffer[5] |= 0x08;
}
if (Protect)
{
buffer[5] |= 0x01;
}
if (EncServ)
{
buffer[6] |= 0x40;
}
if (VS1)
{
buffer[6] |= 0x20;
}
if (MultiP)
{
buffer[6] |= 0x10;
}
if (MChngr)
{
buffer[6] |= 0x08;
}
if (Addr16)
{
buffer[6] |= 0x01;
}
if (WBus16)
{
buffer[7] |= 0x20;
}
if (Sync)
{
buffer[7] |= 0x10;
}
if (CmdQue)
{
buffer[7] |= 0x02;
}
if (VS2)
{
buffer[7] |= 0x01;
}
ByteWriter.WriteAnsiString(buffer, 8, VendorIdentification, 8);
ByteWriter.WriteAnsiString(buffer, 16, ProductIdentification, 16);
ByteWriter.WriteAnsiString(buffer, 32, ProductRevisionLevel, 4);
BigEndianWriter.WriteUInt64(buffer, 36, DriveSerialNumber);
buffer[56] |= (byte)((Clocking & 0x03) << 2);
if (QAS)
{
buffer[56] |= 0x02;
}
if (IUS)
{
buffer[56] |= 0x01;
}
for (int index = 0; index < 8; index++)
{
ushort versionDescriptor = 0;
if (index < VersionDescriptors.Count)
{
versionDescriptor = (ushort)VersionDescriptors[index];
}
BigEndianWriter.WriteUInt16(buffer, 58 + index * 2, versionDescriptor);
}
return(buffer);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteUTF(OS);
writer.WriteUTF(Username);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteUTF(search);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteInt(kamasTotal);
}
public override void Serialize(BigEndianWriter writer)
{
member.Serialize(writer);
}
public override void Serialize(BigEndianWriter writer)
{
@object.Serialize(writer);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteInt(guildId);
writer.WriteUTF(guildName);
}
/// <summary>
/// Serialize and pack the message, and send it.
/// </summary>
public void Send(BlueSheep.Engine.Types.Message msg)
{
using (BigEndianWriter writer = new BigEndianWriter())
{
msg.Serialize(writer);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)msg.ProtocolID);
account.SocketManager.Send(pack.Writer.Content);
if (account.DebugMode.Checked)
account.Log(new DebugTextInformation("[SND] " + msg.ProtocolID), 0);
}
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteShort(spellId);
writer.WriteSByte(spellLevel);
}
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 virtual void Serialize(BigEndianWriter writer)
{
writer.WriteUTF(this.value);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteInt(targetId);
writer.WriteShort(delta);
}
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 SendPrivateTo(string name, string content)
{
if (mods.Contains(name))
{
account.Log(new ErrorTextInformation("[Flood] Annulation de l'envoi d'un message privé à " + name + " (Modo)"), 0);
return;
}
using (BigEndianWriter writer = new BigEndianWriter())
{
ChatClientPrivateMessage msg = new ChatClientPrivateMessage(content, name);
msg.Serialize(writer);
writer.Content = account.HumanCheck.hash_function(writer.Content);
MessagePackaging pack = new MessagePackaging(writer);
pack.Pack((int)msg.ProtocolID);
account.SocketManager.Send(pack.Writer.Content);
account.Log(new PrivateTextInformation("à " + name + " : " + content), 1);
if (account.DebugMode.Checked)
account.Log(new DebugTextInformation("[SND] 851 (ChatClientPrivateMessage)"), 0);
}
}
public void SaveGroup(List<AccountUC> accounts, string groupname)
{
//m_GroupAccounts.Clear();
//foreach (AccountUC bot in accounts)
//{
// bot.AccountPassword = CryptageBS.EncryptBS(bot.AccountPassword);
// m_GroupAccounts.Add(bot);
//}
if (!Directory.Exists(m_SavingGroupDirectoryPath))
Directory.CreateDirectory(m_SavingGroupDirectoryPath);
//if (!File.Exists(m_SavingDirectoryPath + @"\" + groupname))
// File.Create(m_SavingDirectoryPath + @"\" + groupname);
m_GroupAccounts = accounts;
using (BigEndianWriter writer = new BigEndianWriter(File.Create(Path.Combine(m_SavingGroupDirectoryPath, groupname))))
{
writer.WriteInt(m_GroupAccounts.Count);
foreach (AccountUC accountObject in m_GroupAccounts)
{
writer.WriteUTF(accountObject.AccountName);
writer.WriteUTF(CryptageBS.EncryptBS(accountObject.AccountPassword));
}
//IFormatter binaryFormatter = new BinaryFormatter();
//using (Stream stream = new FileStream(m_SavingGroupDirectoryPath + @"\" + groupname, FileMode.Create, FileAccess.Write))
//{
// binaryFormatter.Serialize(stream, writer);
//}
}
//foreach (AccountUC bot in accounts)
// bot.AccountPassword = CryptageBS.DecryptBS(bot.AccountPassword);
}
private byte[] hashKey_Gen(AccountUC account)
{
try
{
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteUTF(account.Ticket);
byte[] key = hash(writer.Content);
return key;
}
}
catch (Exception ex)
{
account.Log(new ErrorTextInformation(ex.Message + ex.InnerException), 0);
return null;
}
}
public abstract void Serialize(BigEndianWriter writer);
public override void Serialize(BigEndianWriter writer)
{
writer.WriteSByte(error);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteShort(rank);
}
public static void PartyMemberInFightMessageTreatment(Message message, byte[] packetDatas, AccountUC account)
{
PartyMemberInFightMessage msg = (PartyMemberInFightMessage)message;
using (BigEndianReader reader = new BigEndianReader(packetDatas))
{
msg.Deserialize(reader);
}
if (msg.fightMap.mapId == account.Map.Id && msg.memberName == account.MyGroup.GetMaster().CharacterBaseInformations.name)
{
account.Wait(500, 1500);
using (BigEndianWriter writer = new BigEndianWriter())
{
GameFightJoinRequestMessage msg2 = new GameFightJoinRequestMessage(msg.memberId, msg.fightId);
account.SocketManager.Send(msg2);
}
}
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteSByte(barType);
writer.WriteSByte(slot);
}
public void SaveAs(string destination, bool overwrite = true)
{
lock (m_linksToSave)
{
// save the links before
while (m_linksToSave.Count > 0)
{
D2pFile link = m_linksToSave.Dequeue();
// theorically the path is defined
link.Save();
}
}
Stream stream;
if (!File.Exists(destination))
stream = File.Create(destination);
else if (!overwrite)
throw new InvalidOperationException(
"Cannot perform SaveAs : file already exist, notify overwrite parameter to true");
else
stream = File.OpenWrite(destination);
using (var writer = new BigEndianWriter(stream))
{
// header
writer.WriteByte(2);
writer.WriteByte(1);
D2pEntry[] entries = GetEntriesOfInstanceOnly();
// avoid the header
int offset = 2;
foreach (D2pEntry entry in entries)
{
byte[] data = ReadFile(entry);
entry.Index = (int) writer.Position - offset;
writer.WriteBytes(data);
}
var entriesDefOffset = (int) writer.Position;
foreach (D2pEntry entry in entries)
{
entry.WriteEntryDefinition(writer);
}
var propertiesOffset = (int) writer.Position;
foreach (D2pProperty property in m_properties)
{
property.WriteProperty(writer);
}
IndexTable.OffsetBase = offset;
IndexTable.EntriesCount = entries.Length;
IndexTable.EntriesDefinitionOffset = entriesDefOffset;
IndexTable.PropertiesCount = m_properties.Count;
IndexTable.PropertiesOffset = propertiesOffset;
IndexTable.Size = IndexTable.EntriesDefinitionOffset - IndexTable.OffsetBase;
IndexTable.WriteTable(writer);
}
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteBoolean(onlySuccess);
writer.WriteVarInt(objectUID);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteSByte(presetId);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteVarShort(questId);
writer.WriteVarShort(objectiveId);
}
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.WriteInt(elemId);
writer.WriteInt(skillInstanceUid);
}
public void SaveAccountsInfos(List<Bot> bots)
{
foreach (Bot bot in bots)
{
bot.Account.Password = CryptageBS.EncryptBS(bot.Account.Password);
m_Accounts.Add(bot.Account);
}
if (!Directory.Exists(m_SavingDirectoryPath))
Directory.CreateDirectory(m_SavingDirectoryPath);
using (BigEndianWriter writer = new BigEndianWriter())
{
writer.WriteInt(m_Accounts.Count);
foreach (Account accountObject in m_Accounts)
{
writer.WriteUTF(accountObject.Name);
writer.WriteUTF(accountObject.Password);
}
IFormatter binaryFormatter = new BinaryFormatter();
using (Stream stream = new FileStream(m_SavingFilePath, FileMode.Create, FileAccess.Write))
{
binaryFormatter.Serialize(stream, writer);
}
}
foreach (Bot bot in bots)
bot.Account.Password = CryptageBS.DecryptBS(bot.Account.Password);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteInt(houseId);
writer.WriteBoolean(bought);
writer.WriteInt(realPrice);
}
public override void Serialize(BigEndianWriter writer)
{
writer.WriteInt(id);
}
public override void Serialize(BigEndianWriter writer)
{
base.Serialize(writer);
writer.WriteBoolean(loyal);
}
