|
public static uint16ToByteArray ( |
||
| data | ||
| reversed | int | |
| return | byte[] | |
public void sendMarketPlaceList(WorldClient client)
{
// ToDo: make it dynamic with database later (but the "handler" should give the items as arguments for this method
// List Marketplace Items
byte[] headerSeperator = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
// Should foreach this later on "Real Server"
DynamicArray listItems = new DynamicArray();
listItems.append(StringUtils.hexStringToBytes("8703000000000034bdcf1200401f00000310db6a4a")); // Foot Wear
listItems.append(0x00); // Seperate each item
listItems.append(StringUtils.hexStringToBytes("2e00000003a04a000bd012000000FFFF01aedc6a4a")); // Google
listItems.append(0x00); // Seperate each item
listItems.append(StringUtils.hexStringToBytes("721a000003a04a000bd012000000FFFF01aedc6a4a")); // Item Data
listItems.append(0x00); // Seperate each item
listItems.append(StringUtils.hexStringToBytes("2e00000003a04a000bd01200000000FF01aedc6a4a")); // Item Data
listItems.append(0x00); // Seperate each item
// get data size
byte[] itemSize = NumericalUtils.uint16ToByteArray((UInt16)listItems.getBytes().Length, 1);
PacketContent pak = new PacketContent();
pak.addUint16((UInt16)RPCResponseHeaders.SERVER_LOAD_MARKERPLACE, 0);
pak.addUintShort(9); // list offset
pak.addByteArray(headerSeperator);
pak.addUint16((UInt16)listItems.getBytes().Length, 1);
pak.addByteArray(listItems.getBytes());
client.messageQueue.addRpcMessage(pak.returnFinalPacket());
}
public void generateRpcMessageData()
{
// Example : 04 01 00 15 01 + submessages
// Strcut: uint8 04 header + uint8 listcount + uint16 currentRPCCounter + submessageCounter (list1)
// If you have 2 lists , the data struct is : uint8 submessagecount + submessages
// TODO!!! FINALIZE!!
// Here goes code from RPCPacket (As it should be generated on the fly)
if (RPCMessages.Count > 0)
{
content.append((byte)ProtocolHeaders.RPC_PROTOCOL);
// ToDo: Figure out what the "Lists" Count should handle ...maybe different types?
// Why not having just one List and adding them all ? Maybe a list has a limit ?
content.append(0x01); // List Count for RPC Messages
Output.WriteLine(" RPC COUNTER BYTES :" + StringUtils.bytesToString(NumericalUtils.uint16ToByteArray(playerData.getRPCCounter(), 0)));
content.append(NumericalUtils.uint16ToByteArray(playerData.getRPCCounter(), 0));
content.append(NumericalUtils.uint16ToByteArrayShort((UInt16)RPCMessages.Count));
foreach (SequencedMessage message in RPCMessages)
{
content.append(message.content);
}
// Set new RPC Counter
UInt16 incrementRpcCounter = playerData.getRPCCounter();
Output.WriteDebugLog("Before RPC Counter :" + incrementRpcCounter.ToString());
incrementRpcCounter += (ushort)RPCMessages.Count;
playerData.setRPCCounter(incrementRpcCounter);
Output.WriteDebugLog("After RPC Counter :" + incrementRpcCounter.ToString() + " (should added " + RPCMessages.Count.ToString() + ")");
}
}
public void sendTCPVariableLenPacket(byte[] packet, NetworkStream client)
{
byte[] size = { };
byte[] bytesize = { };
if (packet.Length > 127)
{
//Do NOT reverse here :P
bytesize = NumericalUtils.uint16ToByteArray((UInt16)(packet.Length + 0x8000), 0);
}
else
{
bytesize = NumericalUtils.uint16ToByteArrayShort((ushort)packet.Length);
}
byte[] finalPacket = new byte[packet.Length + bytesize.Length];
DynamicArray din = new DynamicArray();
din.append(bytesize);
din.append(packet);
finalPacket = din.getBytes();
try
{
client.Write(finalPacket, 0, finalPacket.Length);
}
catch (Exception ex)
{
Console.WriteLine("ERROR ex: " + ex.ToString());
throw;
}
client.Flush();
}
private byte[] getRpcBytes()
{
UInt16 rpcCounter = destClient.playerData.getRPCCounter();
byte [] rpc = NumericalUtils.uint16ToByteArray(rpcCounter, 0);
return(rpc);
}
public void addSizedTerminatedString(string value)
{
int size = value.Length + 1;
packet.append(NumericalUtils.uint16ToByteArray((UInt16)size, 1));
packet.append(StringUtils.stringToBytes(value));
packet.append(0x00);
}
public byte[] getByteContents()
{
DynamicArray response = new DynamicArray();
byte[] numWorldsH = NumericalUtils.uint16ToByteArray((UInt16)numWorlds, 1);
response.append(numWorldsH);
response.append(worlds.getBytes());
return(response.getBytes());
}
public byte[] getByteContents()
{
DynamicArray response = new DynamicArray();
byte[] totalCharsH = NumericalUtils.uint16ToByteArray((UInt16)totalChars, 1);
response.append(totalCharsH);
response.append(charData.getBytes());
response.append(charNames.getBytes());
return(response.getBytes());
}
/// <summary>
/// This sends a View Create/Update/Delete Packet to all Players
/// </summary>
/// <param name="data">Packet Stream without ViewID</param>
/// <param name="charId">from charId</param>
/// <param name="goId">from GoId</param>
public void sendViewPacketToAllPlayers(byte[] data, UInt32 charId, UInt32 goId, UInt64 entityId)
{
// Send a global message to all connected Players (like shut down Server announce or something)
lock (Clients.SyncRoot)
{
foreach (string clientKey in Clients.Keys)
{
WorldClient client = Clients[clientKey] as WorldClient;
if (client.playerData.getCharID() != charId)
{
Output.Write("[ViewThread] Handle View For all Packet for charId : " + charId.ToString());
// Get or generate a View for the GoID
ClientView view = client.viewMan.getViewForEntityAndGo(entityId, goId);
DynamicArray content = new DynamicArray();
if (view.viewCreated == false)
{
Output.WriteDebugLog("Created View Id : " + view.ViewID.ToString());
// if view is new , add the viewId at the end (cause its creation)
// Remove the 03 01 00 (as it was generate previosly)
content.append(data);
content.append(NumericalUtils.uint16ToByteArray(view.ViewID, 1));
content.append(0x00); // View Zero
}
else
{
// Update View
content.append(NumericalUtils.uint16ToByteArray(view.ViewID, 1));
content.append(data);
content.append(0x00); // View Zero
Output.WriteDebugLog("Update View Id : " + view.ViewID.ToString());
}
if (view.viewNeedsToBeDeleted == true)
{
content.append(0x01);
content.append(0x00);
content.append(0x01); // Comand (Delete)
content.append(0x01); // NumViews (1 currently)
content.append(0x00);
content.append(NumericalUtils.uint16ToByteArray(view.ViewID, 1));
content.append(0x00);
}
// ToDo: handle viewId for packets (For creation it needs to be append to the end, for update at the start )
// ToDo: Complete this :)
client.messageQueue.addObjectMessage(content.getBytes(), false);
client.flushQueue();
Output.WriteLine("[World View Server] CharId: " + client.playerData.getCharID().ToString() + " )");
}
}
}
}
public void addCharacter(string charName, int charId, int status, int serverId)
{
byte[] charNameB = new byte[charName.Length + 3];
byte[] hexSize = NumericalUtils.uint16ToByteArray((UInt16)(charName.Length + 1), 1);
charNameB[0] = hexSize[0];
charNameB[1] = hexSize[1];
charNameB[charName.Length + 2] = 0x00;
for (int i = 0; i < charName.Length; i++)
{
charNameB[2 + i] = (byte)charName[i];
}
byte[] charDataB = new byte[14];
byte[] charIdB = NumericalUtils.uint32ToByteArray((UInt32)charId, 1);
charDataB[3] = charIdB[0];
charDataB[4] = charIdB[1];
charDataB[5] = charIdB[2];
charDataB[6] = charIdB[3];
charDataB[9] = 0x00;
charDataB[10] = (byte)status;
charDataB[11] = 0x00;
charDataB[12] = (byte)serverId;
numChars++; // Lets say we have done one ;)
int offset = 0;
// Use formula to calculate offset here
offset = 14 + (14 * (totalChars - numChars));
if (numChars == 1)
{
offset += 0;
}
else
{
offset += charNames.getSize();
}
// End of formula
byte[] offsetH = NumericalUtils.uint16ToByteArray((UInt16)offset, 1);
charDataB[1] = offsetH[0];
charDataB[2] = offsetH[1];
// After all calculations, append it to the dynamic arrays
charData.append(charDataB);
charNames.append(charNameB);
}
public void processSelfUpdateHealth(UInt16 viewId, UInt16 healthC)
{
// ToDo: proove to remove
DynamicArray din = new DynamicArray();
din.append(0x03);
din.append(NumericalUtils.uint16ToByteArray(viewId, 1));
din.append(0x02);
din.append(0x80);
din.append(0x80);
din.append(0x80);
din.append(0x40);
din.append(NumericalUtils.uint16ToByteArray(healthC, 1));
din.append(0x00);
}
public byte[] loadKnownAbilities()
{
DynamicArray din = new DynamicArray();
foreach (MarginAbilityItem ability in Abilities)
{
Int32 finalAblityID = ability.getAbilityID() + ability.getLevel();
string debugAbility = StringUtils.bytesToString(NumericalUtils.int32ToByteArray(finalAblityID, 1));
din.append(NumericalUtils.uint16ToByteArray(ability.getSlot(), 1)); // slot
din.append(NumericalUtils.int32ToByteArray(finalAblityID, 1));
}
return(din.getBytes());
}
public void processSelfUpdateHealth(UInt16 viewId, UInt16 healthC)
{
DynamicArray din = new DynamicArray();
din.append(0x03);
din.append(NumericalUtils.uint16ToByteArray(viewId, 1));
din.append(0x02);
din.append(0x80);
din.append(0x80);
din.append(0x80);
din.append(0x40);
din.append(NumericalUtils.uint16ToByteArray(healthC, 1));
din.append(0x00);
// ToDO SEND PAK and get real health
}
public void sendChatMessage(WorldClient fromClient, string message, UInt32 charId, string handle, string scope)
{
byte typeByte;
switch (scope)
{
case "TEAM":
typeByte = 0x05;
break;
case "CREW":
typeByte = 0x02;
break;
case "FACTION":
typeByte = 0x03;
break;
case "AREA":
typeByte = 0x10;
break;
default:
typeByte = 0x07;
break;
}
UInt16 messageSize = (UInt16)(message.Length + 1);
byte[] messageSizeHex = NumericalUtils.uint16ToByteArray(messageSize, 1);
UInt32 offsetMessage = (uint)handle.Length + 35 + 2 + 2;
PacketContent pak = new PacketContent();
pak.addByte((byte)RPCResponseHeaders.SERVER_CHAT_MESSAGE_RESPONSE);
pak.addByte(typeByte);
pak.addUint32(charId, 0);
pak.addUint16(36, 0);
pak.addUint32(offsetMessage, 0);
pak.addHexBytes("000000000000000000000000000000000000000000000000");
pak.addSizedTerminatedString(handle);
pak.addSizedTerminatedString(message);
Store.world.sendRPCToAllOtherPlayers(Store.currentClient.playerData, pak.returnFinalPacket());
}
public byte[] loadEquippedAbilities()
{
DynamicArray din = new DynamicArray();
//AbilityItem abTemp = AbilityDB.Find(delegate(AbilityItem a) { return a.getAbilityID() == id; });
foreach (MarginAbilityItem ability in Abilities)
{
if (ability.getLoaded() == true)
{
Int32 finalAblityID = ability.getAbilityID() + ability.getLevel();
din.append(NumericalUtils.uint16ToByteArray(ability.getSlot(), 1)); // slot
din.append(NumericalUtils.int32ToByteArray(finalAblityID, 1));
}
}
return(din.getBytes());
}
public void processDecreaseCash(UInt16 amount, UInt16 type)
{
// send 02 04 01 00 16 01 0a 80 e4 ff 00 00 00 02 00 00 00;
byte[] header = { 0x80, 0xe4 };
long newCash = Store.currentClient.playerData.getInfo() - (long)amount;
Store.currentClient.playerData.setInfo(newCash);
Store.dbManager.WorldDbHandler.savePlayer(Store.currentClient);
DynamicArray din = new DynamicArray();
din.append(header);
din.append(NumericalUtils.uint32ToByteArray((UInt32)newCash, 1));
din.append(NumericalUtils.uint16ToByteArray(type, 1));
din.append(0x00);
din.append(0x00);
Store.currentClient.messageQueue.addRpcMessage(din.getBytes());
}
public static byte[] createSystemMessage(string message, WorldClient client)
{
byte[] messageBytes = StringUtils.stringToBytes(message + "\x00");
DynamicArray din = new DynamicArray();
UInt16 messageSize = (UInt16)(message.Length + 1);
byte[] messageSizeHex = NumericalUtils.uint16ToByteArray(messageSize, 1);
byte[] hexContents = StringUtils.hexStringToBytes("0700000000000000000024000000000000000000000000000000000000000000000000");
din.append((byte)RPCResponseHeaders.SERVER_CHAT_MESSAGE_RESPONSE);
din.append(hexContents);
din.append(messageSizeHex);
din.append(messageBytes);
return(din.getBytes());
}
/*
* Add a RPC Message with size byte automatically to the queue
*/
public void addRpcMessage(byte[] messageBlock)
{
byte[] rpcSizeByte;
if (messageBlock.Length > 127)
{
rpcSizeByte = NumericalUtils.uint16ToByteArray((UInt16)(messageBlock.Length + 0x8000), 0);
}
else
{
rpcSizeByte = NumericalUtils.uint16ToByteArrayShort((UInt16)messageBlock.Length);
}
DynamicArray content = new DynamicArray();
content.append(rpcSizeByte);
content.append(messageBlock);
SequencedMessage message = new SequencedMessage(content.getBytes());
RPCMessagesQueue.Add(message);
}
// Shows the Animation of a target Player
public void processFXfromPlayer(UInt16 viewID, byte[] animation)
{
Random rand = new Random();
ushort updateViewCounter = (ushort)rand.Next(3, 200);
byte[] updateCount = NumericalUtils.uint16ToByteArrayShort(updateViewCounter);
DynamicArray din = new DynamicArray();
din.append(NumericalUtils.uint16ToByteArray(viewID, 1));
din.append(0x00);
din.append(0x80);
din.append(0x80);
din.append(0x80);
din.append(0x0c);
din.append(animation); // uint32 anim ID
din.append(updateCount);
din.append(0x00);
din.append(0x00);
Store.currentClient.messageQueue.addObjectMessage(din.getBytes(), false);
}
public void addUint16(UInt16 value, int reversed)
{
packet.append(NumericalUtils.uint16ToByteArray(value, reversed));
}
public void parseCommand(string data)
{
Output.WriteLine("[Chat Command helper] Chat command is: '" + data + "'");
string[] commands = data.Split(' ');
string command = commands[0].ToLower();
try{
if (command.Equals("?fix") && commands.Length > 1)
{
int maxRPC = int.Parse(commands[1]);
for (int i = 0; i < maxRPC; i++)
{
Store.currentClient.playerData.setRPCCounter((UInt16)i);
Store.currentClient.messageQueue.addRpcMessage(PacketsUtils.createSystemMessage("Trying to fix! " + i, Store.currentClient));
}
}
if (command.Equals("?teleport") && commands.Length == 4)
{
// parse the coord parameters parameters as int
Store.currentClient.messageQueue.addObjectMessage(new PlayerHelper().teleport(int.Parse(commands[1]), int.Parse(commands[2]), int.Parse(commands[3])), false);
Store.currentClient.messageQueue.addRpcMessage(PacketsUtils.createSystemMessage("Teleported!", Store.currentClient));
}
if (command.Equals("?rsi") && commands.Length == 3)
{
//parse the rsi part and value
Store.currentClient.messageQueue.addObjectMessage(new PlayerHelper().changeRsi(commands[1], int.Parse(commands[2])), false);
Store.currentClient.messageQueue.addRpcMessage(PacketsUtils.createSystemMessage("Rsi changed!", Store.currentClient));
}
if (command.StartsWith("?message"))
{
Output.WriteLine("[COMMAND HELPER]MESSAGE RECEIVED");
byte[] theMessage = PacketsUtils.createSystemMessageWithoutRPC(commands[1]);
Store.world.sendRPCToAllPlayers(theMessage);
}
if (command.Equals("?playanim"))
{
string animId = commands[1];
if (animId.Length == 4)
{
ServerPackets pak = new ServerPackets();
pak.sendPlayerAnimation(Store.currentClient, animId);
}
}
if (command.StartsWith("?playfx"))
{
string fxHEDID = commands[1];
DynamicArray din = new DynamicArray();
byte[] animationId = StringUtils.hexStringToBytes(fxHEDID);
byte[] viewID = { 0x02, 0x00 };
Random rand = new Random();
ushort updateViewCounter = (ushort)rand.Next(3, 200);
byte[] updateCount = NumericalUtils.uint16ToByteArrayShort(updateViewCounter);
Output.WriteLine("Check if its really one byte or two : " + StringUtils.bytesToString(updateCount));
din.append(viewID);
din.append(0x02);
din.append(0x80);
din.append(0x80);
din.append(0x80);
din.append(0x90);
din.append(0xed);
din.append(0x00);
din.append(0x30);
din.append(animationId);
din.append(updateCount);
Store.currentClient.messageQueue.addObjectMessage(din.getBytes(), false);
}
if (command.Contains("?send"))
{
// Sends a packet from a file
string filename = "packet.txt";
TextReader tr = new StreamReader(filename);
string hexContent = tr.ReadToEnd();
hexContent = hexContent.Replace(" ", string.Empty);
hexContent = hexContent.Replace(" ", Environment.NewLine);
tr.Close();
if (hexContent.Length > 0)
{
Store.currentClient.messageQueue.addObjectMessage(StringUtils.hexStringToBytes(hexContent), false);
Output.writeToLogForConsole("[SENDPACK FROM FILE] Content : " + hexContent);
}
}
if (command.Contains("?combat"))
{
byte[] dummypak = new byte[4];
TestUnitHandler test = new TestUnitHandler();
test.testCloseCombat(ref dummypak);
}
if (command.Contains("?mob"))
{
UInt32[] rsiIDs = new UInt32[10];
rsiIDs[0] = 0xB7010058;
rsiIDs[1] = 0x89090058;
rsiIDs[2] = 0xB5010058;
rsiIDs[3] = 0x3A030008;
rsiIDs[4] = 0x32030008;
rsiIDs[5] = 0xD0010058;
rsiIDs[6] = 0xD4010058;
rsiIDs[7] = 0xB8040004; // Smith
rsiIDs[8] = 0x92010058; // Seraph
rsiIDs[9] = 0x56050004;
Random rand = new Random();
int index = rand.Next(0, 9);
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);
byte[] xPos = NumericalUtils.floatToByteArray((float)x, 1);
byte[] yPos = NumericalUtils.floatToByteArray((float)y, 1);
byte[] zPos = NumericalUtils.floatToByteArray((float)z, 1);
UInt64 currentEntityId = WorldSocket.entityIdCounter;
WorldSocket.entityIdCounter++;
uint rotation = 0;
npc theMob = new npc();
theMob.setEntityId(currentEntityId);
theMob.setDistrict(Convert.ToUInt16(data[0].ToString()));
theMob.setDistrictName(Store.currentClient.playerData.getDistrict());
theMob.setName("HD Protector");
theMob.setLevel(255);
theMob.setHealthM(UInt16.Parse(data[4].ToString()));
theMob.setHealthC(UInt16.Parse(data[5].ToString()));
theMob.setMobId((ushort)rsiIDs[index]);
theMob.setRsiHex(StringUtils.bytesToString_NS(NumericalUtils.uint32ToByteArray(rsiIDs[index], 1)));
theMob.setXPos(x);
theMob.setYPos(y);
theMob.setZPos(z);
theMob.xBase = x;
theMob.yBase = y;
theMob.zBase = z;
theMob.setRotation(rotation);
theMob.setIsDead(false);
theMob.setIsLootable(false);
WorldSocket.npcs.Add(theMob);
// we use this for a test to see if we can spawn mobs and how we can handle them
// We refactor this
}
if (command.Contains("?sendrpc"))
{
// sends a RPC Packet from a File
string filename = "rpcpacket.txt";
TextReader tr = new StreamReader(filename);
string hexContent = tr.ReadToEnd();
hexContent = hexContent.Replace(" ", string.Empty);
hexContent = hexContent.Replace(" ", Environment.NewLine);
Output.Write("SEND RPC COMMAND : CONTENT : " + hexContent);
tr.Close();
if (hexContent.Length > 0)
{
Store.currentClient.messageQueue.addRpcMessage(StringUtils.hexStringToBytes(hexContent));
Output.writeToLogForConsole("[SENDRPC FROM FILE] Content : " + hexContent);
}
}
if (command.Contains("?checkrpc"))
{
DynamicArray din = new DynamicArray();
din.append(StringUtils.hexStringToBytes("2E1000FF7D020024000000310000000000000000000000000000000000000000000000000B0053796E61707A65373737001D004F6E2079656168204920646F2072656D656D62657220796F75203A2900"));
Store.currentClient.messageQueue.addRpcMessage(din.getBytes());
}
if (command.Contains("?testrpc"))
{
UInt16 maxRPC = 33279;
// Just to reference
if (Store.currentClient.playerData.currentTestRPC <= maxRPC)
{
// Only if it is below we send it - we test with a 5 size packet
DynamicArray din = new DynamicArray();
if (Store.currentClient.playerData.currentTestRPC < 127)
{
din.append(NumericalUtils.uint16ToByteArrayShort(Store.currentClient.playerData.currentTestRPC));
}
else
{
din.append(NumericalUtils.uint16ToByteArray(Store.currentClient.playerData.currentTestRPC, 0));
}
din.append(0x00);
din.append(0x00);
din.append(0x00);
Store.currentClient.messageQueue.addRpcMessage(din.getBytes());
ServerPackets pak = new ServerPackets();
pak.sendSystemChatMessage(Store.currentClient, "Test RPC Header : " + Store.currentClient.playerData.currentTestRPC.ToString(), "MODAL");
Store.currentClient.playerData.currentTestRPC++;
}
}
if (command.Equals("?save"))
{
new PlayerHelper().savePlayerInfo(Store.currentClient);
ServerPackets pak = new ServerPackets();
pak.sendSaveCharDataMessage(Store.currentClient, StringUtils.charBytesToString_NZ(Store.currentClient.playerInstance.CharacterName.getValue()));
}
}
catch (Exception e) {
Store.currentClient.messageQueue.addRpcMessage(PacketsUtils.createSystemMessage("Error parsing command!", Store.currentClient));
Output.WriteLine("[CHAT COMMAND PARSER] Error parsing request: " + data);
Output.WriteLine("[CHAT COMMAND PARSER] DEBUG: " + e.Message + "\n" + e.StackTrace);
}
}
public byte[] encrypt(byte[] packet)
{
// Get timestamp
byte[] timestamp = TimeUtils.getUnixTime();
// get size
int psize = packet.Length;
byte[] size = NumericalUtils.uint16ToByteArray((UInt16)psize, 1);
//showPacket(size, " Size ");
// final Packet
DynamicArray temp = new DynamicArray();
temp.append(size);
temp.append(timestamp);
temp.append(packet);
// compute CRC32
byte[] crc32pax = crc32.checksumB(temp.getBytes(), 1);
// Padding
int totalLength = temp.getSize() + 4;
int padding = 16 - (totalLength % 16);
byte[] paddingBytes = new byte[padding];
for (int i = 0; i < padding; i++)
{
paddingBytes[i] = (byte)padding;
}
temp.append(paddingBytes);
tf.setIV(IV);
tf.setKey(TF_Key);
// We init with 2 more than needed, so no memory reservation is done on dyn array
DynamicArray finalPlainData = new DynamicArray();
finalPlainData.append(crc32pax);
finalPlainData.append(temp.getBytes());
temp = null; // Cleaning the house
byte[] encryptedData = new byte[finalPlainData.getSize()];
tf.encrypt(finalPlainData.getBytes(), encryptedData);
finalPlainData = null; // Cleaning the house (2)
// add IV before the results
DynamicArray response = new DynamicArray();
response.append(IV);
response.append(encryptedData);
// Display HEX Values after Encryption
return(response.getBytes());
}
public byte[] GetGoid()
{
return(NumericalUtils.uint16ToByteArray(goid, 1));
}
public static byte[] createMessage(string message, string type, WorldClient client)
{
byte typeByte;
switch (type)
{
case "TEAM":
typeByte = 0x05;
break;
case "CREW":
typeByte = 0x02;
break;
case "FACTION":
typeByte = 0x03;
break;
case "SYSTEM":
typeByte = 0x07;
break;
case "MODAL":
typeByte = 0x17;
break;
case "FRAMEMODAL":
typeByte = 0xd7;
break;
case "BROADCAST":
typeByte = 0xc7;
break;
case "AREA":
typeByte = 0x10;
break;
default:
typeByte = 0x07;
break;
}
byte[] messageBytes = StringUtils.stringToBytes(message + "\x00");
DynamicArray din = new DynamicArray();
UInt16 messageSize = (UInt16)(message.Length + 1);
byte[] messageSizeHex = NumericalUtils.uint16ToByteArray(messageSize, 1);
byte[] hexContents = StringUtils.hexStringToBytes("00000000000000000024000000000000000000000000000000000000000000000000");
din.append((byte)RPCResponseHeaders.SERVER_CHAT_MESSAGE_RESPONSE); // Response header
din.append(typeByte);
din.append(hexContents);
din.append(messageSizeHex);
din.append(messageBytes);
return(din.getBytes());
}
public void certConnectRequest(byte[] packet, NetworkStream client)
{
int firstnum = BitConverter.ToInt16(packet, 3);
int authstart = BitConverter.ToInt16(packet, 5);
if (firstnum != 3)
{
//showMarginDebug("FirstNum is not 3, it is" + firstnum);
}
if (authstart != 310)
{
//showMarginDebug("AuthStart is not 0x3601");
}
// Get the Signature
byte[] signature = new byte[128];
ArrayUtils.copy(packet, 7, signature, 0, 128);
// TODO MD5 Signature and verify it with RSA to check if everything is correct
// Get the signedData
byte[] signedData = new byte[packet.Length - 135];
ArrayUtils.copy(packet, 135, signedData, 0, packet.Length - 135);
int userid = BitConverter.ToInt32(signedData, 1);
this.userID = (UInt32)userid;
// Stripout Exponent and Modulus
byte[] exponent = { 0x00, 0x00, 0x00, 0x11 };
byte[] modulus = new byte[96];
ArrayUtils.copy(signedData, 82, modulus, 0, 96);
// Init our encryptor with users modulus and exponent
marginEncr.setUserPubKey(exponent, modulus);
// build the final packet, it consists of 1 byte 0x00 + twofish key for world and margin + encryptIV
byte[] encryptMeResponse = new byte[33];
encryptMeResponse[0] = 0x00;
ArrayUtils.copy(marginEncr.getTFKey(), 0, encryptMeResponse, 1, 16);
ArrayUtils.copy(marginEncr.getIV(), 0, encryptMeResponse, 17, 16);
byte[] encryptedShit = { };
encryptedShit = marginEncr.encryptUsersPublic(encryptMeResponse);
byte[] blobSize = NumericalUtils.uint16ToByteArray((UInt16)encryptedShit.Length, 1);
byte[] header = { 0x02, 0x03, 0x00 };
// Write final packet
DynamicArray din = new DynamicArray();
din.append(header);
din.append(blobSize);
din.append(encryptedShit);
sendTCPVariableLenPacket(din.getBytes(), client);
}
private void sendMarginCharData(byte[] data, byte opcode, NetworkStream client)
{
// This Method will be used to send the real Data to the client
// Format for general LoadCharacterReply Responses:
// 10 00 00 00 <- everytime the same
// 00 f9 76 04 <- uint32 Char ID
// 00 00 00 09 <- uint32 number of Character Replys (just raise one up)
// 00 05 <- viewData opcode (what data is inside) uint16
// 10 00 <- if it has Data it is 10 00 if not is just 00 00 (and no Data can follow up and packet ends here)
// e1 00 <- short / uint16 data size
// DATA
byte[] header = { 0x10, 0x00, 0x00, 0x00 };
// Raise one up
loadCharCounter++;
// Add the counter
byte[] counterByte = new byte[4];
counterByte = NumericalUtils.uint32ToByteArray(loadCharCounter, 1);
// get the datasize for the packet
byte[] dataSize = NumericalUtils.uint16ToByteArray((UInt16)data.Length, 1);
// charId
byte[] charID = NumericalUtils.uint32ToByteArray(this.newCharID, 0);
// viewData code
byte[] responseCode = { 0x00, opcode };
string pakData = StringUtils.bytesToString_NS(header) +
StringUtils.bytesToString_NS(charID) +
StringUtils.bytesToString_NS(counterByte) +
StringUtils.bytesToString_NS(responseCode);
string hasData;
// this needs improvement...
if (data.Length == 0 && opcode == 0x01)
{
hasData = "0000";
}
else
{
hasData = "1000" + StringUtils.bytesToString_NS(dataSize) + StringUtils.bytesToString_NS(data);
}
pakData += hasData;
PacketContent pak = new PacketContent();
// Dump the Packet Data to see whats in
//Console.WriteLine("Response Load Pak : " + pakData);
// Do the viewData
byte[] response = StringUtils.hexStringToBytes(pakData);
Output.WritePacketLog(StringUtils.bytesToString(response), "MARGINSERVER", "0", "0", "0");
Output.WriteDebugLog("[MARGIN SERVER RESPONSE] for OPCODE " + opcode + " : " + StringUtils.bytesToString(response));
byte[] encryptedResponse = marginEncr.encrypt(response);
sendTCPVariableLenPacket(encryptedResponse, client);
System.Threading.Thread.Sleep(50);
}
public void addSizedString(string value)
{
packet.append(NumericalUtils.uint16ToByteArray((UInt16)value.Length, 1));
packet.append(StringUtils.stringToBytes(value));
}
public void setValue(UInt16 newValue)
{
byte[] t = NumericalUtils.uint16ToByteArray(newValue, 1);
setValue(t);
}
public void processOpenDoor(StaticWorldObject door)
{
UInt16 typeId = NumericalUtils.ByteArrayToUint16(door.type, 1);
byte[] masterViewId = { 0x01, 0x00 };
byte[] seperator = { 0xcd, 0xab };
Store.currentClient.playerData.newViewIdCounter++; // It is just for a test Later we will change this to have a List with Views and Object IDs
byte[] disarmDifficultyMaybe = { 0x03, 0x84 };
byte[] endViewID = { 0x00, 0x00 };
byte[] spawnCounter = NumericalUtils.uint16ToByteArrayShort(Store.currentClient.playerData.assignSpawnIdCounter());
Output.WriteLine("[DOOR]POS X : " + door.pos_x.ToString() + " POS Y: " + door.pos_y.ToString() + " POS Z: " + door.pos_z.ToString() + ", TypeId: " + StringUtils.bytesToString_NS(door.type));
switch (typeId)
{
case 417:
case 419:
// ToDo: Packet Format for Elevator
// 02 03 01 00
// 08
// a3 01
// 6b 01 f0 3d be
// cd ab 03 88 00 00 00 00 ff ff 7f 3f 00 00 00 00 f3 04 35 33
// 22 00 00 00 00 40 f4 fb 40 00 00 00 00 00 90 75 40 00 00 00 00 00 40 af 40 ff ff ff ff 19 00 00
// 11 00 01 00 04 61 97 e1 47 f0 bf 2d 44 de 30 35 45 00 00
PacketContent content = new PacketContent();
content.addByteArray(masterViewId);
content.addByte(0x08);
content.addByteArray(door.type);
content.addByteArray(NumericalUtils.uint32ToByteArray(door.mxoId, 1));
content.addByteArray(spawnCounter); // Spawn Object Counter
content.addByteArray(seperator);
content.addByte(0x03); // Number of Attributes to parse (3)
content.addByte(0x88); // GROUP 1 - more groups ON, Attribute 4 (305,Orientation,LTQuaternion,16) SET (10001000)
content.addByteArray(StringUtils.hexStringToBytes(door.quat)); // ToDo: replace it later with the real LTQuaternion
content.addByte(0x22); // GROUP 2 - more groups OFF, Attribute 2,6 SET (00100010)
content.addDoubleLtVector3d(door.pos_x, door.pos_y, door.pos_z);
content.addByteArray(new byte[] { 0xff, 0xff, 0xff, 0xff });
content.addByteArray(NumericalUtils.uint16ToByteArray(Store.currentClient.playerData.newViewIdCounter, 1));
content.addByteArray(endViewID);
content.addByte(0x00);
Store.currentClient.messageQueue.addObjectMessage(content.returnFinalPacket(), false);
break;
case 2506:
// ToDo: Packet Format for Elevator
break;
default:
PacketContent contentDefault = new PacketContent();
contentDefault.addByteArray(masterViewId);
contentDefault.addByte(0x08);
contentDefault.addByteArray(door.type);
contentDefault.addByteArray(NumericalUtils.uint32ToByteArray(door.mxoId, 1));
contentDefault.addByteArray(spawnCounter); // Spawn Object Counter
contentDefault.addByteArray(seperator);
contentDefault.addByteArray(disarmDifficultyMaybe);
contentDefault.addByte(0x00); // isZionAligned?
contentDefault.addByteArray(StringUtils.hexStringToBytes("0000000000803F000000000000000041")); // ToDo: replace it later with the real values from the object
contentDefault.addDoubleLtVector3d(door.pos_x, door.pos_y, door.pos_z);
contentDefault.addByteArray(StringUtils.hexStringToBytes("34080000"));
contentDefault.addByteArray(NumericalUtils.uint16ToByteArray(Store.currentClient.playerData.newViewIdCounter, 1));
contentDefault.addByteArray(endViewID);
contentDefault.addByte(0x00);
Store.currentClient.messageQueue.addObjectMessage(contentDefault.returnFinalPacket(), false);
break;
}
}
