API tools faq
paste
Advertisement
Waterfiend

727 Data

Waterfiend
Mar 6th, 2015
223
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 58.74 KB | None | 0 0
raw download clone embed print report
  1.         /*   Credits to Sir Tom   */
  2.         public void sendPlayerUnderNPCPriority(boolean priority) {
  3.                 OutputStream stream = new OutputStream(2);
  4.                 stream.writePacket(player, 151);
  5.                 stream.writeByteC(priority ? 1 : 0);
  6.                 session.write(stream);
  7.         }
  8.  
  9.         public void sendHintIcon(HintIcon icon) {
  10.                 OutputStream stream = new OutputStream(15);
  11.                 stream.writePacket(player, 79);
  12.                 stream.writeByte((icon.getTargetType() & 0x1f) | (icon.getIndex() << 5));
  13.                 if (icon.getTargetType() == 0)
  14.                         stream.skip(13);
  15.                 else {
  16.                         stream.writeByte(icon.getArrowType());
  17.                         if (icon.getTargetType() == 1 || icon.getTargetType() == 10) {
  18.                                 stream.writeShort(icon.getTargetIndex());
  19.                                 stream.writeShort(2500);
  20.                                 stream.skip(4);
  21.                         } else if ((icon.getTargetType() >= 2 && icon.getTargetType() <= 6)) { // directions
  22.                                 stream.writeByte(icon.getPlane()); // unknown
  23.                                 stream.writeShort(icon.getCoordX());
  24.                                 stream.writeShort(icon.getCoordY());
  25.                                 stream.writeByte(icon.getDistanceFromFloor() * 4 >> 2);
  26.                                 stream.writeShort(-1);
  27.                         }
  28.                         stream.writeInt(icon.getModelId());
  29.                 }
  30.                 session.write(stream);
  31.         }
  32.  
  33.         public void sendCameraShake(int slotId, int b, int c, int d, int e) {
  34.                 OutputStream stream = new OutputStream(7);
  35.                 stream.writePacket(player, 71);
  36.                 stream.write128Byte(b);
  37.                 stream.writeShort(d);
  38.                 stream.writeByteC(slotId);
  39.                 stream.writeByteC(c);
  40.                 stream.write128Byte(e);
  41.                 session.write(stream);
  42.         }
  43.  
  44.         public void sendStopCameraShake() {
  45.                 OutputStream stream = new OutputStream(1);
  46.                 stream.writePacket(player, 89);
  47.                 session.write(stream);
  48.         }
  49.  
  50.         public void sendIComponentModel(int interfaceId, int componentId, int modelId) {
  51.                 OutputStream stream = new OutputStream(9);
  52.                 stream.writePacket(player, 135);
  53.                 stream.writeInt(interfaceId << 16 | componentId);
  54.                 stream.writeIntV2(modelId);
  55.                 session.write(stream);
  56.         }
  57.  
  58.         public void sendHideIComponent(int interfaceId, int componentId, boolean hidden) {
  59.                 OutputStream stream = new OutputStream(6);
  60.                 stream.writePacket(player, 33);
  61.                 stream.writeByte128(hidden ? 1 : 0);
  62.                 stream.writeInt(interfaceId << 16 | componentId);
  63.                 session.write(stream);
  64.         }
  65.  
  66.         public void sendRemoveGroundItem(FloorItem item) {
  67.                 OutputStream stream = createWorldTileStream(item.getTile());
  68.                 int localX = item.getTile().getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  69.                 int localY = item.getTile().getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  70.                 int offsetX = localX - ((localX >> 3) << 3);
  71.                 int offsetY = localY - ((localY >> 3) << 3);
  72.                 stream.writePacket(player, 125);
  73.                 stream.writeByteC((offsetX << 4) | offsetY);
  74.                 stream.writeShortLE128(item.getId());
  75.                 session.write(stream);
  76.         }
  77.  
  78.         public void sendGroundItem(FloorItem item) {
  79.                 OutputStream stream = createWorldTileStream(item.getTile());
  80.                 int localX = item.getTile().getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  81.                 int localY = item.getTile().getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  82.                 int offsetX = localX - ((localX >> 3) << 3);
  83.                 int offsetY = localY - ((localY >> 3) << 3);
  84.                 stream.writePacket(player, 27);
  85.                 stream.writeShortLE128(item.getAmount());
  86.                 stream.writeShort128(item.getId());
  87.                 stream.writeByteC((offsetX << 4) | offsetY);
  88.                 session.write(stream);
  89.         }
  90.  
  91.         public void sendProjectile(Entity receiver, WorldTile startTile, WorldTile endTile, int gfxId, int startHeight, int endHeight, int speed, int delay, int curve, int startDistanceOffset, int creatorSize) {
  92.                 OutputStream stream = createWorldTileStream(startTile);
  93.                 stream.writePacket(player, 143);
  94.                 int localX = startTile.getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  95.                 int localY = startTile.getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  96.                 int offsetX = localX - ((localX >> 3) << 3);
  97.                 int offsetY = localY - ((localY >> 3) << 3);
  98.                 stream.writeByte((offsetX << 3) | offsetY);
  99.                 stream.writeByte(endTile.getX() - startTile.getX());
  100.                 stream.writeByte(endTile.getY() - startTile.getY());
  101.                 stream.writeShort(receiver == null ? 0 : (receiver instanceof Player ? -(receiver.getIndex() + 1) : receiver.getIndex() + 1));
  102.                 stream.writeShort(gfxId);
  103.                 stream.writeByte(startHeight);
  104.                 stream.writeByte(endHeight);
  105.                 stream.writeShort(delay);
  106.                 int duration = (Utils.getDistance(startTile.getX(), startTile.getY(), endTile.getX(), endTile.getY()) * 30 / ((speed / 10) < 1 ? 1 : (speed / 10))) + delay;
  107.                 stream.writeShort(duration);
  108.                 stream.writeByte(curve);
  109.                 stream.writeShort(creatorSize * 64 + startDistanceOffset * 64);
  110.                 session.write(stream);
  111.  
  112.         }
  113.  
  114.         public void sendUnlockIComponentOptionSlots(int interfaceId, int componentId, int fromSlot, int toSlot, int... optionsSlots) {
  115.                 int settingsHash = 0;
  116.                 for (int slot : optionsSlots)
  117.                         settingsHash |= 2 << slot;
  118.                 sendIComponentSettings(interfaceId, componentId, fromSlot, toSlot, settingsHash);
  119.         }
  120.  
  121.         public void sendIComponentSettings(int interfaceId, int componentId, int fromSlot, int toSlot, int settingsHash) {
  122.                 OutputStream stream = new OutputStream(13);
  123.                 stream.writePacket(player, 121);
  124.                 stream.writeShortLE128(toSlot);
  125.                 stream.writeIntV2(interfaceId << 16 | componentId);
  126.                 stream.writeShort(fromSlot);
  127.                 stream.writeIntLE(settingsHash);
  128.                 session.write(stream);
  129.         }
  130.  
  131.         public void sendInterFlashScript(int interfaceId, int componentId, int width, int height, int slot) {
  132.                 Object[] parameters = new Object[4];
  133.                 int index = 0;
  134.                 parameters[index++] = slot;
  135.                 parameters[index++] = height;
  136.                 parameters[index++] = width;
  137.                 parameters[index++] = interfaceId << 16 | componentId;
  138.                 sendRunScript(143, parameters);
  139.         }
  140.  
  141.         public void sendInterSetItemsOptionsScript(int interfaceId, int componentId, int key, int width, int height, String... options) {
  142.                 sendInterSetItemsOptionsScript(interfaceId, componentId, key, false, width, height, options);
  143.         }
  144.  
  145.         public void sendInterSetItemsOptionsScript(int interfaceId, int componentId, int key, boolean negativeKey, int width, int height, String... options) {
  146.                 Object[] parameters = new Object[6 + options.length];
  147.                 int index = 0;
  148.                 for (int count = options.length - 1; count >= 0; count--)
  149.                         parameters[index++] = options[count];
  150.                 parameters[index++] = -1;
  151.                 parameters[index++] = 0;
  152.                 parameters[index++] = height;
  153.                 parameters[index++] = width;
  154.                 parameters[index++] = key;
  155.                 parameters[index++] = interfaceId << 16 | componentId;
  156.                 sendRunScript(negativeKey ? 695 : 150, parameters);
  157.         }
  158.  
  159.         public void sendInputNameScript(String message) {
  160.                 sendRunScript(109, new Object[] { message });
  161.         }
  162.  
  163.         public void sendInputIntegerScript(String message) {
  164.                 sendRunScript(108, new Object[] { message });
  165.         }
  166.  
  167.         public void sendInputLongTextScript(String message) {
  168.                 sendRunScript(110, new Object[] { message });
  169.         }
  170.  
  171.         public void sendRunScript(int scriptId, Object... params) {
  172.                 OutputStream stream = new OutputStream();
  173.                 stream.writePacketVarShort(player, 99);
  174.                 String parameterTypes = "";
  175.                 if (params != null) {
  176.                         for (int count = params.length - 1; count >= 0; count--) {
  177.                                 if (params[count] instanceof String)
  178.                                         parameterTypes += "s"; // string
  179.                                 else
  180.                                         parameterTypes += "i"; // integer
  181.                         }
  182.                 }
  183.                 stream.writeString(parameterTypes);
  184.                 if (params != null) {
  185.                         int index = 0;
  186.                         for (int count = parameterTypes.length() - 1; count >= 0; count--) {
  187.                                 if (parameterTypes.charAt(count) == 's')
  188.                                         stream.writeString((String) params[index++]);
  189.                                 else
  190.                                         stream.writeInt((Integer) params[index++]);
  191.                         }
  192.                 }
  193.                 stream.writeInt(scriptId);
  194.                 stream.endPacketVarShort();
  195.                 session.write(stream);
  196.         }
  197.  
  198.         public void sendGlobalConfig(int id, int value) {
  199.                 if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE)
  200.                         sendGlobalConfig2(id, value);
  201.                 else
  202.                         sendGlobalConfig1(id, value);
  203.         }
  204.  
  205.         public void sendGlobalConfig1(int id, int value) {
  206.                 OutputStream stream = new OutputStream(4);
  207.                 stream.writePacket(player, 116);
  208.                 stream.write128Byte(value);
  209.                 stream.writeShortLE(id);
  210.                 session.write(stream);
  211.         }
  212.  
  213.         public void sendGlobalConfig2(int id, int value) {
  214.                 OutputStream stream = new OutputStream(7);
  215.                 stream.writePacket(player, 12);
  216.                 stream.writeShortLE(id);
  217.                 stream.writeIntV2(value);
  218.                 session.write(stream);
  219.         }
  220.  
  221.         public void sendConfig(int id, int value) {
  222.                 if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE)
  223.                         sendConfig2(id, value);
  224.                 else
  225.                         sendConfig1(id, value);
  226.         }
  227.  
  228.         public void sendConfigByFile(int fileId, int value) {
  229.                 if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE)
  230.                         sendConfigByFile2(fileId, value);
  231.                 else
  232.                         sendConfigByFile1(fileId, value);
  233.         }
  234.  
  235.         public void sendConfig1(int id, int value) {
  236.                 OutputStream stream = new OutputStream(4);
  237.                 stream.writePacket(player, 115);
  238.                 stream.writeByte(value);
  239.                 stream.writeShortLE128(id);
  240.                 session.write(stream);
  241.         }
  242.  
  243.         public void sendConfig2(int id, int value) {
  244.                 OutputStream stream = new OutputStream(7);
  245.                 stream.writePacket(player, 8);
  246.                 stream.writeIntV2(value);
  247.                 stream.writeShortLE128(id);
  248.                 session.write(stream);
  249.         }
  250.  
  251.         public void sendConfigByFile1(int fileId, int value) {
  252.                 OutputStream stream = new OutputStream(4);
  253.                 stream.writePacket(player, 68);
  254.                 stream.writeShort(fileId);
  255.                 stream.writeByte128(value);
  256.                 session.write(stream);
  257.         }
  258.  
  259.         public void sendConfigByFile2(int fileId, int value) {
  260.                 OutputStream stream = new OutputStream(7);
  261.                 stream.writePacket(player, 108);
  262.                 stream.writeIntV2(value);
  263.                 stream.writeShort128(fileId);
  264.                 session.write(stream);
  265.         }
  266.  
  267.         public void sendRunEnergy() {
  268.                 OutputStream stream = new OutputStream(2);
  269.                 stream.writePacket(player, 64);
  270.                 stream.writeByte(player.getRunEnergy());
  271.                 session.write(stream);
  272.         }
  273.  
  274.         public void sendIComponentText(int interfaceId, int componentId, String text) {
  275.                 OutputStream stream = new OutputStream();
  276.                 stream.writePacketVarShort(player, 124);
  277.                 stream.writeString(text);
  278.                 stream.writeIntV1(interfaceId << 16 | componentId);
  279.                 stream.endPacketVarShort();
  280.                 session.write(stream);
  281.         }
  282.  
  283.         public void sendIComponentAnimation(int emoteId, int interfaceId, int componentId) {
  284.                 OutputStream stream = new OutputStream(9);
  285.                 stream.writePacket(player, 82);
  286.                 stream.writeIntV2(emoteId);
  287.                 stream.writeInt(interfaceId << 16 | componentId);
  288.                 session.write(stream);
  289.         }
  290.  
  291.         public void sendItemOnIComponent(int interfaceid, int componentId, int id, int amount) {
  292.                 OutputStream stream = new OutputStream(11);
  293.                 stream.writePacket(player, 112);
  294.                 stream.writeShort(id);
  295.                 stream.writeInt(interfaceid << 16 | componentId);
  296.                 stream.writeIntV2(amount);
  297.                 session.write(stream);
  298.         }
  299.  
  300.         public void sendEntityOnIComponent(boolean isPlayer, int entityId, int interfaceId, int componentId) {
  301.                 if (isPlayer)
  302.                         sendPlayerOnIComponent(interfaceId, componentId);
  303.                 else
  304.                         sendNPCOnIComponent(interfaceId, componentId, entityId);
  305.         }
  306.  
  307.         public void sendWorldTile(WorldTile tile) {
  308.                 session.write(createWorldTileStream(tile));
  309.         }
  310.  
  311.         public OutputStream createWorldTileStream(WorldTile tile) {
  312.                 OutputStream stream = new OutputStream(4);
  313.                 stream.writePacket(player, 41);
  314.                 stream.writeByte128(tile.getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize()) >> 3);
  315.                 stream.writeByte128(tile.getPlane());
  316.                 stream.writeByte128(tile.getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize()) >> 3);
  317.                 return stream;
  318.         }
  319.  
  320.         public void sendObjectAnimation(WorldObject object, Animation animation) {
  321.                 OutputStream stream = new OutputStream(10);
  322.                 stream.writePacket(player, 80);
  323.                 stream.writeIntV2(object.getTileHash());
  324.                 stream.writeIntLE(animation.getIds()[0]);
  325.                 stream.write128Byte((object.getType() << 2) + (object.getRotation() & 0x3));
  326.                 session.write(stream);
  327.         }
  328.  
  329.         public void sendTileMessage(String message, WorldTile tile, int color) {
  330.                 sendTileMessage(message, tile, 5000, 255, color);
  331.         }
  332.  
  333.         public void sendTileMessage(String message, WorldTile tile, int delay, int height, int color) {
  334.                 OutputStream stream = createWorldTileStream(tile);
  335.                 stream.writePacketVarByte(player, 114);
  336.                 stream.skip(1);
  337.                 int localX = tile.getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  338.                 int localY = tile.getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  339.                 int offsetX = localX - ((localX >> 3) << 3);
  340.                 int offsetY = localY - ((localY >> 3) << 3);
  341.                 stream.writeByte((offsetX << 4) | offsetY);
  342.                 stream.writeShort(delay / 30);
  343.                 stream.writeByte(height);
  344.                 stream.write24BitInteger(color);
  345.                 stream.writeString(message);
  346.                 stream.endPacketVarByte();
  347.                 session.write(stream);
  348.         }
  349.  
  350.         public void sendSpawnedObject(WorldObject object) {
  351.                 OutputStream stream = createWorldTileStream(object);
  352.                 int localX = object.getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  353.                 int localY = object.getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  354.                 int offsetX = localX - ((localX >> 3) << 3);
  355.                 int offsetY = localY - ((localY >> 3) << 3);
  356.                 stream.writePacket(player, 117);
  357.                 stream.writeInt(object.getId());
  358.                 stream.write128Byte((offsetX << 4) | offsetY);
  359.                 stream.write128Byte((object.getType() << 2) + (object.getRotation() & 0x3));
  360.                 session.write(stream);
  361.         }
  362.  
  363.         public void sendDestroyObject(WorldObject object) {
  364.                 OutputStream stream = createWorldTileStream(object);
  365.                 int localX = object.getLocalX(player.getLastLoadedMapRegionTile(), player.getMapSize());
  366.                 int localY = object.getLocalY(player.getLastLoadedMapRegionTile(), player.getMapSize());
  367.                 int offsetX = localX - ((localX >> 3) << 3);
  368.                 int offsetY = localY - ((localY >> 3) << 3);
  369.                 stream.writePacket(player, 69);
  370.                 stream.writeByte128((object.getType() << 2) + (object.getRotation() & 0x3));
  371.                 stream.writeByte((offsetX << 4) | offsetY);
  372.                 session.write(stream);
  373.         }
  374.  
  375.         public void sendPlayerOnIComponent(int interfaceId, int componentId) {
  376.                 OutputStream stream = new OutputStream(5);
  377.                 stream.writePacket(player, 0);
  378.                 stream.writeIntLE(interfaceId << 16 | componentId);
  379.                 session.write(stream);
  380.  
  381.         }
  382.  
  383.         public void sendNPCOnIComponent(int interfaceId, int componentId, int npcId) {
  384.                 OutputStream stream = new OutputStream(9);
  385.                 stream.writePacket(player, 109);
  386.                 stream.writeIntLE(interfaceId << 16 | componentId);
  387.                 stream.writeIntV1(npcId);
  388.                 session.write(stream);
  389.  
  390.         }
  391.  
  392.         public void sendFriendsChatChannel() {
  393.                 FriendChatsManager manager = player.getCurrentFriendChat();
  394.                 OutputStream stream = new OutputStream(manager == null ? 3 : manager.getDataBlock().length + 3);
  395.                 stream.writePacketVarShort(player, 127);
  396.                 if (manager != null)
  397.                         stream.writeBytes(manager.getDataBlock());
  398.                 stream.endPacketVarShort();
  399.                 session.write(stream);
  400.         }
  401.  
  402.         public void sendFriends() {
  403.                 OutputStream stream = new OutputStream();
  404.                 stream.writePacketVarShort(player, 74);
  405.                 for (String username : player.getFriendsIgnores().getFriends()) {
  406.                         String displayName;
  407.                         Player p2 = World.getPlayerByDisplayName(username);
  408.                         if (p2 != null)
  409.                                 displayName = p2.getDisplayName();
  410.                         else
  411.                                 displayName = Utils.formatPlayerNameForDisplay(username);
  412.                         player.getPackets().sendFriend(Utils.formatPlayerNameForDisplay(username), displayName, 177, p2 != null && player.getFriendsIgnores().canSee(p2), false, stream);
  413.                 }
  414.                 stream.endPacketVarShort();
  415.                 session.write(stream);
  416.         }
  417.  
  418.         public void sendFriend(String username, String displayName, int world, boolean putOnline, boolean warnMessage) {
  419.                 Player friend = World.getPlayerByDisplayName(username);
  420.                 if (friend == null)
  421.                         friend = SerializableFilesManager.loadPlayer(username);
  422.                
  423.                 if (friend == null) {
  424.                         System.out.println("" + username + " was null in sendFriend.");
  425.                         return;
  426.                 }
  427.                
  428.                 putOnline = putOnline & player.getFriendsIgnores().canSee(friend);
  429.  
  430.                 OutputStream stream = new OutputStream();
  431.                 stream.writePacketVarShort(player, 74);
  432.                 sendFriend(username, displayName, world, putOnline, warnMessage, stream);
  433.                 stream.endPacketVarShort();
  434.                 session.write(stream);
  435.         }
  436.  
  437.         public void sendFriend(String username, String displayName, int world, boolean putOnline, boolean warnMessage, OutputStream stream) {
  438.                 stream.writeByte(warnMessage ? 0 : 1);
  439.                 stream.writeString(displayName);
  440.                 stream.writeString(displayName.equals(username) ? "" : username);
  441.                 stream.writeShort(putOnline ? world : 0);
  442.                 stream.writeByte(player.getFriendsIgnores().getRank(Utils.formatPlayerNameForProtocol(username)));
  443.                 stream.writeByte(0);// 1 = recruit a friend highlight
  444.                 if (putOnline) {
  445.                         stream.writeString(Settings.SERVER_NAME);
  446.                         stream.writeByte(world == 1118 ? 1 : 0);
  447.                         stream.writeInt(0);
  448.                 }
  449.         }
  450.  
  451.         public void sendIgnores() {
  452.                 OutputStream stream = new OutputStream();
  453.                 stream.writePacketVarShort(player, 97);
  454.                 stream.writeByte(player.getFriendsIgnores().getIgnores().size());
  455.                 for (String username : player.getFriendsIgnores().getIgnores()) {
  456.                         String display;
  457.                         Player p2 = World.getPlayerByDisplayName(username);
  458.                         if (username != null) {
  459.                                 if (p2 != null)
  460.                                         display = p2.getDisplayName();
  461.                                 else
  462.                                         display = Utils.formatPlayerNameForDisplay(username);
  463.                                 String name = Utils.formatPlayerNameForDisplay(username);
  464.  
  465.                                 stream.writeString(display.equals(name) ? name : display);
  466.                                 stream.writeString(display.equals(name) ? "" : name);
  467.                         }
  468.                 }
  469.                 stream.endPacketVarShort();
  470.                 session.write(stream);
  471.         }
  472.  
  473.         public void sendIgnore(String name, String display, boolean updateName) {
  474.                 OutputStream stream = new OutputStream();
  475.                 stream.writePacketVarByte(player, 138);
  476.                 if (name != null) {
  477.                         stream.writeByte(0x2);
  478.                         stream.writeString(display.equals(name) ? name : display);
  479.                         stream.writeString(display.equals(name) ? "" : name);
  480.                         stream.endPacketVarByte();
  481.                 }
  482.                 session.write(stream);
  483.         }
  484.  
  485.         public void sendPrivateMessage(String username, String message) {
  486.                 Player p2 = World.getPlayerByDisplayName(username);
  487.                 if (!player.getFriendsIgnores().canSee(p2)) {
  488.                         player.sendMessage("This player has their privacy mode disabled or is offline.");
  489.                         return;
  490.                 }
  491.  
  492.                 OutputStream stream = new OutputStream();
  493.                 stream.writePacketVarShort(player, 92);
  494.                 stream.writeString(username);
  495.                 Huffman.sendEncryptMessage(stream, message);
  496.                 stream.endPacketVarShort();
  497.                 session.write(stream);
  498.         }
  499.  
  500.         public void sendGameBarStages() {
  501.                 sendConfig(1054, player.getClanStatus());
  502.                 sendConfig(1055, player.getAssistStatus());
  503.                 sendConfig(1056, player.isFilterGame() ? 1 : 0);
  504.                 sendConfig(2159, player.getFriendsIgnores().getFriendsChatStatus());
  505.                 sendOtherGameBarStages();
  506.                 sendPrivateGameBarStage();
  507.         }
  508.  
  509.         public void sendOtherGameBarStages() {
  510.                 OutputStream stream = new OutputStream(3);
  511.                 stream.writePacket(player, 30);
  512.                 stream.writeByteC(player.getTradeStatus());
  513.                 stream.writeByte128(player.getPublicStatus());
  514.                 session.write(stream);
  515.         }
  516.  
  517.         public void sendPrivateGameBarStage() {
  518.                 OutputStream stream = new OutputStream(2);
  519.                 stream.writePacket(player, 67);
  520.                 stream.writeByte(player.getFriendsIgnores().getStatus().getCode());
  521.                 session.write(stream);
  522.         }
  523.  
  524.         public void receivePrivateMessage(String name, String display, int rights, String message) {
  525.                 Player p2 = World.getPlayerByDisplayName(name);
  526.                 if (!name.equals("System")) {
  527.                         if (!p2.getFriendsIgnores().canSee(player))
  528.                                 return;
  529.                         if (p2.getFriendsIgnores().isIgnored(player.getUsername()))
  530.                                 return;
  531.                 }
  532.                 OutputStream stream = new OutputStream();
  533.                 stream.writePacketVarShort(player, 10);
  534.                 stream.writeByte(name.equals(display) ? 0 : 1);
  535.                 stream.writeString(display);
  536.                 if (!name.equals(display))
  537.                         stream.writeString(name);
  538.                 for (int i = 0; i < 5; i++)
  539.                         stream.writeByte(Utils.getRandom(255));
  540.                 stream.writeByte(rights);
  541.                 if (!player.hasDisabledProfanity())
  542.                         message = Profanity.filter(message);
  543.                 Huffman.sendEncryptMessage(stream, message);
  544.                 stream.endPacketVarShort();
  545.                 session.write(stream);
  546.         }
  547.  
  548.         public void receiveFriendChatMessage(String name, String display, int rights, String chatName, String message) {
  549.  
  550.                 OutputStream stream = new OutputStream();
  551.                 stream.writePacketVarByte(player, 25);
  552.                 stream.writeByte(name.equals(display) ? 0 : 1);
  553.                 stream.writeString(display);
  554.                 if (!name.equals(display))
  555.                         stream.writeString(name);
  556.                 stream.writeLong(Utils.stringToLong(chatName));
  557.                 for (int i = 0; i < 5; i++)
  558.                         stream.writeByte(Utils.getRandom(255));
  559.                 stream.writeByte(rights);
  560.                 if (!player.hasDisabledProfanity())
  561.                         message = Profanity.filter(message);
  562.                 Huffman.sendEncryptMessage(stream, message);
  563.                 stream.endPacketVarByte();
  564.                 session.write(stream);
  565.         }
  566.  
  567.         public void sendDynamicMapRegion(boolean sendLswp) {
  568.                 OutputStream stream = new OutputStream();
  569.                 stream.writePacketVarShort(player, 51);
  570.                 if (sendLswp)
  571.                         player.getLocalPlayerUpdate().init(stream);
  572.                 int regionX = player.getChunkX();
  573.                 int regionY = player.getChunkY();
  574.                 stream.writeByteC(player.isForceNextMapLoadRefresh() ? 1 : 0);
  575.                 stream.write128Byte(2);
  576.                 stream.writeByte128(player.getMapSize());
  577.                 stream.writeShort128(regionY);
  578.                 stream.writeShort(regionX);
  579.                 stream.initBitAccess();
  580.                 int mapHash = Settings.MAP_SIZES[player.getMapSize()] >> 4;
  581.                 int[] realRegionIds = new int[4 * mapHash * mapHash];
  582.                 int realRegionIdsCount = 0;
  583.                 for (int plane = 0; plane < 4; plane++) {
  584.                         for (int thisRegionX = (regionX - mapHash); thisRegionX <= ((regionX + mapHash)); thisRegionX++) {
  585.                                 for (int thisRegionY = (regionY - mapHash); thisRegionY <= ((regionY + mapHash)); thisRegionY++) {
  586.                                         int regionId = (((thisRegionX / 8) << 8) + (thisRegionY / 8));
  587.                                         Region region = World.getRegions().get(regionId);
  588.                                         int realRegionX;
  589.                                         int realRegionY;
  590.                                         int realPlane;
  591.                                         int rotation;
  592.                                         if (region instanceof DynamicRegion) {
  593.                                                 DynamicRegion dynamicRegion = (DynamicRegion) region;
  594.                                                 int[] regionCoords = dynamicRegion.getRegionCoords()[plane][thisRegionX - ((thisRegionX / 8) * 8)][thisRegionY - ((thisRegionY / 8) * 8)];
  595.                                                 realRegionX = regionCoords[0];
  596.                                                 realRegionY = regionCoords[1];
  597.                                                 realPlane = regionCoords[2];
  598.                                                 rotation = regionCoords[3];
  599.                                         } else {
  600.                                                 realRegionX = thisRegionX;
  601.                                                 realRegionY = thisRegionY;
  602.                                                 realPlane = plane;
  603.                                                 rotation = 0;
  604.                                         }
  605.                                         if (realRegionX == 0 || realRegionY == 0)
  606.                                                 stream.writeBits(1, 0);
  607.                                         else {
  608.                                                 stream.writeBits(1, 1);
  609.                                                 stream.writeBits(26, (rotation << 1) | (realPlane << 24) | (realRegionX << 14) | (realRegionY << 3));
  610.                                                 int realRegionId = (((realRegionX / 8) << 8) + (realRegionY / 8));
  611.                                                 boolean found = false;
  612.                                                 for (int index = 0; index < realRegionIdsCount; index++)
  613.                                                         if (realRegionIds[index] == realRegionId) {
  614.                                                                 found = true;
  615.                                                                 break;
  616.                                                         }
  617.                                                 if (!found)
  618.                                                         realRegionIds[realRegionIdsCount++] = realRegionId;
  619.                                         }
  620.  
  621.                                 }
  622.                         }
  623.                 }
  624.                 stream.finishBitAccess();
  625.                 for (int index = 0; index < realRegionIdsCount; index++) {
  626.                         int[] xteas = MapArchiveKeys.getMapKeys(realRegionIds[index]);
  627.                         if (xteas == null)
  628.                                 xteas = new int[4];
  629.                         for (int keyIndex = 0; keyIndex < 4; keyIndex++)
  630.                                 stream.writeInt(xteas[keyIndex]);
  631.                 }
  632.                 stream.endPacketVarShort();
  633.                 session.write(stream);
  634.         }
  635.  
  636.         public void sendMapRegion(boolean sendLswp) {
  637.                 OutputStream stream = new OutputStream();
  638.                 stream.writePacketVarShort(player, 85);
  639.                 if (sendLswp)
  640.                         player.getLocalPlayerUpdate().init(stream);
  641.                 stream.writeByte(player.getMapSize());
  642.                 stream.writeShort(player.getChunkX());
  643.                 stream.writeShort(player.getChunkY());
  644.                 stream.writeByte(player.isForceNextMapLoadRefresh() ? 1 : 0);
  645.                 for (int regionId : player.getMapRegionsIds()) {
  646.                         int[] xteas = MapArchiveKeys.getMapKeys(regionId);
  647.                         if (xteas == null)
  648.                                 xteas = new int[4];
  649.                         for (int index = 0; index < 4; index++)
  650.                                 stream.writeInt(xteas[index]);
  651.                 }
  652.                 stream.endPacketVarShort();
  653.                 session.write(stream);
  654.         }
  655.  
  656.         public void sendCutscene(int id) {
  657.                 OutputStream stream = new OutputStream();
  658.                 stream.writePacketVarShort(player, 110);
  659.                 stream.writeShort(id);
  660.                 stream.writeShort(20);
  661.                 for (int count = 0; count < 20; count++)
  662.                         for (int i = 0; i < 4; i++)
  663.                                 stream.writeInt(0);
  664.                 byte[] appearence = player.getAppearence().getAppeareanceData();
  665.                 stream.writeByte(appearence.length);
  666.                 stream.writeBytes(appearence);
  667.                 stream.endPacketVarShort();
  668.                 session.write(stream);
  669.         }
  670.  
  671.         public void sendWindowsPane(int id, int type) {
  672.                 player.getInterfaceManager().setWindowsPane(id);
  673.                 OutputStream stream = new OutputStream(4);
  674.                 stream.writePacket(player, 37);
  675.                 stream.writeIntV1(0);
  676.                 stream.writeIntV1(0);
  677.                 stream.writeShort128(id);
  678.                 stream.writeByte128(type);
  679.                 stream.writeIntLE(0);
  680.                 stream.writeIntLE(0);
  681.                 session.write(stream);
  682.         }
  683.  
  684.         public void sendPlayerOption(String option, int slot, boolean top) {
  685.                 sendPlayerOption(option, slot, top, -1);
  686.         }
  687.  
  688.         public void sendPublicMessage(Player p, PublicChatMessage message) {
  689.                 OutputStream stream = new OutputStream();
  690.                 stream.writePacketVarByte(player, 152);
  691.                 stream.writeShort(p.getIndex());
  692.                 stream.writeShort(message.getEffects());
  693.                 stream.writeByte(p.getMessageIcon());
  694.                 String filtered = message.getMessage();
  695.                 if (!player.hasDisabledProfanity())
  696.                         filtered = Profanity.filter(filtered);
  697.                 if (message instanceof QuickChatMessage) {
  698.                         QuickChatMessage qcMessage = (QuickChatMessage) message;
  699.                         stream.writeShort(qcMessage.getFileId());
  700.                         if (qcMessage.getMessage() != null)
  701.                                 stream.writeBytes(message.getMessage().getBytes());
  702.                 } else {
  703.                         byte[] chatStr = new byte[250];
  704.                         chatStr[0] = (byte) filtered.length();
  705.                         int offset = 1 + Huffman.encryptMessage(1, filtered.length(), chatStr, 0, filtered.getBytes());
  706.                         stream.writeBytes(chatStr, 0, offset);
  707.                 }
  708.                 stream.endPacketVarByte();
  709.                 session.write(stream);
  710.         }
  711.  
  712.         public void sendPlayerOption(String option, int slot, boolean top, int cursor) {
  713.                 OutputStream stream = new OutputStream();
  714.                 stream.writePacketVarByte(player, 111);
  715.                 stream.writeString(option);
  716.                 stream.writeByte128(slot);
  717.                 stream.writeShortLE128(cursor);
  718.                 stream.writeByteC(top ? 1 : 0);
  719.                 stream.endPacketVarByte();
  720.                 session.write(stream);
  721.         }
  722.  
  723.         public void sendLocalPlayersUpdate() {
  724.                 session.write(player.getLocalPlayerUpdate().createPacketAndProcess());
  725.         }
  726.  
  727.         public void sendLocalNPCsUpdate() {
  728.                 session.write(player.getLocalNPCUpdate().createPacketAndProcess());
  729.         }
  730.  
  731.         public void sendGraphics(Graphics graphics, Object target) {
  732.                 OutputStream stream = new OutputStream(13);
  733.                 int hash = 0;
  734.                 if (target instanceof Player) {
  735.                         Player p = (Player) target;
  736.                         hash = p.getIndex() & 0xffff | 1 << 28;
  737.                 } else if (target instanceof NPC) {
  738.                         NPC n = (NPC) target;
  739.                         hash = n.getIndex() & 0xffff | 1 << 29;
  740.                 } else {
  741.                         WorldTile tile = (WorldTile) target;
  742.                         hash = tile.getPlane() << 28 | tile.getX() << 14 | tile.getY() & 0x3fff | 1 << 30;
  743.                 }
  744.                 stream.writePacket(player, 126);
  745.                 stream.writeByteC(0);
  746.                 stream.writeShort128(graphics.getId());
  747.                 stream.writeByteC(graphics.getSettings2Hash());
  748.                 stream.writeShort128(graphics.getSpeed());
  749.                 stream.writeIntLE(hash);
  750.                 stream.writeShortLE(graphics.getHeight());
  751.                 session.write(stream);
  752.         }
  753.  
  754.         public void closeInterface(int windowComponentId) {
  755.                 closeInterface(player.getInterfaceManager().getTabWindow(windowComponentId), windowComponentId);
  756.                 player.getInterfaceManager().removeTab(windowComponentId);
  757.         }
  758.  
  759.         public void closeInterface(int windowId, int windowComponentId) {
  760.                 OutputStream stream = new OutputStream(5);
  761.                 stream.writePacket(player, 78);
  762.                 stream.writeInt(windowId << 16 | windowComponentId);
  763.                 session.write(stream);
  764.         }
  765.  
  766.         public void sendInterface(boolean nocliped, int windowId, int windowComponentId, int interfaceId) {
  767.                 if (!(windowId == 752 && (windowComponentId == 9 || windowComponentId == 12))) {
  768.                         if (player.getInterfaceManager().containsInterface(windowComponentId, interfaceId))
  769.                                 closeInterface(windowComponentId);
  770.                         if (!player.getInterfaceManager().addInterface(windowId, windowComponentId, interfaceId)) {
  771.                                 return;
  772.                         }
  773.                 }
  774.                 int[] xteas = new int[4];
  775.                 OutputStream stream = new OutputStream(24);
  776.                 stream.writePacket(player, 38);
  777.                 stream.writeInt(xteas[0]);
  778.                 stream.writeIntV2(xteas[2]);
  779.                 stream.writeIntV2(xteas[1]);
  780.                 stream.writeShortLE128(interfaceId);
  781.                 stream.writeIntLE(xteas[3]);
  782.                 stream.writeInt(windowId << 16 | windowComponentId);
  783.                 stream.writeByteC(nocliped ? 1 : 0);
  784.                 // TODO: interface noclip/walkable
  785.                 session.write(stream);
  786.         }
  787.  
  788.         public void sendSystemUpdate(int delay) {
  789.                 OutputStream stream = new OutputStream(3);
  790.                 stream.writePacket(player, 102);
  791.                 stream.writeShort((int) (delay * 1.6));
  792.                 session.write(stream);
  793.         }
  794.  
  795.         public void sendUpdateItems(int key, ItemsContainer<Item> items, int... slots) {
  796.                 sendUpdateItems(key, items.getItems(), slots);
  797.         }
  798.  
  799.         public void sendUpdateItems(int key, Item[] items, int... slots) {
  800.                 sendUpdateItems(key, key < 0, items, slots);
  801.         }
  802.  
  803.         public void sendUpdateItems(int key, boolean negativeKey, Item[] items, int... slots) {
  804.                 OutputStream stream = new OutputStream();
  805.                 stream.writePacketVarShort(player, 4);
  806.                 stream.writeShort(key);
  807.                 stream.writeByte(negativeKey ? 1 : 0);
  808.                 for (int slotId : slots) {
  809.                         if (slotId >= items.length)
  810.                                 continue;
  811.                         stream.writeSmart(slotId);
  812.                         int id = -1;
  813.                         int amount = 0;
  814.                         Item item = items[slotId];
  815.                         if (item != null) {
  816.                                 id = item.getId();
  817.                                 amount = item.getAmount();
  818.                         }
  819.                         stream.writeShort(id + 1);
  820.                         if (id != -1) {
  821.                                 stream.writeByte(amount >= 255 ? 255 : amount);
  822.                                 if (amount >= 255)
  823.                                         stream.writeInt(amount);
  824.                         }
  825.                 }
  826.                 stream.endPacketVarShort();
  827.                 session.write(stream);
  828.         }
  829.  
  830.         public void sendGlobalString(int id, String string) {
  831.                 OutputStream stream = new OutputStream();
  832.                 if (string.length() > 253) {
  833.                         stream.writePacketVarShort(player, 119);
  834.                         stream.writeShortLE(id);
  835.                         stream.writeString(string);
  836.                         stream.endPacketVarShort();
  837.                 } else {
  838.                         stream.writePacketVarByte(player, 54);
  839.                         stream.writeString(string);
  840.                         stream.writeShortLE128(id);
  841.                         stream.endPacketVarByte();
  842.                 }
  843.                 session.write(stream);
  844.         }
  845.  
  846.         public void sendItems(int key, ItemsContainer<Item> items) {
  847.                 sendItems(key, key < 0, items);
  848.         }
  849.  
  850.         public void sendItems(int key, boolean negativeKey, ItemsContainer<Item> items) {
  851.                 sendItems(key, negativeKey, items.getItems());
  852.         }
  853.  
  854.         public void sendItems(int key, Item[] items) {
  855.                 sendItems(key, key < 0, items);
  856.         }
  857.  
  858.         public void resetItems(int key, boolean negativeKey, int size) {
  859.                 sendItems(key, negativeKey, new Item[size]);
  860.         }
  861.  
  862.         public void sendItems(int key, boolean negativeKey, Item[] items) {
  863.                 OutputStream stream = new OutputStream();
  864.                 stream.writePacketVarShort(player, 5);
  865.                 stream.writeShort(key);
  866.                 stream.writeByte(negativeKey ? 1 : 0);
  867.                 stream.writeShort(items.length);
  868.                 for (int index = 0; index < items.length; index++) {
  869.                         Item item = items[index];
  870.                         int id = -1;
  871.                         int amount = 0;
  872.                         if (item != null) {
  873.                                 id = item.getId();
  874.                                 amount = item.getAmount();
  875.                         }
  876.                         stream.write128Byte(amount >= 255 ? 255 : amount);
  877.                         if (amount >= 255)
  878.                                 stream.writeIntV2(amount);
  879.                         stream.writeShortLE128(id + 1);
  880.                 }
  881.                 stream.endPacketVarShort();
  882.                 session.write(stream);
  883.         }
  884.  
  885.         public void sendLogout(boolean lobby) {
  886.                 OutputStream stream = new OutputStream();
  887.                 stream.writePacket(player, lobby ? 9 : 62);
  888.                 ChannelFuture future = session.write(stream);
  889.                 if (future != null)
  890.                         future.addListener(ChannelFutureListener.CLOSE);
  891.                 else
  892.                         session.getChannel().close();
  893.         }
  894.  
  895.         public void sendInventoryMessage(int border, int slotId, String message) {
  896.                 sendGameMessage(message);
  897.                 sendRunScript(948, border, slotId, message);
  898.         }
  899.  
  900.         public void sendNPCMessage(int border, NPC npc, String message) {
  901.                 sendGameMessage(message);
  902.         }
  903.  
  904.         public void sendGameMessage(String text) {
  905.                 sendGameMessage(text, false);
  906.         }
  907.  
  908.         public void sendGameMessage(String text, boolean filter) {
  909.                 sendMessage(filter ? 109 : 0, text, null);
  910.         }
  911.  
  912.         public void sendPanelBoxMessage(String text) {
  913.                 sendMessage(player.getRights() == 2 ? 99 : 0, text, null);
  914.         }
  915.  
  916.         public void sendTradeRequestMessage(Player p) {
  917.                 if (player.getFriendsIgnores().getIgnores().contains(p.getUsername())) {
  918.                         return;
  919.                 }
  920.                 sendMessage(100, "wishes to trade with you.", p);
  921.         }
  922.  
  923.         public void sendClanWarsRequestMessage(Player p) {
  924.                 if (player.getFriendsIgnores().getIgnores().contains(p.getUsername())) {
  925.                         return;
  926.                 }
  927.                 sendMessage(101, "wishes to challenge your clan to a clan war.", p);
  928.         }
  929.  
  930.         public void sendDuelChallengeRequestMessage(Player p, boolean friendly) {
  931.                 if (player.getFriendsIgnores().getIgnores().contains(p.getUsername())) {
  932.                         return;
  933.                 }
  934.                 sendMessage(101, "wishes to duel with you(" + (friendly ? "friendly" : "stake") + ").", p);
  935.         }
  936.  
  937.         public void sendMessage(int type, String text, Player p) {
  938.                 int maskData = 0;
  939.                 // this is the legit max, go to 249 rip client
  940.                 if (text.length() >= 248)
  941.                         text = text.substring(0, 248);
  942.  
  943.                 if (p != null) {
  944.                         maskData |= 0x1;
  945.                         if (p.hasDisplayName())
  946.                                 maskData |= 0x2;
  947.                 }
  948.                 OutputStream stream = new OutputStream();
  949.                 stream.writePacketVarByte(player, 160);
  950.                 stream.writeSmart(type);
  951.                 stream.writeInt(player.getTileHash()); // junk, not used by client
  952.                 stream.writeByte(maskData);
  953.                 if ((maskData & 0x1) != 0) {
  954.                         stream.writeString(p.getDisplayName());
  955.                         if (p.hasDisplayName())
  956.                                 stream.writeString(Utils.formatPlayerNameForDisplay(p.getUsername()));
  957.                 }
  958.                 stream.writeString(text);
  959.                 stream.endPacketVarByte();
  960.                 session.write(stream);
  961.         }
  962.  
  963.         public void sendSound(int id, int delay, int effectType) {
  964.                 if (effectType == 1)
  965.                         sendIndex14Sound(id, delay);
  966.                 else if (effectType == 2)
  967.                         sendIndex15Sound(id, delay);
  968.         }
  969.  
  970.         public void sendVoice(int id) {
  971.                 resetSounds();
  972.                 sendSound(id, 0, 2);
  973.         }
  974.  
  975.         public void resetSounds() {
  976.                 OutputStream stream = new OutputStream(1);
  977.                 stream.writePacket(player, 120);
  978.                 session.write(stream);
  979.         }
  980.  
  981.         public void sendIndex14Sound(int id, int delay) {
  982.                 OutputStream stream = new OutputStream(9);
  983.                 stream.writePacket(player, 136);
  984.                 stream.writeShort(id);
  985.                 stream.writeByte(1);
  986.                 stream.writeShort(delay);
  987.                 stream.writeByte(255);
  988.                 stream.writeShort(256);
  989.                 session.write(stream);
  990.         }
  991.  
  992.         public void sendIndex15Sound(int id, int delay) {
  993.                 OutputStream stream = new OutputStream(7);
  994.                 stream.writePacket(player, 104);
  995.                 stream.writeShort(id);
  996.                 stream.writeByte(1);
  997.                 stream.writeShort(delay);
  998.                 stream.writeByte(255);
  999.                 session.write(stream);
  1000.         }
  1001.  
  1002.         public void sendMusicEffect(int id) {
  1003.                 OutputStream stream = new OutputStream(7);
  1004.                 stream.writePacket(player, 60);
  1005.                 stream.write24BitIntegerV2(0);
  1006.                 stream.write128Byte(255);
  1007.                 stream.writeShortLE(id);
  1008.                 session.write(stream);
  1009.         }
  1010.  
  1011.         public void sendMusic(int id) {
  1012.                 sendMusic(id, 100, 255);
  1013.         }
  1014.  
  1015.         public void sendMusic(int id, int delay, int volume) {
  1016.                 OutputStream stream = new OutputStream(5);
  1017.                 stream.writePacket(player, 63);
  1018.                 stream.writeByte128(delay);
  1019.                 stream.writeByte128(volume);
  1020.                 stream.writeShort128(id);
  1021.                 session.write(stream);
  1022.         }
  1023.  
  1024.         public void sendSkillLevel(int skill) {
  1025.                 OutputStream stream = new OutputStream(7);
  1026.                 stream.writePacket(player, 140);
  1027.                 stream.writeInt((int) player.getSkills().getXp(skill));
  1028.                 stream.writeByte(skill);
  1029.                 stream.writeByte(player.getSkills().getLevel(skill));
  1030.                 session.write(stream);
  1031.         }
  1032.  
  1033.         public void sendBlackOut(int area) {
  1034.                 OutputStream out = new OutputStream(2);
  1035.                 out.writePacket(player, 154);
  1036.                 out.writeByte(area);
  1037.                 session.write(out);
  1038.         }
  1039.  
  1040.         public void sendCameraLook(int viewLocalX, int viewLocalY, int viewZ) {
  1041.                 sendCameraLook(viewLocalX, viewLocalY, viewZ, -1, -1);
  1042.         }
  1043.  
  1044.         public void sendCameraLook(int viewLocalX, int viewLocalY, int viewZ, int speed1, int speed2) {
  1045.                 OutputStream stream = new OutputStream(7);
  1046.                 stream.writePacket(player, 24);
  1047.                 stream.writeByte(viewLocalX);
  1048.                 stream.writeShort128(viewZ >> 2);
  1049.                 stream.writeByte128(viewLocalY);
  1050.                 stream.writeByteC(speed1);
  1051.                 stream.write128Byte(speed2);
  1052.                 session.write(stream);
  1053.         }
  1054.  
  1055.         public void sendResetCamera() {
  1056.                 OutputStream stream = new OutputStream(1);
  1057.                 stream.writePacket(player, 66);
  1058.                 session.write(stream);
  1059.         }
  1060.  
  1061.         public void sendCameraPos(int moveLocalX, int moveLocalY, int moveZ) {
  1062.                 sendCameraPos(moveLocalX, moveLocalY, moveZ, -1, -1);
  1063.         }
  1064.  
  1065.         public void sendClientConsoleCommand(String command) {
  1066.                 OutputStream stream = new OutputStream();
  1067.                 stream.writePacketVarByte(player, 61);
  1068.                 stream.writeString(command);
  1069.                 stream.endPacketVarByte();
  1070.         }
  1071.  
  1072.         public void sendOpenURL(String url) {
  1073.                 OutputStream stream = new OutputStream();
  1074.                 stream.writePacketVarShort(player, 16);
  1075.                 stream.writeByte(0);
  1076.                 stream.writeString(url);
  1077.                 stream.endPacketVarShort();
  1078.                 session.write(stream);
  1079.         }
  1080.  
  1081.         public void sendSetMouse(String walkHereReplace, int cursor) {
  1082.                 OutputStream stream = new OutputStream();
  1083.                 stream.writePacketVarByte(player, 153);
  1084.                 stream.writeString(walkHereReplace);
  1085.                 stream.writeShort(cursor);
  1086.                 stream.endPacketVarByte();
  1087.                 session.write(stream);
  1088.         }
  1089.  
  1090.         public void sendCameraPos(int moveLocalX, int moveLocalY, int moveZ, int speed1, int speed2) {
  1091.                 OutputStream stream = new OutputStream(7);
  1092.                 stream.writePacket(player, 39);
  1093.                 stream.writeByte(moveLocalY);
  1094.                 stream.writeByte(moveLocalX);
  1095.                 stream.write128Byte(speed1);
  1096.                 stream.writeShortLE(moveZ >> 2);
  1097.                 stream.writeByte128(speed2);
  1098.                 session.write(stream);
  1099.         }
  1100.  
  1101.         public void sendAccessMask(Player player, int min, int max, int interfaceId, int childId, int hash) {
  1102.                 OutputStream stream = new OutputStream(13);
  1103.                 stream.writePacket(player, 121);
  1104.                 stream.writeShortLE128(min);
  1105.                 stream.writeIntV2(interfaceId << 16 | childId);
  1106.                 stream.writeShort(max);
  1107.                 stream.writeIntLE(hash);
  1108.                 session.write(stream);
  1109.         }
  1110.  
  1111.         public void sendBlankRunScript(int scriptId) {
  1112.                 sendRunScript(scriptId, new Object[] {});
  1113.         }
  1114.  
  1115.         @Deprecated
  1116.         public void sendVar(int id, int value) {
  1117.                 if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE)
  1118.                         sendVar2(id, value);
  1119.                 else
  1120.                         sendVar1(id, value);
  1121.         }
  1122.  
  1123.         public void sendVar1(int id, int value) {
  1124.                 OutputStream stream = new OutputStream(4);
  1125.                 stream.writePacket(player, 115);
  1126.                 stream.writeByte(value);
  1127.                 stream.writeShortLE128(id);
  1128.                 session.write(stream);
  1129.         }
  1130.  
  1131.         public void sendVar2(int id, int value) {
  1132.                 OutputStream stream = new OutputStream(7);
  1133.                 stream.writePacket(player, 8);
  1134.                 stream.writeIntV2(value);
  1135.                 stream.writeShortLE128(id);
  1136.                 session.write(stream);
  1137.         }
  1138.  
  1139.         public void sendUnlockIComponentOptionSlots(int interfaceId, int componentId, int fromSlot, int toSlot, boolean unlockEvent, int... optionsSlots) {
  1140.                 int settingsHash = unlockEvent ? 1 : 0;
  1141.                 for (int slot : optionsSlots)
  1142.                         settingsHash |= 2 << slot;
  1143.                 sendIComponentSettings(interfaceId, componentId, fromSlot, toSlot, settingsHash);
  1144.         }
  1145.  
  1146.         public void sendRunScriptBlank(int scriptId) {
  1147.                 sendRunScript(scriptId, new Object[] {});
  1148.         }
  1149.  
  1150.         public void receiveClanChatMessage(boolean myClan, String display, int rights, ChatMessage message) {
  1151.                 OutputStream stream = new OutputStream();
  1152.                 stream.writePacketVarByte(player, 81);
  1153.                 stream.writeByte(myClan ? 1 : 0);
  1154.                 stream.writeString(display);
  1155.                 for (int i = 0; i < 5; i++)
  1156.                         stream.writeByte(Utils.getRandom(255));
  1157.                 stream.writeByte(rights);
  1158.                 String message1 = message.getMessage(false);
  1159.                 if (!player.hasDisabledProfanity()) {
  1160.                         message1 = Profanity.filter(message1);
  1161.                 }
  1162.                 Huffman.sendEncryptMessage(stream, message1);
  1163.                 stream.endPacketVarByte();
  1164.                 session.write(stream);
  1165.         }
  1166.  
  1167.         public void sendClanChannel(ClansManager manager, boolean myClan) {
  1168.                 OutputStream stream = new OutputStream(manager == null ? 4 : manager.getClanChannelDataBlock().length + 4);
  1169.                 stream.writePacketVarShort(player, 49);
  1170.                 stream.writeByte(myClan ? 1 : 0); // 123
  1171.                 if (manager != null)
  1172.                         stream.writeBytes(manager.getClanChannelDataBlock());
  1173.                 stream.endPacketVarShort();
  1174.                 session.write(stream);
  1175.         }
  1176.  
  1177.         public void sendClanSettings(ClansManager manager, boolean myClan) {
  1178.                 OutputStream stream = new OutputStream(manager == null ? 4 : manager.getClanSettingsDataBlock().length + 4);
  1179.                 stream.writePacketVarShort(player, 137); // 1
  1180.                 stream.writeByte(myClan ? 1 : 0);
  1181.                 if (manager != null)
  1182.                         stream.writeBytes(manager.getClanSettingsDataBlock());
  1183.                 stream.endPacketVarShort();
  1184.                 session.write(stream);
  1185.         }
  1186.  
  1187.         public void sendIComponentSprite(int interfaceId, int componentId, int spriteId) {
  1188.                 OutputStream stream = new OutputStream(8);
  1189.                 stream.writePacket(player, 135);
  1190.                 stream.writeInt(spriteId);
  1191.                 stream.writeIntV2(interfaceId << 16 | componentId);
  1192.                 //session.write(stream);
  1193.         }
  1194.  
  1195.         public void sendClanInviteMessage(Player p) {
  1196.                 sendMessage(117, p.getDisplayName() + " is inviting you to join their clan.", p);
  1197.         }
  1198.  
  1199.         public void sendAssistanceMessage(Player p) {
  1200.                 sendMessage(102, "is requesting your assistance.", p);
  1201.         }
  1202.  
  1203.         public void sendResetMinimapFlag() {
  1204.                 OutputStream stream = new OutputStream();
  1205.                 stream.writePacket(player, 70);
  1206.                 stream.write128Byte(255);
  1207.                 stream.write128Byte(255);
  1208.                 session.write(stream);
  1209.         }
  1210.  
  1211.         public void sendMinimapFlag(int localX, int localY) {
  1212.                 OutputStream stream = new OutputStream();
  1213.                 stream.writePacket(player, 70);
  1214.                 stream.write128Byte(localX);
  1215.                 stream.write128Byte(localY);
  1216.                 session.write(stream);
  1217.         }
  1218.  
  1219.         public void sendGrandExchangeOffer(Offer offer) {
  1220.                 OutputStream stream = new OutputStream(21);
  1221.                 stream.writePacket(player, 57);
  1222.                 stream.writeByte(offer.getSlot());
  1223.                 stream.writeByte(offer.getStage());
  1224.                 if (offer.forceRemove())
  1225.                         stream.skip(18);
  1226.                 else {
  1227.                         stream.writeShort(offer.getId());
  1228.                         stream.writeInt(offer.getPrice());
  1229.                         stream.writeInt(offer.getAmount());
  1230.                         stream.writeInt(offer.getTotalAmount());
  1231.                         stream.writeInt(offer.getPriceTotal());
  1232.                 }
  1233.                 session.write(stream);
  1234.         }
  1235.  
  1236.         public void sendObjectMessage(int border, int color, WorldObject object, String message) {
  1237.                 sendGameMessage(message);
  1238.                 sendGlobalString(306, message);
  1239.                 sendGlobalConfig(1699, color);
  1240.                 sendGlobalConfig(1700, border);
  1241.                 sendGlobalConfig(1695, 1);
  1242.                 sendObjectInterface(object, true, 746, 0, 1177);
  1243.         }
  1244.  
  1245.         public void sendObjectInterface(WorldObject object, boolean nocliped, int windowId, int windowComponentId, int interfaceId) {
  1246.                 int[] xteas = new int[4];
  1247.                 OutputStream stream = new OutputStream(33);
  1248.                 stream.writePacket(player, 143);
  1249.                 stream.writeIntV2(xteas[1]);
  1250.                 stream.writeByte(nocliped ? 1 : 0);
  1251.                 stream.writeIntLE(xteas[2]);
  1252.                 stream.writeIntV1(object.getId());
  1253.                 stream.writeByte128((object.getType() << 2) | (object.getRotation() & 0x3));
  1254.                 stream.writeInt((object.getPlane() << 28) | (object.getX() << 14) | object.getY()); // the
  1255.                 stream.writeIntV2((windowId << 16) | windowComponentId);
  1256.                 stream.writeShort(interfaceId);
  1257.                 stream.writeInt(xteas[3]);
  1258.                 stream.writeInt(xteas[0]);
  1259.                 session.write(stream);
  1260.         }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!