| public WriteInt32 ( int Value ) : void | ||
| Value | int | The 32 bit integer to write. |
| return | void | |
/// <summary>
/// Ticks the VM one step.
/// Should be called once every loop.
/// </summary>
public void Tick()
{
foreach (VirtualThread Thread in m_Threads)
{
Thread.Tick();
}
m_TickCounter++;
if (m_TickCounter == 4)
{
//TODO: Change ID...
PacketStream SimulationStatePacket = new PacketStream(0x10, 0x00);
SimulationStatePacket.WriteByte(0x10); //TODO: Change ID
SimulationStatePacket.WriteByte((byte)m_TickCounter); //Number of ticks since last update.
SimulationStatePacket.WriteInt32(m_Threads.Count); //Number of objects in this VM.
BinaryFormatter BinFormatter = new BinaryFormatter();
foreach (VirtualThread VThread in m_Threads)
BinFormatter.Serialize(SimulationStatePacket, VThread);
//TODO: Compress packet...
NewSimulationStateEvent(SimulationStatePacket);
m_TickCounter = 0;
}
}
/// <summary>
/// Sends a CharacterCreate packet to the LoginServer.
/// </summary>
/// <param name="Character">The character to create.</param>
/// <param name="TimeStamp">The timestamp of when this character was created.</param>
public static void SendCharacterCreate(UISim Character, string TimeStamp)
{
PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_CREATE, 0);
Packet.WriteString(NetworkFacade.Client.ClientEncryptor.Username);
Packet.WriteString(TimeStamp);
Packet.WriteString(Character.Name);
Packet.WriteString(Character.Sex);
Packet.WriteString(Character.Description);
Packet.WriteUInt64(Character.HeadOutfitID);
Packet.WriteUInt64(Character.BodyOutfitID);
Packet.WriteByte((byte)Character.Avatar.Appearance);
Packet.WriteString(Character.ResidingCity.Name);
Packet.WriteUInt64(Character.ResidingCity.Thumbnail);
Packet.WriteString(Character.ResidingCity.UUID);
Packet.WriteUInt64(Character.ResidingCity.Map);
Packet.WriteString(Character.ResidingCity.IP);
Packet.WriteInt32(Character.ResidingCity.Port);
byte[] PacketData = Packet.ToArray();
NetworkFacade.Client.SendEncrypted((byte)PacketType.CHARACTER_CREATE, PacketData);
}
private void SendToServer(VMNetCommandBodyAbstract cmd)
{
byte[] data;
using (var stream = new MemoryStream())
{
var cmd2 = new VMNetCommand(cmd);
using (var writer = new BinaryWriter(stream))
{
cmd2.SerializeInto(writer);
}
data = stream.ToArray();
}
using (var stream = new PacketStream((byte)PacketType.VM_PACKET, 0))
{
stream.WriteHeader();
stream.WriteInt32(data.Length + (int)PacketHeaders.UNENCRYPTED);
stream.WriteBytes(data);
Client.Send(stream.ToArray());
}
}
protected virtual void ReceiveCallback(IAsyncResult AR)
{
Socket Sock = (Socket)AR.AsyncState;
int NumBytesRead = 0;
try {
NumBytesRead = Sock.EndReceive(AR);
}
catch (SocketException)
{
Disconnect();
return;
}
if (NumBytesRead == 0)
{
return;
}
byte[] TmpBuf = new byte[NumBytesRead];
Buffer.BlockCopy(m_RecvBuf, 0, TmpBuf, 0, NumBytesRead);
int Offset = 0;
while (Offset < NumBytesRead)
{
if (m_TempPacket == null)
{
byte ID = TmpBuf[Offset++];
PacketStream TempPacket = new PacketStream(ID, 0);
TempPacket.WriteByte(ID);
m_HeaderBuild = new List <byte>();
while (Offset < NumBytesRead && m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
if (m_HeaderBuild.Count < 4)
{
m_TempPacket = TempPacket;
//length got fragmented.
}
else
{
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
TempPacket.SetLength(Length);
TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, TempPacket.Length - TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
TempPacket.WriteBytes(TmpBuffer);
m_TempPacket = TempPacket;
}
}
else //fragmented, continue from last
{
if (m_HeaderBuild != null)
{
//we can safely assume that resuming from a fragmented length, it cannot get fragmented again.
while (m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
m_TempPacket.SetLength(Length);
m_TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
}
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, m_TempPacket.Length - m_TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
m_TempPacket.WriteBytes(TmpBuffer);
}
if (m_TempPacket != null && m_TempPacket.BufferLength == m_TempPacket.Length)
{
var handler = FindPacketHandler(m_TempPacket.PacketID);
if (handler != null)
{
OnPacket(new ProcessedPacket(m_TempPacket.PacketID, handler.Encrypted,
handler.VariableLength, (int)m_TempPacket.Length, m_ClientEncryptor, m_TempPacket.ToArray()), handler);
}
m_TempPacket = null;
}
}
try
{
m_Sock.BeginReceive(m_RecvBuf, 0, m_RecvBuf.Length, SocketFlags.None,
new AsyncCallback(ReceiveCallback), m_Sock);
}
catch (SocketException)
{
Disconnect();
return;
}
}
protected virtual void ReceiveCallback(IAsyncResult AR)
{
Socket Sock = (Socket)AR.AsyncState;
int NumBytesRead = 0;
try {
NumBytesRead = Sock.EndReceive(AR);
}
catch (SocketException)
{
Disconnect();
return;
}
if (NumBytesRead == 0)
{
Disconnect();
return;
}
byte[] TmpBuf = new byte[NumBytesRead];
Buffer.BlockCopy(m_RecvBuf, 0, TmpBuf, 0, NumBytesRead);
int Offset = 0;
while (Offset < NumBytesRead)
{
if (m_TempPacket == null)
{
byte ID = TmpBuf[Offset++];
PacketStream TempPacket = new PacketStream(ID, 0);
TempPacket.WriteByte(ID);
m_HeaderBuild = new List<byte>();
while (Offset < NumBytesRead && m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
if (m_HeaderBuild.Count < 4)
{
m_TempPacket = TempPacket;
//length got fragmented.
} else
{
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
TempPacket.SetLength(Length);
TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, TempPacket.Length-TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
TempPacket.WriteBytes(TmpBuffer);
m_TempPacket = TempPacket;
}
}
else //fragmented, continue from last
{
if (m_HeaderBuild != null)
{
//we can safely assume that resuming from a fragmented length, it cannot get fragmented again.
while (m_HeaderBuild.Count < 4)
{
m_HeaderBuild.Add(TmpBuf[Offset++]);
}
int Length = BitConverter.ToInt32(m_HeaderBuild.ToArray(), 0);
m_TempPacket.SetLength(Length);
m_TempPacket.WriteInt32(Length);
m_HeaderBuild = null;
}
byte[] TmpBuffer = new byte[Math.Min(NumBytesRead - Offset, m_TempPacket.Length - m_TempPacket.BufferLength)];
Buffer.BlockCopy(TmpBuf, Offset, TmpBuffer, 0, TmpBuffer.Length);
Offset += TmpBuffer.Length;
m_TempPacket.WriteBytes(TmpBuffer);
}
if (m_TempPacket != null && m_TempPacket.BufferLength == m_TempPacket.Length)
{
var handler = FindPacketHandler(m_TempPacket.PacketID);
if (handler != null)
{
OnPacket(new ProcessedPacket(m_TempPacket.PacketID, handler.Encrypted,
handler.VariableLength, (int)m_TempPacket.Length, m_ClientEncryptor, m_TempPacket.ToArray()), handler);
}
m_TempPacket = null;
}
}
try
{
m_Sock.BeginReceive(m_RecvBuf, 0, m_RecvBuf.Length, SocketFlags.None,
new AsyncCallback(ReceiveCallback), m_Sock);
}
catch (SocketException)
{
Disconnect();
return;
}
}
public static void SendLoginRequestCity(LoginArgsContainer Args)
{
PacketStream Packet = new PacketStream((byte)PacketType.LOGIN_REQUEST_CITY, 0);
Packet.WriteHeader();
ECDiffieHellmanCng PrivateKey = Args.Client.ClientEncryptor.GetDecryptionArgsContainer()
.AESDecryptArgs.PrivateKey;
//IMPORTANT: Public key must derive from the private key!
byte[] ClientPublicKey = PrivateKey.PublicKey.ToByteArray();
byte[] NOnce = Args.Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
Packet.WriteInt32(((byte)PacketHeaders.UNENCRYPTED +
(ClientPublicKey.Length + 1) + (NOnce.Length + 1)));
Packet.WriteByte((byte)ClientPublicKey.Length);
Packet.WriteBytes(ClientPublicKey);
Packet.WriteByte((byte)NOnce.Length);
Packet.WriteBytes(NOnce);
Args.Client.Send(Packet.ToArray());
}
public static void SendLoginRequest(LoginArgsContainer Args)
{
PacketStream InitialPacket = new PacketStream((byte)PacketType.LOGIN_REQUEST, 0);
InitialPacket.WriteHeader();
ECDiffieHellmanCng PrivateKey = Args.Client.ClientEncryptor.GetDecryptionArgsContainer()
.AESDecryptArgs.PrivateKey;
//IMPORTANT: Public key must derive from the private key!
byte[] ClientPublicKey = PrivateKey.PublicKey.ToByteArray();
byte[] NOnce = Args.Client.ClientEncryptor.GetDecryptionArgsContainer().AESDecryptArgs.NOnce;
InitialPacket.WriteInt32(((byte)PacketHeaders.UNENCRYPTED +
/*4 is for version*/ 4 + (ClientPublicKey.Length + 1) + (NOnce.Length + 1)));
SaltedHash Hash = new SaltedHash(new SHA512Managed(), Args.Username.Length);
byte[] HashBuf = Hash.ComputePasswordHash(Args.Username, Args.Password);
PlayerAccount.Hash = HashBuf;
string[] Version = GlobalSettings.Default.ClientVersion.Split('.');
InitialPacket.WriteByte((byte)int.Parse(Version[0])); //Version 1
InitialPacket.WriteByte((byte)int.Parse(Version[1])); //Version 2
InitialPacket.WriteByte((byte)int.Parse(Version[2])); //Version 3
InitialPacket.WriteByte((byte)int.Parse(Version[3])); //Version 4
InitialPacket.WriteByte((byte)ClientPublicKey.Length);
InitialPacket.WriteBytes(ClientPublicKey);
InitialPacket.WriteByte((byte)NOnce.Length);
InitialPacket.WriteBytes(NOnce);
Args.Client.Send(InitialPacket.ToArray());
}
private void SendTickBuffer()
{
var ticks = new VMNetTickList { Ticks = TickBuffer };
byte[] data;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
ticks.SerializeInto(writer);
}
data = stream.ToArray();
}
using (var stream = new PacketStream((byte)PacketType.VM_PACKET, 0))
{
stream.WriteHeader();
stream.WriteInt32(data.Length + (int)PacketHeaders.UNENCRYPTED);
stream.WriteBytes(data);
Broadcast(stream.ToArray(), ClientsToSync);
}
TickBuffer.Clear();
}
private void SendState(VM vm)
{
if (ClientsToSync.Count == 0) return;
//Console.WriteLine("== SERIAL: Sending State to Client... ==");
var watch = new Stopwatch();
watch.Start();
var state = vm.Save();
//Console.WriteLine("== STATE: Intermediate - after save... " + watch.ElapsedMilliseconds + " ms. ==");
var cmd = new VMNetCommand(new VMStateSyncCmd { State = state });
//currently just hack this on the tick system. will change when we switch to not gonzonet
var ticks = new VMNetTickList { Ticks = new List<VMNetTick> {
new VMNetTick {
Commands = new List<VMNetCommand> { cmd },
RandomSeed = 0, //will be restored by client from cmd
TickID = TickID
}
} };
byte[] data;
using (var stream = new MemoryStream())
{
//Console.WriteLine("== STATE: Intermediate - before serialize... " + watch.ElapsedMilliseconds + " ms. ==");
using (var writer = new BinaryWriter(stream))
{
ticks.SerializeInto(writer);
}
//Console.WriteLine("== STATE: Intermediate - before toArray... " + watch.ElapsedMilliseconds + " ms. ==");
data = stream.ToArray();
}
//Console.WriteLine("== STATE: Intermediate - before send... " + watch.ElapsedMilliseconds + " ms. ==");
byte[] packet;
using (var stream = new PacketStream((byte)PacketType.VM_PACKET, 0))
{
stream.WriteHeader();
stream.WriteInt32(data.Length + (int)PacketHeaders.UNENCRYPTED);
stream.WriteBytes(data);
packet = stream.ToArray();
}
foreach (var client in ClientsToSync) client.Send(packet);
ClientsToSync.Clear();
watch.Stop();
//Console.WriteLine("== SERIAL: DONE! State send took "+watch.ElapsedMilliseconds+" ms. ==");
}
//uh, this is a little silly.
private void SendOneOff(NetworkClient client, VMNetTick tick)
{
var ticks = new VMNetTickList { Ticks = new List<VMNetTick>() { tick }, ImmediateMode = true };
byte[] data;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
ticks.SerializeInto(writer);
}
data = stream.ToArray();
}
using (var stream = new PacketStream((byte)PacketType.VM_PACKET, 0))
{
stream.WriteHeader();
stream.WriteInt32(data.Length + (int)PacketHeaders.UNENCRYPTED);
stream.WriteBytes(data);
client.Send(stream.ToArray());
}
}
private void SendState(VM vm)
{
if (ClientsToSync.Count == 0) return;
var state = vm.Save();
var cmd = new VMNetCommand(new VMStateSyncCmd { State = state });
//currently just hack this on the tick system. will change when we switch to not gonzonet
var ticks = new VMNetTickList { Ticks = new List<VMNetTick> {
new VMNetTick {
Commands = new List<VMNetCommand> { cmd },
RandomSeed = 0, //will be restored by client from cmd
TickID = TickID
}
} };
byte[] data;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
ticks.SerializeInto(writer);
}
data = stream.ToArray();
}
using (var stream = new PacketStream((byte)PacketType.VM_PACKET, 0))
{
stream.WriteHeader();
stream.WriteInt32(data.Length + (int)PacketHeaders.UNENCRYPTED);
stream.WriteBytes(data);
var packet = stream.ToArray();
foreach (var client in ClientsToSync) client.Send(packet);
}
ClientsToSync.Clear();
}
