public static void Broadcast(WorldConnector pConnector, InterPacket pPacket)
{
int packetlenght;
byte[] packet;
string charname;
if (!pPacket.TryReadString(out charname, 16))
return;
if (!pPacket.TryReadInt(out packetlenght))
return;
if (!pPacket.TryReadBytes(packetlenght, out packet))
return;
ZoneClient pClient = ClientManager.Instance.GetClientByCharName(charname);
if (pClient == null)
return;
using (var ipacket = new InterPacket(InterHeader.SendBroiadCastList))
{
List<ZoneCharacter> Sender = pClient.Character.Map.GetCharactersBySectors(pClient.Character.MapSector.SurroundingSectors);
if (Sender.Count == 0)
return;
ipacket.WriteInt(packetlenght);
ipacket.WriteBytes(packet);
ipacket.WriteInt(Sender.Count);
foreach (var character in Sender)
{
ipacket.WriteString(character.Name,16);
}
pConnector.SendPacket(ipacket);
}
}
public static void SendAssigned(WorldConnection wc)
{
using (var p = new InterPacket(InterHeader.Assigned))
{
wc.SendPacket(p);
}
}
public static void HandleServerAssignement(WorldConnection wc, InterPacket packet)
{
byte wid;
string name, ip;
ushort port;
if (!packet.TryReadByte(out wid) || !packet.TryReadString(out name) || !packet.TryReadString(out ip) || !packet.TryReadUShort(out port))
{
Log.WriteLine(LogLevel.Error, "Could not read World ID in inter server packet.");
wc.Disconnect();
return;
}
if (WorldManager.Instance.Worlds.ContainsKey(wid))
{
Log.WriteLine(LogLevel.Error, "Already loaded this world?");
wc.Disconnect();
return;
}
wc.Name = name;
wc.ID = wid;
wc.IP = ip;
wc.Port = port;
wc.IsAWorld = true;
if (WorldManager.Instance.Worlds.TryAdd(wc.ID, wc))
{
Log.WriteLine(LogLevel.Info, "Assigned world {0}!", wc.ID);
SendAssigned(wc);
}
else
{
Log.WriteLine(LogLevel.Error, "Couldn't assign world {0}..", wc.ID);
}
}
private void SendIVs()
{
var packet = new InterPacket(InterHeader.Ivs);
packet.WriteBytes(_mIvSend);
SendPacket(packet, false);
}
public static void On_WorldClient_AcademyMemberJoined(WorldConnector pConnector, InterPacket pPacket)
{
int guildID, characterID;
DateTime registerDate;
if (!pPacket.TryReadInt(out guildID)
|| !pPacket.TryReadInt(out characterID)
|| !pPacket.TryReadDateTime(out registerDate))
{
return;
}
Guild guild;
if (GuildManager.GetGuildByID(guildID, out guild))
{
var member = new GuildAcademyMember(guild.Academy, characterID, GuildAcademyRank.Member, registerDate)
{
IsOnline = true,
};
guild.Academy.Members.Add(member);
ZoneCharacter character;
if (CharacterManager.GetLoggedInCharacter(characterID, out character))
{
member.Character = character;
character.Guild = guild;
character.GuildAcademy = guild.Academy;
character.GuildAcademyMember = member;
GuildManager.SetGuildBuff(character);
}
}
}
public static void ChangeZoneBeginn(ZoneConnection zc, InterPacket packet)
{
ushort mapid,randomid,port;
string charname,ip;
int x,y;
if(!packet.TryReadUShort(out mapid))
return;
if(!packet.TryReadInt(out x))
return;
if(!packet.TryReadInt(out y))
return;
if(!packet.TryReadString(out charname,16))
return;
if(!packet.TryReadString(out ip,16))
return;
if(!packet.TryReadUShort(out port))
return;
if(!packet.TryReadUShort(out randomid))
return;
WorldClient client = ClientManager.Instance.GetClientByCharname(charname);
if(client == null)
return;
int oldmap = client.Character.Character.PositionInfo.Map;
client.Character.Character.PositionInfo.Map = mapid;
client.Character.Character.PositionInfo.XPos = x;
client.Character.Character.PositionInfo.YPos = y;
Managers.CharacterManager.InvokeChangeMapEvent(client.Character);
client.Character.ChangeFrendMap(DataProvider.GetMapname(mapid));//setup later to event
}
public void SendInterPass(string what)
{
var packet = new InterPacket(InterHeader.Auth);
packet.WriteStringLen(what);
SendPacket(packet);
}
public static void On_WorldClient_AcademyMemberLeft(WorldConnector pConnector, InterPacket pPacket)
{
int guildID, characterID;
if (!pPacket.TryReadInt(out guildID)
|| !pPacket.TryReadInt(out characterID))
{
return;
}
Guild guild;
if (GuildManager.GetGuildByID(guildID, out guild))
{
GuildAcademyMember member;
if (guild.Academy.GetMember(characterID, out member))
{
guild.Academy.Members.Remove(member);
member.Dispose();
ZoneCharacter character;
if (CharacterManager.GetLoggedInCharacter(characterID, out character))
{
character.Guild = null;
character.GuildAcademy = null;
character.GuildAcademyMember = null;
GuildManager.RemoveGuildBuff(character);
}
}
}
}
public void Broadcast(InterPacket pPacket)
{
foreach (var zone in Program.Zones.Values)
{
zone.SendPacket(pPacket);
}
}
public void SendPacket(InterPacket pPacket, bool crypto = true)
{
byte[] data = new byte[pPacket.Length + 4];
Buffer.BlockCopy(crypto ? InterCrypto.EncryptData(mIVSend, pPacket.ToArray()) : pPacket.ToArray(), 0, data, 4, pPacket.Length);
Buffer.BlockCopy(BitConverter.GetBytes(pPacket.Length), 0, data, 0, 4);
Send(data);
}
public static void BackTo(ZoneClient client, Packet packet)
{
using(var iacket = new InterPacket(InterHeader.ClientDisconect))
{
iacket.WriteString(client.Character.Character.Name, 16);
InterServer.WorldConnector.Instance.SendPacket(iacket);
}
}
public static void Banaccount(WorldConnection wc, InterPacket packet)
{
int acountid;
if (packet.TryReadInt(out acountid))
{
Program.DatabaseManager.GetClient().ExecuteQuery("UPDATE Accounts Set Blocked='1' WHERE ID="+acountid+"");
}
}
public static void AddPartyMember(WorldConnector lc, InterPacket packet)
{
long groupId = 0;
string charName = "";
if (!packet.TryReadLong(out groupId) &&
!packet.TryReadString(out charName, 16))
{
throw new InvalidPacketException();
}
GroupManager.Instance.AddMemberToGroup(groupId, charName);
}
public static void RemoveBuff(AbStateInfo AbState, params WorldCharacter[] Receiver)
{
using (var packet = new InterPacket(InterHeader.ZONE_CharacterRemoveBuff))
{
packet.WriteUShort(AbState.ID);
packet.WriteInt(Receiver.Length);
Array.ForEach(Receiver, ch => packet.WriteInt(ch.ID));
ZoneManager.Instance.Broadcast(packet);
}
}
public static void DisconnectFromzoneserver(ZoneConnection zc, InterPacket packet)
{
string charname;
if (packet.TryReadString(out charname,16))
{
WorldClient client = ClientManager.Instance.GetClientByCharname(charname);
if (client == null)
return;
client.Character.Loggeout(client);
ClientManager.Instance.RemoveClient(client);
}
}
public void SendTransferClientFromWorld(int accountID, string userName, byte admin, string hostIP, string hash)
{
using (var packet = new InterPacket(InterHeader.Clienttransfer))
{
packet.WriteByte(0);
packet.WriteInt(accountID);
packet.WriteStringLen(userName);
packet.WriteStringLen(hash);
packet.WriteByte(admin);
packet.WriteStringLen(hostIP);
this.SendPacket(packet);
}
}
public void SendTransferClientFromZone(int accountID, string userName, string charName,int CharID, ushort randid, byte admin, string hostIP)
{
using (var packet = new InterPacket(InterHeader.Clienttransfer))
{
packet.WriteByte(1);
packet.WriteInt(accountID);
packet.WriteStringLen(userName);
packet.WriteStringLen(charName);
packet.WriteInt(CharID);
packet.WriteUShort(randid);
packet.WriteByte(admin);
packet.WriteStringLen(hostIP);
this.SendPacket(packet);
}
}
public static void FunctionGetCharacterOnline(ZoneConnection pConnection, InterPacket pPacket)
{
long id;
string charName;
if(!pPacket.TryReadLong(out id) ||!pPacket.TryReadString(out charName, 16))
throw new InvalidPacketException();
bool isOnline = ClientManager.Instance.IsOnline(charName);
using (InterPacket packet = new InterPacket(InterHeader.FunctionAnswer))
{
packet.WriteLong(id);
packet.WriteBool(isOnline);
pConnection.SendPacket(packet);
}
}
public static void BanAccount(ZoneConnection zc, InterPacket packet)
{
string playername;
if (packet.TryReadString(out playername, 16))
{
WorldClient bannclient = ClientManager.Instance.GetClientByCharname(playername);
if (bannclient != null)
{
using (var p = new InterPacket(InterHeader.BanAccount))
{
p.WriteInt(bannclient.AccountID);
LoginConnector.Instance.SendPacket(p);
}
bannclient.Disconnect();
}
}
}
public static void On_WorldClient_AcademyBuffUpdate(WorldConnector pConnector, InterPacket pPacket)
{
int guildID;
DateTime updateTime;
double keepTime;
if (!pPacket.TryReadInt(out guildID)
|| !pPacket.TryReadDateTime(out updateTime)
|| !pPacket.TryReadDouble(out keepTime))
{
//Client.Dispose();
return;
}
Guild guild;
if (GuildManager.GetGuildByID(guildID, out guild))
{
guild.Academy.GuildBuffUpdateTime = updateTime;
guild.Academy.GuildBuffKeepTime = TimeSpan.FromSeconds(keepTime);
}
}
public static void AddRewardItem(WorldConnector pConnector, InterPacket pPacket)
{
byte count;
ushort ItemID;
string Charname;
if (!pPacket.TryReadUShort(out ItemID))
return;
if (!pPacket.TryReadByte(out count))
return;
if(!pPacket.TryReadString(out Charname,16))
return;
ZoneClient pClient = ClientManager.Instance.GetClientByName(Charname);
if(pClient == null)
return;
pClient.Character.GiveMasterRewardItem(ItemID, count);
}
public void SendData()
{
using (var packet = new InterPacket(InterHeader.Assigned))
{
packet.WriteByte(ID);
packet.WriteStringLen(String.Format("{0}-{1}", Settings.Instance.GameServiceUri, ID));
packet.WriteUShort((ushort)(Settings.Instance.ZoneBasePort + ID));
packet.WriteInt(Maps.Count);
foreach (var m in Maps)
{
packet.WriteUShort(m.ID);
packet.WriteStringLen(m.ShortName);
packet.WriteStringLen(m.FullName);
packet.WriteInt(m.RegenX);
packet.WriteInt(m.RegenY);
packet.WriteByte(m.Kingdom);
packet.WriteUShort(m.ViewRange);
}
this.SendPacket(packet);
}
}
public InterPacketReceivedEventArgs(InterPacket packet, InterClient client)
{
this.Packet = packet;
this.Client = client;
}
private static void On_CharacterManager_CharacterLogout(WorldCharacter Character)
{
GuildMember member;
if (Character.Guild != null
&& Character.Guild.GetMember(Character.Character.Name, out member))
{
//send guild member logged out to other guild members
using (var packet = new Packet(SH29Type.GuildMemberLoggedOut))
{
packet.WriteString(Character.Character.Name, 16);
Character.Guild.Broadcast(packet, member);
}
//send packet to zone that guild member logged out
using (var packet = new InterPacket(InterHeader.ZONE_GuildMemberLogout))
{
packet.WriteInt(Character.Guild.ID);
packet.WriteInt(Character.ID);
ZoneManager.Instance.Broadcast(packet);
}
}
}
private static void On_CharacterManager_CharacterLogin(WorldCharacter Character)
{
if (Character.IsInGuild)
{
var guild = Character.Guild;
//send guild info to client
using (var packet = new Packet(SH4Type.CharacterGuildinfo))
{
guild.WriteGuildInfo(packet);
Character.Client.SendPacket(packet);
}
//send member list to client
guild.SendMemberList(Character.Client);
GuildMember member;
if (guild.GetMember(Character.Character.Name, out member))
{
//send guild member logged in to other guild members
using (var packet = new Packet(SH29Type.GuildMemberLoggedIn))
{
packet.WriteString(Character.Character.Name, 16);
Character.Guild.Broadcast(packet, member);
}
}
//send packet to zone that guild member logged in
using (var packet = new InterPacket(InterHeader.ZONE_GuildMemberLogin))
{
packet.WriteInt(guild.ID);
packet.WriteInt(Character.ID);
ZoneManager.Instance.Broadcast(packet);
}
}
else
{
using (var packet = new Packet(SH4Type.CharacterGuildinfo))
{
packet.WriteInt(0);
Character.Client.SendPacket(packet);
}
}
//academy
var academy = Character.GuildAcademy;
if (academy != null)
{
if (Character.IsInGuildAcademy)
{
using (var packet = new Packet(SH4Type.CharacterGuildacademyinfo))
{
academy.WriteInfo(packet);
Character.Client.SendPacket(packet);
}
academy.SendMemberList(Character.Client);
}
else
{
using (var packet = new Packet(SH4Type.CharacterGuildacademyinfo))
{
packet.Fill(5, 0);
Character.Client.SendPacket(packet);
}
}
}
else
{
using (var packet = new Packet(SH4Type.CharacterGuildacademyinfo))
{
packet.Fill(5, 0);
Character.Client.SendPacket(packet);
}
}
}
public static void On_GameClient_UpdateGuildMessage(WorldClient Client, Packet Packet)
{
ushort length;
string message;
if (Client.Character.Guild == null
|| !Packet.TryReadUShort(out length)
|| !Packet.TryReadString(out message, length))
{
return;
}
//response packets
using (var packet = new Packet(SH29Type.UnkMessageChange))
{
packet.WriteHexAsBytes("68 1B 00 92 AD F8 4F 2E 00 00 00 2B 00 00 00 17 00 00 00 07 00 00 00 06 00 00 00 70 00 00 00 06 00 00 00 BC 00 00 00 01 00 00 00 00 00");
Client.SendPacket(packet);
}
using (var packet = new Packet(SH29Type.ClearGuildDetailsMessage))
{
packet.WriteUShort(3137);
packet.WriteLong(0);
Client.SendPacket(packet);
}
using (var packet = new Packet(SH29Type.UpdateGuildMessageResponse))
{
packet.WriteUShort(3137);
Client.SendPacket(packet);
}
//update guild
lock (Client.Character.Guild.ThreadLocker)
{
Client.Character.Guild.Message = message;
Client.Character.Guild.MessageCreater = Client.Character;
Client.Character.Guild.MessageCreateTime = Program.CurrentTime;
Client.Character.Guild.Save();
//broadcast packet to all guild members
using (var packet = new Packet(SH29Type.SendUpdateGuildDetails))
{
packet.Fill(4, 0x00);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Second);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Minute);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Hour);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Day);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Month - 1);
packet.WriteInt(Client.Character.Guild.MessageCreateTime.Year - 1900);
packet.WriteInt(0);
packet.WriteLong(0);
packet.WriteString(Client.Character.Character.Name, 16);
packet.WriteUShort(length);
packet.WriteString(message, length);
Client.Character.Guild.Broadcast(packet);
}
//send packet to zone that guild message changed
using (var packet = new InterPacket(InterHeader.ZONE_GuildMessageUpdate))
{
packet.WriteInt(Client.Character.Guild.ID);
packet.WriteInt(Client.Character.ID);
packet.WriteDateTime(Client.Character.Guild.MessageCreateTime);
packet.WriteUShort(length);
packet.WriteString(message, length);
ZoneManager.Instance.Broadcast(packet);
}
}
}
public static void On_GameClient_CreateGuild(WorldClient Client, Packet Packet)
{
string name, password;
bool allowGuildWar;
if (!Packet.TryReadString(out name, 16)
|| !Packet.TryReadString(out password, 8)
|| !Packet.ReadSkip(4) // unk ?
|| !Packet.TryReadBool(out allowGuildWar))
{
return;
}
GuildCreateResponse response;
if (Client.Character.Character.CharLevel < 20)
{
response = GuildCreateResponse.LevelTooLow;
}
else if (Client.Character.Character.Money < Guild.Price)
{
response = GuildCreateResponse.MoneyTooLow;
}
else
{
//encrypt guild pw
var pwData = Encoding.UTF8.GetBytes(password);
// InterCrypto.Encrypt(ref pwData, 0, pwData.Length);
Guild guild;
//try to create guild
lock (ThreadLocker)
{
int result;
int guildID;
var createTime = Program.CurrentTime;
using (var con = Program.DatabaseManager.GetClient().GetConnection())
{
//insert guild in db
using (var cmd = con.CreateCommand())
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "Guild_Create";
cmd.Parameters.Add(new MySqlParameter("@pName", name));
cmd.Parameters.Add(new MySqlParameter("@pPassword", pwData));
cmd.Parameters.Add(new MySqlParameter("@pAllowGuildWar", allowGuildWar));
cmd.Parameters.Add(new MySqlParameter("@pCreaterID", Client.Character.ID));
cmd.Parameters.Add(new MySqlParameter("@pCreateTime", createTime));
var idParam = cmd.Parameters.Add(new MySqlParameter("@pID", SqlDbType.Int)
{
Direction = ParameterDirection.Output
});
result = Convert.ToInt32(cmd.ExecuteScalar());
guildID = (int)idParam.Value;
}
switch (result)
{
case -1:
//guild name already exists (ToDo: get response code)
SendGuildCreateResponse(Client, name, password, allowGuildWar, GuildCreateResponse.AlredyExist);
return;
case -2: //database error @ insert guild (ToDo: get response code)
SendGuildCreateResponse(Client, name, password, allowGuildWar, GuildCreateResponse.Failed);
return;
case -3: //database error @ insert guild academy (ToDo: get response code)
SendGuildCreateResponse(Client, name, password, allowGuildWar, GuildCreateResponse.Failed);
return;
case 0:
//create guild
guild = new Guild(con, guildID, name, pwData, allowGuildWar, Client.Character, createTime);
//insert guild master (character will get updated)
guild.AddMember(Client.Character, GuildRank.Master, con, false, false);
//add to loaded guilds
LoadedGuilds.Add(guild);
break;
default:
return;
}
}
}
Client.Character.
//revoke money
Client.Character.ChangeMoney(Client.Character.Character.Money - Guild.Price);
//let character broadcast guild name packet
using (var packet = new Packet(SH29Type.GuildNameResult))
{
packet.WriteInt(guild.ID);
packet.WriteString(guild.Name, 16);
BroadcastManager.Instance.BroadcastInRange(Client.Character, packet, true);
}
//let zone know that a guild has been loaded
using (var packet = new InterPacket(InterHeader.ZONE_GuildCreated))
{
packet.WriteInt(guild.ID);
packet.WriteInt(Client.Character.ID);
ZoneManager.Instance.Broadcast(packet);
}
//set response to success
response = GuildCreateResponse.Success;
}
SendGuildCreateResponse(Client, name, password, allowGuildWar, response);
}
public void Ban()
{
Save();
// Program.worldService.DisconnectClient(this.Name, true); // TODO: Inter server packet.
using (var p = new InterPacket(InterHeader.BanAccount))
{
p.WriteString(this.Character.Name, 16);
WorldConnector.Instance.SendPacket(p);
}
Client.Disconnect();
}
public void SendPacket(InterPacket pPacket, bool crypto = true)
{
byte[] data = new byte[pPacket.Length + 4];
Buffer.BlockCopy(crypto ? InterCrypto.EncryptData(mIVSend, pPacket.ToArray()) : pPacket.ToArray(), 0, data, 4, pPacket.Length);
Buffer.BlockCopy(BitConverter.GetBytes(pPacket.Length), 0, data, 0, 4);
Send(data);
}
public void SendInterPass(string what)
{
InterPacket packet = new InterPacket(InterHeader.Auth);
packet.WriteStringLen(what);
SendPacket(packet);
}
private void EndReceive(object sender, SocketAsyncEventArgs pArguments)
{
if (_mDisconnected != 0)
{
return;
}
if (pArguments.BytesTransferred <= 0)
{
Disconnect();
return;
}
_mReceiveLength += pArguments.BytesTransferred;
if (_mReceivingPacketLength == _mReceiveLength)
{
if (_mHeader) //parse headers
{
_mReceivingPacketLength = BitConverter.ToInt32(_mReceiveBuffer, 0);
_mReceiveLength = 0;
_mReceiveStart = 0;
_mHeader = false;
// mReceiveBuffer = new byte[mReceivingPacketLength];
}
else
{
//parse packets
var packetData = new byte[_mReceivingPacketLength];
Buffer.BlockCopy(_mReceiveBuffer, 0, packetData, 0, _mReceivingPacketLength);
if (!_mIVs)
{
var packet = new InterPacket(packetData);
if (packet.OpCode == InterHeader.Ivs)
{
Log.WriteLine(LogLevel.Info, "IV data received");
packet.ReadBytes(_mIvRecv);
_mIVs = true;
}
else
{
Log.WriteLine(LogLevel.Info, "Got wrong packet.");
Disconnect();
}
}
else
{
packetData = InterCrypto.DecryptData(_mIvRecv, packetData);
if (OnPacket != null)
{
var packet = new InterPacket(packetData);
OnPacket(this, new InterPacketReceivedEventArgs(packet, this));
}
}
//we reset this packet
_mReceivingPacketLength = 4;
_mReceiveLength = 0;
_mReceiveStart = 0;
_mHeader = true;
// mReceiveBuffer = new byte[4];
}
}
else
{
_mReceiveStart += _mReceivingPacketLength;
}
BeginReceive();
pArguments.Dispose();
}
public void SendPacket(InterPacket packet)
{
if (this.client == null) return;
this.client.SendPacket(packet);
}
public static GroupMember ReadGroupMemberFromDatabase(long pCharId)
{
//--------------------------------------------------
// Quries used in this function
//--------------------------------------------------
const string get_groupmem_query =
"SELECT `Name`, `IsGroupMaster` " +
"FROM `fiesta_world`.`characters` " +
"WHERE `CharID` = '{0}'";
//--------------------------------------------------
// Read member from database.
//--------------------------------------------------
string name = "";
bool isOnline = false;
bool isMaster = false;
using (var client = Program.DatabaseManager.GetClient())
using (var cmd = new MySqlCommand(string.Format(get_groupmem_query, pCharId), client.GetConnection()))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
name = reader.GetString("Name");
if (reader.IsDBNull(reader.GetOrdinal("IsGroupMaster")))
isMaster = false;
else
isMaster = reader.GetBoolean("IsGroupMaster");
}
}
GroupMember member = new GroupMember(name, isMaster, isOnline);
if (ClientManager.Instance.HasClient(name))
{
var client = ClientManager.Instance.GetClientByCharName(name);
member.IsOnline = true;
member.Character = client.Character;
}
else
member.IsOnline = (bool)InterFunctionCallbackProvider.Instance.QueuePacket(id =>
{
var packet = new InterPacket(InterHeader.FunctionCharIsOnline);
packet.WriteLong(id);
packet.WriteString(name, 16);
return packet;
}, packet =>
{
bool value = false;
packet.TryReadBool(out value);
return value;
});
return member;
}
private void SendIVs()
{
InterPacket packet = new InterPacket(InterHeader.Ivs);
packet.WriteBytes(mIVSend);
SendPacket(packet, false);
}
private void EndReceive(object sender, SocketAsyncEventArgs pArguments)
{
if (mDisconnected != 0) return;
if (pArguments.BytesTransferred <= 0)
{
Disconnect();
return;
}
mReceiveLength += pArguments.BytesTransferred;
if (mReceivingPacketLength == mReceiveLength)
{
if (mHeader) //parse headers
{
mReceivingPacketLength = BitConverter.ToInt32(mReceiveBuffer, 0);
mReceiveLength = 0;
mReceiveStart = 0;
mHeader = false;
// mReceiveBuffer = new byte[mReceivingPacketLength];
}
else
{ //parse packets
byte[] packetData = new byte[mReceivingPacketLength];
Buffer.BlockCopy(mReceiveBuffer, 0, packetData, 0, mReceivingPacketLength);
if (!mIVs)
{
InterPacket packet = new InterPacket(packetData);
if (packet.OpCode == InterHeader.Ivs)
{
Log.WriteLine(LogLevel.Info, "IV data received");
packet.ReadBytes(mIVRecv);
mIVs = true;
}
else
{
Log.WriteLine(LogLevel.Info, "Got wrong packet.");
Disconnect();
}
}
else
{
packetData = InterCrypto.DecryptData(mIVRecv, packetData);
if (OnPacket != null)
{
InterPacket packet = new InterPacket(packetData);
this.OnPacket(this, new InterPacketReceivedEventArgs(packet, this));
}
}
//we reset this packet
mReceivingPacketLength = 4;
mReceiveLength = 0;
mReceiveStart = 0;
mHeader = true;
// mReceiveBuffer = new byte[4];
}
}
else
{
mReceiveStart += mReceivingPacketLength;
}
BeginReceive();
pArguments.Dispose();
}
