private static void SavePlayers()
{
foreach (string clientKey in WorldSocket.Clients.Keys)
{
WorldClient thisclient = WorldSocket.Clients[clientKey] as WorldClient;
if (thisclient != null && thisclient.playerData.lastSaveTime == 0)
{
thisclient.playerData.lastSaveTime = TimeUtils.getUnixTimeUint32();
}
if (thisclient != null && (TimeUtils.getUnixTimeUint32() - thisclient.playerData.lastSaveTime) > 20)
{
thisclient.playerData.lastSaveTime = TimeUtils.getUnixTimeUint32();
// Save Player
new PlayerHelper().savePlayerInfo(thisclient);
// Notify Player about save
ServerPackets pak = new ServerPackets();
pak.sendSaveCharDataMessage(thisclient,
StringUtils.charBytesToString_NZ(thisclient.playerInstance.CharacterName.getValue()));
}
// Handle Jackout exit
if (thisclient.playerData.isJackoutInProgress == true &&
(thisclient.playerData.jackoutStartTime - TimeUtils.getUnixTimeUint32()) > 5)
{
ServerPackets packets = new ServerPackets();
packets.sendExitGame(thisclient);
}
}
}
public void processHardlineExitConfirm(ref byte[] packet)
{
ServerPackets packets = new ServerPackets();
switch (packet[0])
{
case 0x01:
ServerPackets serverPak = new ServerPackets();
#if DEBUG
serverPak.sendSystemChatMessage(Store.currentClient, "Exit to LA init...", "MODAL");
#endif
// Tell client we want to reset
byte[] response = { 0x81, 0x07 };
Store.currentClient.messageQueue.addRpcMessage(response);
break;
case 0x02:
Store.currentClient.playerData.isJackoutInProgress = true;
Store.currentClient.playerData.jackoutStartTime = TimeUtils.getUnixTimeUint32();
packets.sendJackoutEffect(Store.currentClient);
break;
}
}
public void processPacket(byte[] packet)
{
// Update the last time we are called
lastUsedTime = TimeUtils.getUnixTimeUint32();
// Decryption start
bool encrypted = false;
byte[] processedPacket = null;
if (packet.Length > 0)
{
if (packet[0] == 0x00)
{ // Plain text packet
processedPacket = packet;
}
else
{
encrypted = true;
processedPacket = decryptReceivedPacket(packet);
}
Output.WriteLine("\n" + key + " PSS = " + playerData.getPss() + ", Cseq = " + playerData.getCseq() + ", AckSSeq = " + playerData.getACK());
Output.WriteLine("D: " + StringUtils.bytesToString(processedPacket));
Output.WritePacketLog(StringUtils.bytesToString(processedPacket), "CLIENT", playerData.getPss().ToString(), playerData.getCseq().ToString(), playerData.getACK().ToString());
Store.Mpm.Parse(encrypted, processedPacket);
flushQueue();
}
}
public void processHyperJump(ref byte[] rpcData)
{
double xDest = 0;
double yDest = 0;
double zDest = 0;
PacketReader reader = new PacketReader(rpcData);
xDest = reader.readDouble(1);
yDest = reader.readDouble(1);
zDest = reader.readDouble(1);
// ToDo: figure out what this 6 bytes are could be
// Skip 6 bytes as we currently didnt knew
byte[] unknownJumpBytes = reader.readBytes(6);
float maybeMaxHeight = reader.readFloat(1);
reader.incrementOffsetByValue(1);
UInt32 clientJumpIdUnknown = reader.readUInt32(1);
// Players current X Z Y
double x = 0;
double y = 0;
double z = 0;
byte[] Ltvector3d = Store.currentClient.playerInstance.Position.getValue();
NumericalUtils.LtVector3dToDoubles(Ltvector3d, ref x, ref y, ref z);
int rotation = (int)Store.currentClient.playerInstance.YawInterval.getValue()[0];
float xPos = (float)x;
float yPos = (float)y;
float zPos = (float)z;
LtVector3f[] JumpMovements = Maths.ParabolicMovement(new LtVector3f(xPos, yPos, zPos),
new LtVector3f((float)xDest, (float)yDest, (float)zDest), 50, 128);
float distance = Maths.getDistance(xPos, yPos, zPos, (float)xDest, (float)yDest, (float)zDest);
UInt16 duration = (UInt16)(distance * 0.5f);
UInt32 startTime = TimeUtils.getUnixTimeUint32();
UInt32 endTime = startTime + duration;
ServerPackets packets = new ServerPackets();
packets.sendHyperJumpID(clientJumpIdUnknown);
Store.currentClient.playerData.isJumping = true;
Store.currentClient.playerData.incrementJumpID();
UInt32 maybeTimeBasedValue = 40384248;
foreach (LtVector3f currentJumpPos in JumpMovements)
{
Steps.Add(new JumpStep(currentJumpPos, new LtVector3f((float)xDest, (float)yDest, (float)zDest),
maybeMaxHeight, endTime, Store.currentClient.playerData.getJumpID(), maybeTimeBasedValue));
//packets.SendHyperJumpStepUpdate(currentJumpPos, xDest, yDest, zDest, maybeMaxHeight, endTime);
maybeTimeBasedValue = maybeTimeBasedValue + 100;
}
hyperjumpTimer = new Timer(ProcessJumpStep, this, 0, 0);
//packets.SendHyperJumpUpdate(xPos,yPos,zPos,(float)xDest,(float)yDest,(float)zDest,startTime,endTime);
}
private void CleanNakPackets()
{
// ToDo: split flushQueue and resending
UInt32 currentTime = TimeUtils.getUnixTimeUint32();
// Remove Packets that are resent more than 3 times and we didnt got an ack for it
ArrayList ackedObjectMessages = new ArrayList();
lock (messageQueue.ObjectMessagesQueue.SyncRoot)
{
foreach (SequencedMessage message in messageQueue.ObjectMessagesQueue)
{
if (message.sendCounter >= 10 && message.getResendTime() >= TimeUtils.getUnixTimeUint32())
{
ackedObjectMessages.Add(message);
}
}
}
ArrayList ackedRPCMessages = new ArrayList();
lock (messageQueue.RPCMessagesQueue.SyncRoot)
{
foreach (SequencedMessage message in messageQueue.RPCMessagesQueue)
{
if (message.sendCounter >= 10 && message.getResendTime() >= TimeUtils.getUnixTimeUint32())
{
ackedRPCMessages.Add(message);
}
}
}
// Now delete them finally
foreach (SequencedMessage deletedAckObject in ackedObjectMessages)
{
lock (messageQueue.ObjectMessagesQueue.SyncRoot)
{
messageQueue.ObjectMessagesQueue.Remove(deletedAckObject);
}
}
foreach (SequencedMessage deletedAckRpc in ackedRPCMessages)
{
lock (messageQueue.RPCMessagesQueue.SyncRoot)
{
messageQueue.RPCMessagesQueue.Remove(deletedAckRpc);
}
}
}
public void processPacket(byte[] packet)
{
// Update the last time we are called
lastUsedTime = TimeUtils.getUnixTimeUint32();
// Decryption start
bool encrypted = false;
byte[] processedPacket = null;
Stopwatch stopwatch = new Stopwatch();
if (packet.Length > 0)
{
if (packet[0] == 0x00)
{
// Plain text packet
processedPacket = packet;
Output.WritePacketLog(processedPacket, "CLIENT",
playerData.getPss().ToString(), playerData.getCseq().ToString(),
playerData.getACK().ToString());
}
else
{
encrypted = true;
stopwatch.Start();
processedPacket = DecryptReceivedPacket(packet);
stopwatch.Stop();
TimeSpan ts = stopwatch.Elapsed;
Output.WritePacketLog(processedPacket, "CLIENT",
playerData.getPss().ToString(), playerData.getCseq().ToString(), playerData.getACK().ToString(),
ts.TotalMilliseconds.ToString(), "DECRYPT");
}
// Output.WriteLine("\n" + key + " PSS = " + playerData.getPss() + ", Cseq = " + playerData.getCseq() +
// ", AckSSeq = " + playerData.getACK());
Store.Mpm.Parse(encrypted, processedPacket);
FlushQueue();
}
}
public void processHyperJumpCancel(ref byte[] rpcData)
{
double xDest = 0;
double yDest = 0;
double zDest = 0;
PacketReader reader = new PacketReader(rpcData);
xDest = reader.readDouble(1);
yDest = reader.readDouble(1);
zDest = reader.readDouble(1);
// ToDo: figure out what this 6 bytes are could be
// Skip 6 bytes as we currently didnt knew
reader.incrementOffsetByValue(6);
UInt32 maybeMaxHeight = reader.readUInt32(1);
reader.setOffsetOverrideValue(rpcData.Length - 4);
UInt32 clientJumpIdUnknown = reader.readUInt32(1);
// Players current X Z Y
double x = 0; double y = 0; double z = 0;
byte[] Ltvector3d = Store.currentClient.playerInstance.Position.getValue();
NumericalUtils.LtVector3dToDoubles(Ltvector3d, ref x, ref y, ref z);
int rotation = (int)Store.currentClient.playerInstance.YawInterval.getValue()[0];
float xPos = (float)x;
float yPos = (float)y;
float zPos = (float)z;
float distance = Maths.getDistance(xPos, yPos, zPos, (float)xDest, (float)yDest, (float)zDest);
UInt16 duration = (UInt16)(distance * 0.5);
UInt32 startTime = TimeUtils.getUnixTimeUint32();
UInt32 endTime = startTime + duration;
ServerPackets packets = new ServerPackets();
packets.sendHyperJumpID(clientJumpIdUnknown);
packets.SendHyperJumpUpdate(xPos, yPos, zPos, (float)xDest, (float)yDest, (float)zDest, startTime, endTime);
}
public void processHyperJump(ref byte[] packet)
{
byte[] destXBytes = new byte[8];
byte[] destYBytes = new byte[8];
byte[] destZBytes = new byte[8];
byte[] maxHeight = new byte[4];
byte[] theLast4 = new byte[4]; // we dont know what this is lol
DynamicArray restBytes = new DynamicArray();
ArrayUtils.copy(packet, 0, destXBytes, 0, 8);
ArrayUtils.copy(packet, 8, destYBytes, 0, 8);
ArrayUtils.copy(packet, 16, destZBytes, 0, 8);
ArrayUtils.copy(packet, 30, maxHeight, 0, 4);
ArrayUtils.copy(packet, packet.Length - 4, theLast4, 0, 4);
// Players current X Z Y
double x = 0; double y = 0; double z = 0;
byte[] Ltvector3d = Store.currentClient.playerInstance.Position.getValue();
NumericalUtils.LtVector3dToDoubles(Ltvector3d, ref x, ref y, ref z);
int rotation = (int)Store.currentClient.playerInstance.YawInterval.getValue()[0];
float xPos = (float)x;
float yPos = (float)y;
float zPos = (float)z;
float xDestFloat = (float)NumericalUtils.byteArrayToDouble(destXBytes, 1);
float yDestFloat = (float)NumericalUtils.byteArrayToDouble(destYBytes, 1);
float zDestFloat = (float)NumericalUtils.byteArrayToDouble(destZBytes, 1);
float distance = getDistance(xPos, yPos, zPos, xDestFloat, yDestFloat, zDestFloat);
UInt16 duration = (UInt16)(distance * 1.5);
//UInt32 startTime = TimeUtils.getUnixTimeUint32() - 100000;
//UInt32 endTime = startTime + duration;
UInt32 startTime = TimeUtils.getUnixTimeUint32();
UInt32 endTime = startTime + duration;
PacketContent pak = new PacketContent();
pak.addByte(0x02);
pak.addByte(0x00);
pak.addByte(0x03);
pak.addByte(0x09);
pak.addByte(0x08);
pak.addByte(0x00);
pak.addFloatLtVector3f(xPos, yPos, zPos);
pak.addUint32(startTime, 1);
pak.addByte(0x80);
pak.addByte(0x80);
pak.addByte(0xb8);
pak.addByte(0x14); // if 0xb8
pak.addByte(0x00); // if 0xb8
pak.addUint32(endTime, 1);
pak.addByteArray(destXBytes);
pak.addByteArray(destYBytes);
pak.addByteArray(destZBytes);
pak.addByteArray(new byte[] { 0x10, 0xff, 0xff });
pak.addByte(0x00);
pak.addByte(0x00);
pak.addByte(0x00);
Store.currentClient.messageQueue.addObjectMessage(pak.returnFinalPacket(), true);
}
// Flush the MessageQueue Lists to the Client
public void flushQueue()
{
// This resend the MessageQueue - should be called after parsing or after sending something out
// or in a timed interval (keep alive for example)
// Sends RAW MEssages
sendRawMessages();
Output.WriteLine("[CLIENT] In Queue Messages : " + messageQueue.ObjectMessagesQueue.Count.ToString() + " Object and " + messageQueue.RPCMessagesQueue.Count.ToString() + " RPC Messages");
ArrayList worldPackets = new ArrayList();
WorldPacket packet = new WorldPacket(playerData);
// Init encrypted Packet if we have MPM Messages
if (messageQueue.RPCMessagesQueue.Count > 0 || messageQueue.ObjectMessagesQueue.Count > 0 && flushingQueueInProgress == false)
{
flushingQueueInProgress = true;
// we currently dont know if we send something out so we need to proove that in a way
if (messageQueue.ObjectMessagesQueue.Count > 0)
{
UInt16 sendingSSeq = playerData.calculateNextPossibleSseq();
lock (messageQueue.ObjectMessagesQueue.SyncRoot)
{
foreach (SequencedMessage messageObjects in messageQueue.ObjectMessagesQueue)
{
// Just append each message...
if (messageObjects.getResendTime() >= TimeUtils.getUnixTimeUint32() || messageObjects.getResendTime() == 0)
{
// Check if this really save the resendtime or not
messageObjects.increaseResendTime();
bool canAddThePak = packet.addObjectContent(messageObjects);
if (canAddThePak == false)
{
packet.isFinal = true;
// if one sub has a timed param set, we just set it here too
worldPackets.Add(packet);
// Start new packet and add it to the queue
packet = new WorldPacket(playerData);
packet.addRPCContent(messageObjects);
}
if (messageObjects.isTimed == true)
{
packet.timed = true;
}
}
}
}
}
// Workaround: complete the packet so we dont mix up
if (packet.ObjectMessages.Count > 0)
{
packet.isFinal = true;
worldPackets.Add(packet);
packet = new WorldPacket(playerData);
packet.timed = false;
}
if (messageQueue.RPCMessagesQueue.Count > 0)
{
lock (messageQueue.RPCMessagesQueue.SyncRoot)
{
foreach (SequencedMessage messageRPC in messageQueue.RPCMessagesQueue)
{
// First do stuff on messages
// Just append each message...
if (messageRPC.getResendTime() >= TimeUtils.getUnixTimeUint32() || messageRPC.getResendTime() == 0)
{
// Check if this really save the resendtime or not
messageRPC.increaseResendTime();
if (packet.addRPCContent(messageRPC) == false)
{
packet.isFinal = true;
worldPackets.Add(packet);
// Start new packet and add it to the queue
packet = new WorldPacket(playerData);
packet.addRPCContent(messageRPC);
}
if (messageRPC.isTimed == true)
{
packet.timed = true;
}
}
}
}
}
// Check if the current not finalize packet has content and needs to be send
if ((packet.isFinal == false) && (packet.ObjectMessages.Count > 0 || packet.RPCMessages.Count > 0))
{
worldPackets.Add(packet);
}
}
// We have nothing - but we should really ack this
if (messageQueue.ackOnlyCount > 0)
{
for (int i = 0; i < messageQueue.ackOnlyCount; i++)
{
WorldPacket ackPacket = new WorldPacket(playerData);
packet.isFinal = true;
packet.timed = false;
worldPackets.Add(ackPacket);
}
messageQueue.ackOnlyCount = 0;
}
// We have now PacketObjects - time to send them
if (worldPackets.Count > 0)
{
Output.WriteLine("[CLIENT] Flush the final Queue with " + worldPackets.Count.ToString() + " Packets");
foreach (WorldPacket thePacket in worldPackets)
{
playerData.IncrementSseq();
byte[] finalData = thePacket.getFinalData(playerData);
Output.WritePacketLog(StringUtils.bytesToString(finalData), "SERVER", playerData.getPss().ToString(), playerData.getCseq().ToString(), playerData.getSseq().ToString());
byte[] encryptedData = cypher.encrypt(finalData, finalData.Length, playerData.getPss(), playerData.getCseq(), playerData.getSseq());
sendPacket(encryptedData);
Output.WriteDebugLog("PACKET SEND FINALLY (WC AFTER sendPacket):" + StringUtils.bytesToString(finalData));
}
}
flushingQueueInProgress = false;
}
public npc()
{
this.next_move_time = TimeUtils.getUnixTimeUint32() + (30); // 30 seconds for a move to test
}
