开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
ServerType0.pm
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：43k
源码类别：

外挂编程

开发平台：

Windows_Unix

ServerType0.pm：源码内容
  1. #########################################################################
  2. #  OpenKore - Network subsystem
  3. #  This module contains functions for sending messages to the server.
  4. #
  5. #  This software is open source, licensed under the GNU General Public
  6. #  License, version 2.
  7. #  Basically, this means that you're allowed to modify and distribute
  8. #  this software. However, if you distribute modified versions, you MUST
  9. #  also distribute the source code.
  10. #  See http://www.gnu.org/licenses/gpl.html for the full license.
  11. #########################################################################
  12. # June 21 2007, this is the server type for:
  13. # pRO (Philippines), except Sakray and Thor
  14. # And many other servers.
  15. # Servertype overview: http://www.openkore.com/wiki/index.php/ServerType
  16. package Network::Send::ServerType0;
  18. use strict;
  19. use Time::HiRes qw(time);
  20. use Digest::MD5;
  22. use Network::Send ();
  23. use base qw(Network::Send);
  24. use Plugins;
  25. use Globals qw($accountID $sessionID $sessionID2 $accountSex $char $charID %config %guild @chars $masterServer $syncSync);
  26. use Log qw(debug);
  27. use Translation qw(T TF);
  28. use I18N qw(stringToBytes);
  29. use Utils;
  30. use Utils::Exceptions;
  33. sub new {
  34. my ($class) = @_;
  35. return $class->SUPER::new(@_);
  36. }
  38. sub sendAddSkillPoint {
  39. my ($self, $skillID) = @_;
  40. my $msg = pack("C*", 0x12, 0x01) . pack("v*", $skillID);
  41. $self->sendToServer($msg);
  42. }
  44. sub sendAddStatusPoint {
  45. my ($self, $statusID) = @_;
  46. my $msg = pack("C*", 0xBB, 0) . pack("v*", $statusID) . pack("C*", 0x01);
  47. $self->sendToServer($msg);
  48. }
  50. sub sendAlignment {
  51. my ($self, $ID, $alignment) = @_;
  52. my $msg = pack("C*", 0x49, 0x01) . $ID . pack("C*", $alignment);
  53. $self->sendToServer($msg);
  54. debug "Sent Alignment: ".getHex($ID).", $alignmentn", "sendPacket", 2;
  55. }
  57. sub sendArrowCraft {
  58. my ($self, $index) = @_;
  59. my $msg = pack("C*", 0xAE, 0x01) . pack("v*", $index);
  60. $self->sendToServer($msg);
  61. debug "Sent Arrowmake: $indexn", "sendPacket", 2;
  62. }
  64. sub sendAttack {
  65. my ($self, $monID, $flag) = @_;
  66. my $msg;
  68. $msg = pack("C*", 0x89, 0x00) .
  69. $monID .
  70. pack("C*", $flag);
  72. $self->sendToServer($msg);
  73. debug "Sent attack: ".getHex($monID)."n", "sendPacket", 2;
  74. }
  76. sub sendAttackStop {
  77. my $self = shift;
  78. #my $msg = pack("C*", 0x18, 0x01);
  79. # Apparently this packet is wrong. The server disconnects us if we do this.
  80. # Sending a move command to the current position seems to be able to emulate
  81. # what this function is supposed to do.
  83. # Don't use this function, use Misc::stopAttack() instead!
  84. #sendMove ($char->{'pos_to'}{'x'}, $char->{'pos_to'}{'y'});
  85. #debug "Sent stop attackn", "sendPacket";
  86. }
  88. sub sendAutoSpell {
  89. my ($self, $ID) = @_;
  90. my $msg = pack("C*", 0xce, 0x01, $ID, 0x00, 0x00, 0x00);
  91. $self->sendToServer($msg);
  92. }
  94. sub sendBanCheck {
  95. my ($self, $ID) = @_;
  96. my $msg = pack("C*", 0x87, 0x01) . $ID;
  97. $self->sendToServer($msg);
  98. debug "Sent Account Ban Check Request : " . getHex($ID) . "n", "sendPacket", 2;
  99. }
  101. sub sendBuy {
  102. my ($self, $ID, $amount) = @_;
  103. my $msg = pack("C*", 0xC8, 0x00, 0x08, 0x00) . pack("v*", $amount, $ID);
  104. $self->sendToServer($msg);
  105. debug "Sent buy: ".getHex($ID)."n", "sendPacket", 2;
  106. }
  108. sub sendBuyVender {
  109. my ($self, $venderID, $ID, $amount) = @_;
  110. my $msg = pack("C*", 0x34, 0x01, 0x0C, 0x00) . $venderID . pack("v*", $amount, $ID);
  111. $self->sendToServer($msg);
  112. debug "Sent Vender Buy: ".getHex($ID)."n", "sendPacket";
  113. }
  115. sub sendCardMerge {
  116. my ($self, $card_index, $item_index) = @_;
  117. my $msg = pack("C*", 0x7C, 0x01) . pack("v*", $card_index, $item_index);
  118. $self->sendToServer($msg);
  119. debug "Sent Card Merge: $card_index, $item_indexn", "sendPacket";
  120. }
  122. sub sendCardMergeRequest {
  123. my ($self, $card_index) = @_;
  124. my $msg = pack("C*", 0x7A, 0x01) . pack("v*", $card_index);
  125. $self->sendToServer($msg);
  126. debug "Sent Card Merge Request: $card_indexn", "sendPacket";
  127. }
  129. sub sendCartAdd {
  130. my ($self, $index, $amount) = @_;
  131. my $msg = pack("C*", 0x26, 0x01) . pack("v*", $index) . pack("V*", $amount);
  132. $self->sendToServer($msg);
  133. debug "Sent Cart Add: $index x $amountn", "sendPacket", 2;
  134. }
  136. sub sendCartGet {
  137. my ($self, $index, $amount) = @_;
  138. my $msg = pack("C*", 0x27, 0x01) . pack("v*", $index) . pack("V*", $amount);
  139. $self->sendToServer($msg);
  140. debug "Sent Cart Get: $index x $amountn", "sendPacket", 2;
  141. }
  143. sub sendCharCreate {
  144. my ($self, $slot, $name,
  145.     $str, $agi, $vit, $int, $dex, $luk,
  146. $hair_style, $hair_color) = @_;
  147. $hair_color ||= 1;
  148. $hair_style ||= 0;
  150. my $msg = pack("C*", 0x67, 0x00) .
  151. pack("a24", stringToBytes($name)) .
  152. pack("C*", $str, $agi, $vit, $int, $dex, $luk, $slot) .
  153. pack("v*", $hair_color, $hair_style);
  154. $self->sendToServer($msg);
  155. }
  157. sub sendCharDelete {
  158. my ($self, $charID, $email) = @_;
  159. my $msg = pack("C*", 0x68, 0x00) .
  160. $charID . pack("a40", stringToBytes($email));
  161. $self->sendToServer($msg);
  162. }
  164. sub sendCharLogin {
  165. my ($self, $char) = @_;
  166. my $msg = pack("C*", 0x66,0) . pack("C*",$char);
  167. $self->sendToServer($msg);
  168. }
  170. sub sendChat {
  171. my ($self, $message) = @_;
  172. $message = "|00$message" if ($config{chatLangCode} && $config{chatLangCode} ne "none");
  174. my ($data, $charName); # Type: Bytes
  175. $message = stringToBytes($message); # Type: Bytes
  176. $charName = stringToBytes($char->{name});
  178. $data = pack("C*", 0x8C, 0x00) .
  179. pack("v*", length($charName) + length($message) + 8) .
  180. $charName . " : " . $message . chr(0);
  182. $self->sendToServer($data);
  183. }
  185. sub sendChatRoomBestow {
  186. my ($self, $name) = @_;
  188. my $binName = stringToBytes($name);
  189. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  190. $binName .= chr(0) x (24 - length($binName));
  192. my $msg = pack("C*", 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00) . $binName;
  193. $self->sendToServer($msg);
  194. debug "Sent Chat Room Bestow: $namen", "sendPacket", 2;
  195. }
  197. sub sendChatRoomChange {
  198. my ($self, $title, $limit, $public, $password) = @_;
  200. my $titleBytes = stringToBytes($title);
  201. my $passwordBytes = stringToBytes($password);
  202. $passwordBytes = substr($passwordBytes, 0, 8) if (length($passwordBytes) > 8);
  203. $passwordBytes = $passwordBytes . chr(0) x (8 - length($passwordBytes));
  205. my $msg = pack("C*", 0xDE, 0x00).pack("v*", length($titleBytes) + 15, $limit).pack("C*",$public).$passwordBytes.$titleBytes;
  206. $self->sendToServer($msg);
  207. debug "Sent Change Chat Room: $title, $limit, $public, $passwordn", "sendPacket", 2;
  208. }
  210. sub sendChatRoomCreate {
  211. my ($self, $title, $limit, $public, $password) = @_;
  213. my $passwordBytes = stringToBytes($password);
  214. $passwordBytes = substr($passwordBytes, 0, 8) if (length($passwordBytes) > 8);
  215. $passwordBytes = $passwordBytes . chr(0) x (8 - length($passwordBytes));
  216. my $binTitle = stringToBytes($title);
  218. my $msg = pack("C*", 0xD5, 0x00) .
  219. pack("v*", length($binTitle) + 15, $limit) .
  220. pack("C*", $public) . $passwordBytes . $binTitle;
  221. $self->sendToServer($msg);
  222. debug "Sent Create Chat Room: $title, $limit, $public, $passwordn", "sendPacket", 2;
  223. }
  225. sub sendChatRoomJoin {
  226. my ($self, $ID, $password) = @_;
  228. my $passwordBytes = stringToBytes($password);
  229. $passwordBytes = substr($passwordBytes, 0, 8) if (length($passwordBytes) > 8);
  230. $passwordBytes = $passwordBytes . chr(0) x (8 - length($passwordBytes));
  231. my $msg = pack("C*", 0xD9, 0x00).$ID.$passwordBytes;
  232. $self->sendToServer($msg);
  233. debug "Sent Join Chat Room: ".getHex($ID)." $passwordn", "sendPacket", 2;
  234. }
  236. sub sendChatRoomKick {
  237. my ($self, $name) = @_;
  239. my $binName = stringToBytes($name);
  240. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  241. $binName .= chr(0) x (24 - length($binName));
  242. my $msg = pack("C*", 0xE2, 0x00) . $binName;
  243. $self->sendToServer($msg);
  244. debug "Sent Chat Room Kick: $namen", "sendPacket", 2;
  245. }
  247. sub sendChatRoomLeave {
  248. my $self = shift;
  249. my $msg = pack("C*", 0xE3, 0x00);
  250. $self->sendToServer($msg);
  251. debug "Sent Leave Chat Roomn", "sendPacket", 2;
  252. }
  254. sub sendCloseShop {
  255. my $self = shift;
  256. my $msg = pack("C*", 0x2E, 0x01);
  257. $self->sendToServer($msg);
  258. debug "Shop Closedn", "sendPacket", 2;
  259. }
  261. sub sendCommandMercenary {
  262. my ($self, $command, $type) = @_;
  263. # $type is ignored, $command can be 0, 1 or 2
  265. my $msg = pack ('v2 C1', 0x022D, $type, $command);
  266. $self->sendToServer ($msg);
  267. debug "Sent MercenaryCommand", "sendPacket", 2;
  268. }
  270. sub sendCompanionRelease {
  271. my $msg = pack("C*", 0x2A, 0x01);
  272. $_[0]->sendToServer($msg);
  273. debug "Sent Companion Release (Cart, Falcon or Pecopeco)n", "sendPacket", 2;
  274. }
  276. sub sendCurrentDealCancel {
  277. my $msg = pack("C*", 0xED, 0x00);
  278. $_[0]->sendToServer($msg);
  279. debug "Sent Cancel Current Dealn", "sendPacket", 2;
  280. }
  282. sub sendDeal {
  283. my ($self, $ID) = @_;
  284. my $msg = pack("C*", 0xE4, 0x00) . $ID;
  285. $_[0]->sendToServer($msg);
  286. debug "Sent Initiate Deal: ".getHex($ID)."n", "sendPacket", 2;
  287. }
  289. sub sendDealAccept {
  290. my $msg = pack("C*", 0xE6, 0x00, 0x03);
  291. $_[0]->sendToServer($msg);
  292. debug "Sent Accept Dealn", "sendPacket", 2;
  293. }
  295. sub sendDealAddItem {
  296. my ($self, $index, $amount) = @_;
  297. my $msg = pack("C*", 0xE8, 0x00) . pack("v*", $index) . pack("V*",$amount);
  298. $_[0]->sendToServer($msg);
  299. debug "Sent Deal Add Item: $index, $amountn", "sendPacket", 2;
  300. }
  302. sub sendDealCancel {
  303. my $msg = pack("C*", 0xE6, 0x00, 0x04);
  304. $_[0]->sendToServer($msg);
  305. debug "Sent Cancel Dealn", "sendPacket", 2;
  306. }
  308. sub sendDealFinalize {
  309. my $msg = pack("C*", 0xEB, 0x00);
  310. $_[0]->sendToServer($msg);
  311. debug "Sent Deal OKn", "sendPacket", 2;
  312. }
  314. sub sendDealOK {
  315. my $msg = pack("C*", 0xEB, 0x00);
  316. $_[0]->sendToServer($msg);
  317. debug "Sent Deal OKn", "sendPacket", 2;
  318. }
  320. sub sendDealTrade {
  321. my $msg = pack("C*", 0xEF, 0x00);
  322. $_[0]->sendToServer($msg);
  323. debug "Sent Deal Traden", "sendPacket", 2;
  324. }
  326. sub sendDrop {
  327. my ($self, $index, $amount) = @_;
  328. my $msg;
  330. $msg = pack("C*", 0xA2, 0x00) . pack("v*", $index, $amount);
  332. $self->sendToServer($msg);
  333. debug "Sent drop: $index x $amountn", "sendPacket", 2;
  334. }
  336. sub sendEmotion {
  337. my ($self, $ID) = @_;
  338. my $msg = pack("C*", 0xBF, 0x00).pack("C1",$ID);
  339. $self->sendToServer($msg);
  340. debug "Sent Emotionn", "sendPacket", 2;
  341. }
  343. sub sendEnteringVender {
  344. my ($self, $ID) = @_;
  345. my $msg = pack("C*", 0x30, 0x01) . $ID;
  346. $self->sendToServer($msg);
  347. debug "Sent Entering Vender: ".getHex($ID)."n", "sendPacket", 2;
  348. }
  350. sub sendEquip {
  351. my ($self, $index, $type) = @_;
  352. my $msg = pack("C*", 0xA9, 0x00) . pack("v*", $index) .  pack("v*", $type);
  353. $self->sendToServer($msg);
  354. debug "Sent Equip: $index Type: $typen" , 2;
  355. }
  357. sub sendFriendAccept {
  358. my ($self, $accountID, $charID) = @_;
  359. my $msg = pack("C*", 0x08, 0x02) . $accountID . $charID . pack("C*", 0x01, 0x00, 0x00, 0x00);
  360. $self->sendToServer($msg);
  361. debug "Sent Accept friend requestn", "sendPacket";
  362. }
  364. sub sendFriendReject {
  365. my ($self, $accountID, $charID) = @_;
  366. my $msg = pack("C*", 0x08, 0x02) . $accountID . $charID . pack("C*", 0x00, 0x00, 0x00, 0x00);
  367. $self->sendToServer($msg);
  368. debug "Sent Reject friend requestn", "sendPacket";
  369. }
  371. sub sendFriendRequest {
  372. my ($self, $name) = @_;
  374. my $binName = stringToBytes($name);
  375. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  376. $binName = $binName . chr(0) x (24 - length($binName));
  377. my $msg = pack("C*", 0x02, 0x02) . $binName;
  379. $self->sendToServer($msg);
  380. debug "Sent Request to be a friend: $namen", "sendPacket";
  381. }
  383. sub sendFriendRemove {
  384. my ($self, $accountID, $charID) = @_;
  385. my $msg = pack("C*", 0x03, 0x02) . $accountID . $charID;
  386. $self->sendToServer($msg);
  387. debug "Sent Remove a friendn", "sendPacket";
  388. }
  390. sub sendForgeItem {
  391. my ($self, $ID,
  392. # nameIDs for added items such as Star Crumb or Flame Heart
  393. $item1, $item2, $item3) = @_;
  395. my $msg = pack("C*", 0x8E, 0x01) . pack("v1 v1 v1 v1", $ID, $item1, $item2, $item3);
  396. $self->sendToServer($msg);
  397. debug "Sent Forge Item: $IDn" , 2;
  398. }
  400. sub sendGameLogin {
  401. my ($self, $accountID, $sessionID, $sessionID2, $sex) = @_;
  402. my $msg = pack("v1", hex($masterServer->{gameLogin_packet}) || 0x65) . $accountID . $sessionID . $sessionID2 . pack("C*", 0, 0, $sex);
  403. if (hex($masterServer->{gameLogin_packet}) == 0x0273 || hex($masterServer->{gameLogin_packet}) == 0x0275) {
  404. my ($serv) = $masterServer->{ip} =~ /d+.d+.d+.(d+)/;
  405. $msg .= pack("x16 C1 x3", $serv);
  406. }
  407. $self->sendToServer($msg);
  408. debug "Sent sendGameLoginn", "sendPacket", 2;
  409. }
  411. sub sendGetCharacterName {
  412. my ($self, $ID) = @_;
  413. my $msg = pack("C*", 0x93, 0x01) . $ID;
  414. $self->sendToServer($msg);
  415. debug "Sent get character name: ID - ".getHex($ID)."n", "sendPacket", 2;
  416. }
  418. sub sendGetPlayerInfo {
  419. my ($self, $ID) = @_;
  420. my $msg;
  421. $msg = pack("C*", 0x94, 0x00) . $ID;
  422. $self->sendToServer($msg);
  423. debug "Sent get player info: ID - ".getHex($ID)."n", "sendPacket", 2;
  424. }
  426. sub sendGetStoreList {
  427. my ($self, $ID) = @_;
  428. my $msg = pack("C*", 0xC5, 0x00) . $ID . pack("C*",0x00);
  429. $self->sendToServer($msg);
  430. debug "Sent get store list: ".getHex($ID)."n", "sendPacket", 2;
  431. }
  433. sub sendGetSellList {
  434. my ($self, $ID) = @_;
  435. my $msg = pack("C*", 0xC5, 0x00) . $ID . pack("C*",0x01);
  436. $self->sendToServer($msg);
  437. debug "Sent sell to NPC: ".getHex($ID)."n", "sendPacket", 2;
  438. }
  440. sub sendGmSummon {
  441. my ($self, $playerName) = @_;
  442. my $packet = pack("C*", 0xBD, 0x01) . pack("a24", stringToBytes($playerName));
  443. $self->sendToServer($packet);
  444. }
  446. sub sendGuildAlly {
  447. my ($self, $ID, $flag) = @_;
  448. my $msg = pack("C*", 0x72, 0x01).$ID.pack("V1", $flag);
  449. $self->sendToServer($msg);
  450. debug "Sent Ally Guild : ".getHex($ID).", $flagn", "sendPacket", 2;
  451. }
  453. sub sendGuildBreak {
  454. my ($self, $guildName) = @_;
  455. my $msg = pack("C C a40", 0x5D, 0x01, stringToBytes($guildName));
  456. $self->sendToServer($msg);
  457. debug "Sent Guild Break: $guildNamen", "sendPacket", 2;
  458. }
  460. sub sendGuildChat {
  461. my ($self, $message) = @_;
  463. my ($charName);
  464. $message = "|00$message" if ($config{chatLangCode} && $config{chatLangCode} ne "none");
  465. $message = stringToBytes($message);
  466. $charName = stringToBytes($char->{name});
  468. my $data = pack("C*",0x7E, 0x01) .
  469. pack("v*", length($charName) + length($message) + 8) .
  470. $charName . " : " . $message . chr(0);
  471. $self->sendToServer($data);
  472. }
  474. sub sendGuildCreate {
  475. my ($self, $name) = @_;
  476. my $msg = pack("C*", 0x65, 0x01, 0x4D, 0x8B, 0x01, 0x00) .
  477. pack("a24", stringToBytes($name));
  478. $self->sendToServer($msg);
  479. debug "Sent Guild Create: $namen", "sendPacket", 2;
  480. }
  482. sub sendGuildInfoRequest {
  483. my $self = shift;
  484. my $msg = pack("C*", 0x4d, 0x01);
  485. $self->sendToServer($msg);
  486. debug "Sent Guild Information Requestn", "sendPacket";
  487. }
  489. sub sendGuildJoin {
  490. my ($self, $ID, $flag) = @_;
  491. my $msg = pack("C*", 0x6B, 0x01).$ID.pack("V1", $flag);
  492. $self->sendToServer($msg);
  493. debug "Sent Join Guild : ".getHex($ID).", $flagn", "sendPacket";
  494. }
  496. sub sendGuildJoinRequest {
  497. my ($self, $ID) = @_;
  498. my $msg = pack("C*", 0x68, 0x01).$ID.$accountID.$charID;
  499. $self->sendToServer($msg);
  500. debug "Sent Request Join Guild: ".getHex($ID)."n", "sendPacket";
  501. }
  503. sub sendGuildLeave {
  504. my ($self, $reason) = @_;
  505. my $mess = pack("Z40", stringToBytes($reason));
  506. my $msg = pack("C*", 0x59, 0x01).$guild{ID}.$accountID.$charID.$mess;
  507. $self->sendToServer($msg);
  508. debug "Sent Guild Leave: $reason (".getHex($msg).")n", "sendPacket";
  509. }
  511. sub sendGuildMemberKick {
  512. my ($self, $guildID, $accountID, $charID, $cause) = @_;
  513. my $msg = pack("C*", 0x5B, 0x01).$guildID.$accountID.$charID.pack("a40", stringToBytes($cause));
  514. $self->sendToServer($msg);
  515. debug "Sent Guild Kick: ".getHex($charID)."n", "sendPacket";
  516. }
  518. sub sendGuildMemberTitleSelect {
  519. # set the title for a member
  520. my ($self, $accountID, $charID, $index) = @_;
  522. my $msg = pack("C*", 0x55, 0x01).pack("v1",16).$accountID.$charID.pack("V1",$index);
  523. $self->sendToServer($msg);
  524. debug "Sent Change Guild title: ".getHex($charID)." $indexn", "sendPacket", 2;
  525. }
  527. sub sendGuildNotice {
  528. # sets the notice/announcement for the guild
  529. my ($self, $guildID, $name, $notice) = @_;
  530. my $msg = pack("C*", 0x6E, 0x01) . $guildID .
  531. pack("a60 a120", stringToBytes($name), stringToBytes($notice));
  532. $self->sendToServer($msg);
  533. debug "Sent Change Guild Notice: $noticen", "sendPacket", 2;
  534. }
  536. sub sendGuildRankChange {
  537. # change the title for a certain index
  538. # i would  guess 0 is the top rank, but i dont know
  539. my ($self, $index, $permissions, $tax, $title) = @_;
  541. my $msg = pack("C*", 0x61, 0x01) .
  542. pack("v1", 44) . # packet length, we can actually send multiple titles in the same packet if we wanted to
  543. pack("V1", $index) . # index of this rank in the list
  544. pack("V1", $permissions) . # this is their abilities, not sure what format
  545. pack("V1", $index) . # isnt even used on emulators, but leave in case Aegis wants this
  546. pack("V1", $tax) . # guild tax amount, not sure what format
  547. pack("a24", $title);
  548. $self->sendToServer($msg);
  549. debug "Sent Set Guild title: $index $titlen", "sendPacket", 2;
  550. }
  552. sub sendGuildRequest {
  553. my ($self, $page) = @_;
  554. my $msg = pack("C*", 0x4f, 0x01).pack("V1", $page);
  555. $self->sendToServer($msg);
  556. debug "Sent Guild Request Page : ".$page."n", "sendPacket";
  557. }
  559. sub sendGuildSetAlly {
  560. # this packet is for guildmaster asking to set alliance with another guildmaster
  561. # the other sub for sendGuildAlly are responses to this sub
  562. # kept the parameters open, but everything except $targetAID could be replaced with Global variables
  563. # unless you plan to mess around with the alliance packet, no exploits though, I tried ;-)
  564. # -zdivpsa
  565. my ($self, $targetAID, $myAID, $charID) = @_; # remote socket, $net
  566. my $msg = pack("C*", 0x70, 0x01) .
  567. $targetAID .
  568. $myAID .
  569. $charID;
  570. $self->sendToServer($msg);
  572. }
  574. sub sendHomunculusFeed {
  575. my $self = shift;
  576. my $msg = pack("C*", 0x2D, 0x02, 0x00, 0x00, 0x01);
  577. $self->sendToServer($msg);
  578. debug "Sent Feed Homunculusn", "sendPacket", 2;
  579. }
  581. sub sendHomunculusGetStats {
  582. my $self = shift;
  583. my $msg = pack("C*", 0x2D, 0x02, 0x00, 0x00, 0x00);
  584. $self->sendToServer($msg);
  585. debug "Sent Get Homunculus Statsn", "sendPacket", 2;
  586. }
  588. sub sendHomunculusMove {
  589. my $self = shift;
  590. my $homunID = shift;
  591. my $x = int scalar shift;
  592. my $y = int scalar shift;
  593. my $msg = pack("C*", 0x32, 0x02) . $homunID . getCoordString($x, $y);
  594. $self->sendToServer($msg);
  595. debug "Sent Homunculus move to: $x, $yn", "sendPacket", 2;
  596. }
  598. sub sendHomunculusAttack {
  599. my $self = shift;
  600. my $homunID = shift;
  601. my $targetID = shift;
  602. my $flag = shift;
  603. my $msg = pack("C*", 0x33, 0x02) . $homunID . $targetID . pack("C1", $flag);
  604. $self->sendToServer($msg);
  605. debug "Sent Homunculus attack: ".getHex($targetID)."n", "sendPacket", 2;
  606. }
  608. sub sendHomunculusStandBy {
  609. my $self = shift;
  610. my $homunID = shift;
  611. my $msg = pack("C*", 0x34, 0x02) . $homunID;
  612. $self->sendToServer($msg);
  613. debug "Sent Homunculus standbyn", "sendPacket", 2;
  614. }
  616. sub sendHomunculusName {
  617. my $self = shift;
  618. my $name = shift;
  619. my $msg = pack("v1 a24", 0x0231, stringToBytes($name));
  620. $self->sendToServer($msg);
  621. debug "Sent Homunculus Rename: $namen", "sendPacket", 2;
  622. }
  624. sub sendIdentify {
  625. my $self = shift;
  626. my $index = shift;
  627. my $msg = pack("C*", 0x78, 0x01) . pack("v*", $index);
  628. $self->sendToServer($msg);
  629. debug "Sent Identify: $indexn", "sendPacket", 2;
  630. }
  632. sub sendIgnore {
  633. my $self = shift;
  634. my $name = shift;
  635. my $flag = shift;
  637. my $binName = stringToBytes($name);
  638. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  639. $binName = $binName . chr(0) x (24 - length($binName));
  640. my $msg = pack("C*", 0xCF, 0x00) . $binName . pack("C*", $flag);
  642. $self->sendToServer($msg);
  643. debug "Sent Ignore: $name, $flagn", "sendPacket", 2;
  644. }
  646. sub sendIgnoreAll {
  647. my $self = shift;
  648. my $flag = shift;
  649. my $msg = pack("C*", 0xD0, 0x00).pack("C*", $flag);
  650. $self->sendToServer($msg);
  651. debug "Sent Ignore All: $flagn", "sendPacket", 2;
  652. }
  654. sub sendIgnoreListGet {
  655. my $self = shift;
  656. my $flag = shift;
  657. my $msg = pack("C*", 0xD3, 0x00);
  658. $self->sendToServer($msg);
  659. debug "Sent get Ignore List: $flagn", "sendPacket", 2;
  660. }
  662. sub sendItemUse {
  663. my ($self, $ID, $targetID) = @_;
  664. my $msg;
  666. $msg = pack("C*", 0xA7, 0x00).pack("v*",$ID) .
  667. $targetID;
  669. $self->sendToServer($msg);
  670. debug "Item Use: $IDn", "sendPacket", 2;
  671. }
  673. sub sendLook {
  674. my ($self, $body, $head) = @_;
  675. my $msg;
  676. $msg = pack("C*", 0x9B, 0x00, $head, 0x00, $body);
  677. $self->sendToServer($msg);
  678. debug "Sent look: $body $headn", "sendPacket", 2;
  679. $char->{look}{head} = $head;
  680. $char->{look}{body} = $body;
  681. }
  683. sub sendMapLoaded {
  684. my $self = shift;
  685. my $msg;
  686. $syncSync = pack("V", getTickCount());
  687. $msg = pack("C*", 0x7D,0x00);
  688. debug "Sending Map Loadedn", "sendPacket";
  689. $self->sendToServer($msg);
  690. Plugins::callHook('packet/sendMapLoaded');
  691. }
  693. sub sendMapLogin {
  694. my ($self, $accountID, $charID, $sessionID, $sex) = @_;
  695. my $msg;
  696. $sex = 0 if ($sex > 1 || $sex < 0); # Sex can only be 0 (female) or 1 (male)
  698. if ($self->{serverType} == 0 || $self->{serverType} == 21 || $self->{serverType} == 22) {
  699. # Server Type 21 is tRO (2008-09-16Ragexe12_Th), 22 is idRO
  700. $msg = pack("C*", 0x72,0) .
  701. $accountID .
  702. $charID .
  703. $sessionID .
  704. pack("V1", getTickCount()) .
  705. pack("C*",$sex);
  707. } else { #oRO and pRO
  708. my $key;
  710. $key = pack("C*", 0xFA, 0x12, 0, 0x50, 0x83);
  711. $msg = pack("C*", 0x72, 0, 0, 0, 0) .
  712. $accountID .
  713. $key .
  714. $charID .
  715. pack("C*", 0xFF, 0xFF) .
  716. $sessionID .
  717. pack("V", getTickCount()) .
  718. pack("C", $sex);
  719. }
  721. $self->sendToServer($msg);
  722. }
  724. sub sendMasterCodeRequest {
  725. my $self = shift;
  726. my $type = shift;
  727. my $code = shift;
  728. my $msg;
  730. if ($type eq 'code') {
  731. $msg = '';
  732. foreach (split(/ /, $code)) {
  733. $msg .= pack("C1",hex($_));
  734. }
  736. } else { # type eq 'type'
  737. if ($code == 1) {
  738. $msg = pack("C*", 0x04, 0x02, 0x7B, 0x8A, 0xA8, 0x90, 0x2F, 0xD8, 0xE8, 0x30, 0xF8, 0xA5, 0x25, 0x7A, 0x0D, 0x3B, 0xCE, 0x52);
  739. } elsif ($code == 2) {
  740. $msg = pack("C*", 0x04, 0x02, 0x27, 0x6A, 0x2C, 0xCE, 0xAF, 0x88, 0x01, 0x87, 0xCB, 0xB1, 0xFC, 0xD5, 0x90, 0xC4, 0xED, 0xD2);
  741. } elsif ($code == 3) {
  742. $msg = pack("C*", 0x04, 0x02, 0x42, 0x00, 0xB0, 0xCA, 0x10, 0x49, 0x3D, 0x89, 0x49, 0x42, 0x82, 0x57, 0xB1, 0x68, 0x5B, 0x85);
  743. } elsif ($code == 4) {
  744. $msg = pack("C*", 0x04, 0x02, 0x22, 0x37, 0xD7, 0xFC, 0x8E, 0x9B, 0x05, 0x79, 0x60, 0xAE, 0x02, 0x33, 0x6D, 0x0D, 0x82, 0xC6);
  745. } elsif ($code == 5) {
  746. $msg = pack("C*", 0x04, 0x02, 0xc7, 0x0A, 0x94, 0xC2, 0x7A, 0xCC, 0x38, 0x9A, 0x47, 0xF5, 0x54, 0x39, 0x7C, 0xA4, 0xD0, 0x39);
  747. }
  748. }
  749. $msg .= pack("C*", 0xDB, 0x01);
  750. $self->sendToServer($msg);
  751. }
  753. sub sendMasterLogin {
  754. my ($self, $username, $password, $master_version, $version) = @_;
  755. my $msg;
  757. if ($self->{serverType} == 4) {
  758. # This is used on the RuRO private server.
  759. # A lot of packets are different so I gave up,
  760. # but I'll keep this code around in case anyone ever needs it.
  762. # I'm not sure if serverType 4 actually needs this whacko login
  764. $username = substr($username, 0, 23) if (length($username) > 23);
  765. $password = substr($password, 0, 23) if (length($password) > 23);
  767. my $tmp = pack("C*", 0x0D, 0xF0, 0xAD, 0xBA) x 6;
  768. substr($tmp, 0, length($username) + 1, $username . chr(0));
  769. $username = $tmp;
  771. $tmp = (pack("C*", 0x0D, 0xF0, 0xAD, 0xBA) x 3) .
  772. pack("C*", 0x00, 0xD0, 0xC2, 0xCF, 0xA2, 0xF9, 0xCA, 0xDF, 0x0E, 0xA6, 0xF1, 0x41);
  773. substr($tmp, 0, length($password) + 1, $password . chr(0));
  774. $password = $tmp;
  776. $msg = pack("v1 V", hex($masterServer->{masterLogin_packet}) || 0x64, $version) .
  777. $username . $password .
  778. pack("C*", $master_version);
  780. } else {
  781. $msg = pack("v1 V", hex($masterServer->{masterLogin_packet}) || 0x64, $version) .
  782. pack("a24", $username) .
  783. pack("a24", $password) .
  784. pack("C*", $master_version);
  785. }
  786. $self->sendToServer($msg);
  787. }
  789. sub sendMasterSecureLogin {
  790. my $self = shift;
  791. my $username = shift;
  792. my $password = shift;
  793. my $salt = shift;
  794. my $version = shift;
  795. my $master_version = shift;
  796. my $type =  shift;
  797. my $account = shift;
  798. my $md5 = Digest::MD5->new;
  799. my ($msg);
  801. $username = stringToBytes($username);
  802. $password = stringToBytes($password);
  803. if ($type % 2 == 1) {
  804. $salt = $salt . $password;
  805. } else {
  806. $salt = $password . $salt;
  807. }
  808. $md5->add($salt);
  809. if ($type < 3 ) {
  810. $msg = pack("C*", 0xDD, 0x01) . pack("V1", $version) . pack("a24", $username) .
  811.  $md5->digest . pack("C*", $master_version);
  812. }else{
  813. $account = ($account>0) ? $account -1 : 0;
  814. $msg = pack("C*", 0xFA, 0x01) . pack("V1", $version) . pack("a24", $username) .
  815.  $md5->digest . pack("C*", $master_version). pack("C1", $account);
  816. }
  817. $self->sendToServer($msg);
  818. }
  820. sub sendMemo {
  821. my $self = shift;
  822. my $msg = pack("C*", 0x1D, 0x01);
  823. $self->sendToServer($msg);
  824. debug "Sent Memon", "sendPacket", 2;
  825. }
  827. sub sendMercenaryCommand {
  828. my ($self, $command) = @_;
  830. # 0x0 => COMMAND_REQ_NONE
  831. # 0x1 => COMMAND_REQ_PROPERTY
  832. # 0x2 => COMMAND_REQ_DELETE
  834. my $msg = pack ('v1 C1', 0x029F, $command);
  835. $self->sendToServer ($msg);
  836. debug "Sent MercenaryCommand", "sendPacket", 2;
  837. }
  839. sub sendMove {
  840. my $self = shift;
  841. my $x = int scalar shift;
  842. my $y = int scalar shift;
  843. my $msg;
  845. $msg = pack("C*", 0x85, 0x00) . getCoordString($x, $y);
  847. $self->sendToServer($msg);
  848. debug "Sent move to: $x, $yn", "sendPacket", 2;
  849. }
  851. sub sendOpenShop {
  852. my ($self, $title, $items) = @_;
  854. my $length = 0x55 + 0x08 * @{$items};
  855. my $msg = pack("C*", 0xB2, 0x01).
  856. pack("v*", $length).
  857. pack("a80", stringToBytes($title)).
  858. pack("C*", 0x01);
  860. foreach my $item (@{$items}) {
  861. $msg .= pack("v1", $item->{index}).
  862. pack("v1", $item->{amount}).
  863. pack("V1", $item->{price});
  864. }
  866. $self->sendToServer($msg);
  867. }
  869. sub sendOpenWarp {
  870. my ($self, $map) = @_;
  871. my $msg = pack("C*", 0x1b, 0x01, 0x1b, 0x00) . $map .
  872. chr(0) x (16 - length($map));
  873. $self->sendToServer($msg);
  874. }
  876. sub sendPartyChat {
  877. my $self = shift;
  878. my $message = shift;
  880. my $charName;
  881. $message = "|00$message" if ($config{chatLangCode} && $config{chatLangCode} ne "none");
  882. $message = stringToBytes($message);
  883. $charName = stringToBytes($char->{name});
  885. my $msg = pack("C*",0x08, 0x01) . pack("v*", length($charName) + length($message) + 8) .
  886. $charName . " : " . $message . chr(0);
  887. $self->sendToServer($msg);
  888. }
  890. sub sendPartyJoin {
  891. my $self = shift;
  892. my $ID = shift;
  893. my $flag = shift;
  894. my $msg = pack("C*", 0xFF, 0x00).$ID.pack("V", $flag);
  895. $self->sendToServer($msg);
  896. debug "Sent Join Party: ".getHex($ID).", $flagn", "sendPacket", 2;
  897. }
  899. sub sendPartyJoinRequest {
  900. my $self = shift;
  901. my $ID = shift;
  902. my $msg = pack("C*", 0xFC, 0x00).$ID;
  903. $self->sendToServer($msg);
  904. debug "Sent Request Join Party: ".getHex($ID)."n", "sendPacket", 2;
  905. }
  907. sub sendPartyKick {
  908. my $self = shift;
  909. my $ID = shift;
  910. my $name = shift;
  912. my $binName = stringToBytes($name);
  913. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  914. $binName .= chr(0) x (24 - length($binName));
  915. my $msg = pack("C*", 0x03, 0x01) . $ID . $binName;
  916. $self->sendToServer($msg);
  917. debug "Sent Kick Party: ".getHex($ID).", $namen", "sendPacket", 2;
  918. }
  920. sub sendPartyLeave {
  921. my $self = shift;
  922. my $msg = pack("C*", 0x00, 0x01);
  923. $self->sendToServer($msg);
  924. debug "Sent Leave Partyn", "sendPacket", 2;
  925. }
  927. sub sendPartyOrganize {
  928. my $self = shift;
  929. my $name = shift;
  930. my $share1 = shift || 1;
  931. my $share2 = shift || 1;
  933. my $binName = stringToBytes($name);
  934. $binName = substr($binName, 0, 24) if (length($binName) > 24);
  935. $binName .= chr(0) x (24 - length($binName));
  936. #my $msg = pack("C*", 0xF9, 0x00) . $binName;
  937. # I think this is obsolete - which serverTypes still support this packet anyway?
  938. # FIXME: what are shared with $share1 and $share2? experience? item? vice-versa?
  940. my $msg = pack("C*", 0xE8, 0x01) . $binName . pack("C*", $share1, $share2);
  942. $self->sendToServer($msg);
  943. debug "Sent Organize Party: $namen", "sendPacket", 2;
  944. }
  946. sub sendPartyShareEXP {
  947. my $self = shift;
  948. my $flag = shift;
  949. my $msg = pack("C*", 0x02, 0x01).pack("V", $flag);
  950. $self->sendToServer($msg);
  951. debug "Sent Party Share: $flagn", "sendPacket", 2;
  952. }
  954. sub sendPetCapture {
  955. my $self = shift;
  956. my $monID = shift;
  957. my $msg = pack("C*", 0x9F, 0x01) . $monID . pack("C*", 0x00, 0x00);
  958. $self->sendToServer($msg);
  959. debug "Sent pet capture: ".getHex($monID)."n", "sendPacket", 2;
  960. }
  962. sub sendPetFeed {
  963. my $self = shift;
  964. my $msg = pack("C*", 0xA1, 0x01, 0x01);
  965. $self->sendToServer($msg);
  966. debug "Sent Pet Feedn", "sendPacket", 2;
  967. }
  969. sub sendPetGetInfo {
  970. my $self = shift;
  971. my $msg = pack("C*", 0xA1, 0x01, 0x00);
  972. $self->sendToServer($msg);
  973. debug "Sent Pet Get Infon", "sendPacket", 2;
  974. }
  976. sub sendPetHatch {
  977. my $self = shift;
  978. my $index = shift;
  979. my $msg = pack("C*", 0xA7, 0x01) . pack("v1", $index);
  980. $self->sendToServer($msg);
  981. debug "Sent Incubator hatch: $indexn", "sendPacket", 2;
  982. }
  984. sub sendPetName {
  985. my $self = shift;
  986. my $name = shift;
  987. my $msg = pack("C1 C1 a24", 0xA5, 0x01, stringToBytes($name));
  988. $self->sendToServer($msg);
  989. debug "Sent Pet Rename: $namen", "sendPacket", 2;
  990. }
  992. sub sendPetPerformance {
  993. my $self = shift;
  994. my $msg = pack("C*", 0xA1, 0x01, 0x02);
  995. $self->sendToServer($msg);
  996. debug "Sent Pet Performancen", "sendPacket", 2;
  997. }
  999. sub sendPetReturnToEgg {
  1000. my $self = shift;
  1001. my $msg = pack("C*", 0xA1, 0x01, 0x03);
  1002. $self->sendToServer($msg);
  1003. debug "Sent Pet Return to Eggn", "sendPacket", 2;
  1004. }
  1006. sub sendPetUnequipItem {
  1007. my $self = shift;
  1008. my $msg = pack("C*", 0xA1, 0x01, 0x04);
  1009. $self->sendToServer($msg);
  1010. debug "Sent Pet Unequip Itemn", "sendPacket", 2;
  1011. }
  1013. sub sendPreLoginCode {
  1014. # no server actually needs this, but we might need it in the future?
  1015. my $self = shift;
  1016. my $type = shift;
  1017. my $msg;
  1018. if ($type == 1) {
  1019. $msg = pack("C*", 0x04, 0x02, 0x82, 0xD1, 0x2C, 0x91, 0x4F, 0x5A, 0xD4, 0x8F, 0xD9, 0x6F, 0xCF, 0x7E, 0xF4, 0xCC, 0x49, 0x2D);
  1020. }
  1021. $self->sendToServer($msg);
  1022. debug "Sent pre-login packet $typen", "sendPacket", 2;
  1023. }
  1025. sub sendPrivateMsg {
  1026. my ($self, $user, $message) = @_;
  1028. $message = "|00$message" if ($config{chatLangCode} && $config{chatLangCode} ne "none");
  1029. $message = stringToBytes($message);
  1030. $user = stringToBytes($user);
  1032. my $msg = pack("C*", 0x96, 0x00) . pack("v*", length($message) + 29) . $user .
  1033. chr(0) x (24 - length($user)) . $message . chr(0);
  1034. $self->sendToServer($msg);
  1035. }
  1037. sub sendQuit {
  1038. my $self = shift;
  1039. my $msg = pack("C*", 0x8A, 0x01, 0x00, 0x00);
  1040. $self->sendToServer($msg);
  1041. debug "Sent Quitn", "sendPacket", 2;
  1042. }
  1044. sub sendQuitToCharSelect {
  1045. my $msg = pack("C*", 0xB2, 0x00, 0x01);
  1046. $_[0]->sendToServer($msg);
  1047. debug "Sent Quit To Char Selectionn", "sendPacket", 2;
  1048. }
  1050. sub sendRaw {
  1051. my $self = shift;
  1052. my $raw = shift;
  1053. my @raw;
  1054. my $msg;
  1055. @raw = split / /, $raw;
  1056. foreach (@raw) {
  1057. $msg .= pack("C", hex($_));
  1058. }
  1059. $self->sendToServer($msg);
  1060. debug "Sent Raw Packet: @rawn", "sendPacket", 2;
  1061. }
  1063. sub sendRequestMakingHomunculus {
  1064. # WARNING: If you don't really know, what are you doing - don't touch this
  1065. my ($self, $make_homun) = @_;
  1067. my $skill = new Skill (idn => 241);
  1069. if (
  1070. Actor::Item::get (997) && Actor::Item::get (998) && Actor::Item::get (999)
  1071. && ($char->getSkillLevel ($skill) > 0)
  1072. ) {
  1073. my $msg = pack ('v1 C1', 0x01CA, $make_homun);
  1074. $self->sendToServer($msg);
  1075. debug "Sent RequestMakingHomunculusn", "sendPacket", 2;
  1076. }
  1077. }
  1079. sub sendRemoveAttachments {
  1080. # remove peco, falcon, cart
  1081. my $msg = pack("C*", 0x2A, 0x01);
  1082. $_[0]->sendToServer($msg);
  1083. debug "Sent remove attachmentsn", "sendPacket", 2;
  1084. }
  1086. sub sendRepairItem {
  1087. my ($self, $args) = @_;
  1088. my $msg = pack("C2 v2 V2 C1", 0xFD, 0x01, %{$args}->{index}, %{$args}->{nameID}, %{$args}->{status}, %{$args}->{status2}, %{$args}->{listID});
  1089. $self->sendToServer($msg);
  1090. debug ("Sent repair item: ".%{$args}->{index}."n", "sendPacket", 2);
  1091. }
  1093. sub sendRespawn {
  1094. my $self = shift;
  1095. my $msg = pack("C*", 0xB2, 0x00, 0x00);
  1096. $self->sendToServer($msg);
  1097. debug "Sent Respawnn", "sendPacket", 2;
  1098. }
  1100. sub sendSell {
  1101. my $self = shift;
  1102. my $index = shift;
  1103. my $amount = shift;
  1104. my $msg = pack("C*", 0xC9, 0x00, 0x08, 0x00) . pack("v*", $index, $amount);
  1105. $self->sendToServer($msg);
  1106. debug "Sent sell: $index x $amountn", "sendPacket", 2;
  1107. }
  1109. sub sendSellBulk {
  1110. my $self = shift;
  1111. my $r_array = shift;
  1112. my $sellMsg = "";
  1114. for (my $i = 0; $i < @{$r_array}; $i++) {
  1115. $sellMsg .= pack("v*", $r_array->[$i]{index}, $r_array->[$i]{amount});
  1116. debug "Sent bulk sell: $r_array->[$i]{index} x $r_array->[$i]{amount}n", "d_sendPacket", 2;
  1117. }
  1119. my $msg = pack("C*", 0xC9, 0x00) . pack("v*", length($sellMsg) + 4) . $sellMsg;
  1120. $self->sendToServer($msg);
  1121. }
  1123. sub sendSit {
  1124. my $self = shift;
  1125. my $msg;
  1127. $msg = pack("C*", 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02);
  1129. $self->sendToServer($msg);
  1130. debug "Sittingn", "sendPacket", 2;
  1131. }
  1133. sub sendSkillUse {
  1134. my ($self, $ID, $lv, $targetID) = @_;
  1135. my $msg;
  1137. $msg = pack("C*", 0x13, 0x01).pack("v*",$lv,$ID).$targetID;
  1139. $self->sendToServer($msg);
  1140. debug "Skill Use: $IDn", "sendPacket", 2;
  1141. }
  1143. sub sendSkillUseLoc {
  1144. my ($self, $ID, $lv, $x, $y) = @_;
  1145. my $msg;
  1147. $msg = pack("C*", 0x16, 0x01).pack("v*",$lv,$ID,$x,$y);
  1149. $self->sendToServer($msg);
  1150. debug "Skill Use on Location: $ID, ($x, $y)n", "sendPacket", 2;
  1151. }
  1153. sub sendStorageAdd {
  1154. my ($self, $index, $amount) = @_;
  1155. my $msg;
  1157. $msg = pack("C*", 0xF3, 0x00) . pack("v*", $index) . pack("V*", $amount);
  1159. $self->sendToServer($msg);
  1160. debug "Sent Storage Add: $index x $amountn", "sendPacket", 2;
  1161. }
  1163. sub sendStorageAddFromCart {
  1164. my $self = shift;
  1165. my $index = shift;
  1166. my $amount = shift;
  1167. my $msg;
  1168. $msg = pack("C*", 0x29, 0x01) . pack("v*", $index) . pack("V*", $amount);
  1169. $self->sendToServer($msg);
  1170. debug "Sent Storage Add From Cart: $index x $amountn", "sendPacket", 2;
  1171. }
  1173. sub sendStorageClose {
  1174. my ($self) = @_;
  1175. my $msg;
  1176. if (($self->{serverType} == 3) || ($self->{serverType} == 5) || ($self->{serverType} == 9) || ($self->{serverType} == 15)) {
  1177. $msg = pack("C*", 0x93, 0x01);
  1178. } elsif ($self->{serverType} == 12) {
  1179. $msg = pack("C*", 0x72, 0x00);
  1180. } elsif ($self->{serverType} == 14) {
  1181. $msg = pack("C*", 0x16, 0x01);
  1182. } else {
  1183. $msg = pack("C*", 0xF7, 0x00);
  1184. }
  1186. $self->sendToServer($msg);
  1187. debug "Sent Storage Donen", "sendPacket", 2;
  1188. }
  1190. sub sendStorageGet {
  1191. my ($self, $index, $amount) = @_;
  1192. my $msg;
  1194. $msg = pack("C*", 0xF5, 0x00) . pack("v*", $index) . pack("V*", $amount);
  1196. $self->sendToServer($msg);
  1197. debug "Sent Storage Get: $index x $amountn", "sendPacket", 2;
  1198. }
  1200. sub sendStorageGetToCart {
  1201. my $self = shift;
  1202. my $index = shift;
  1203. my $amount = shift;
  1204. my $msg;
  1205. $msg = pack("C*", 0x28, 0x01) . pack("v*", $index) . pack("V*", $amount);
  1206. $self->sendToServer($msg);
  1207. debug "Sent Storage Get From Cart: $index x $amountn", "sendPacket", 2;
  1208. }
  1210. sub sendStoragePassword {
  1211. my $self = shift;
  1212. # 16 byte packed hex data
  1213. my $pass = shift;
  1214. # 2 = set password ?
  1215. # 3 = give password ?
  1216. my $type = shift;
  1217. my $msg;
  1218. if ($type == 3) {
  1219. $msg = pack("C C v", 0x3B, 0x02, $type).$pass.pack("H*", "EC62E539BB6BBC811A60C06FACCB7EC8");
  1220. } elsif ($type == 2) {
  1221. $msg = pack("C C v", 0x3B, 0x02, $type).pack("H*", "EC62E539BB6BBC811A60C06FACCB7EC8").$pass;
  1222. } else {
  1223. ArgumentException->throw("The 'type' argument has invalid value ($type).");
  1224. }
  1225. $self->sendToServer($msg);
  1226. }
  1228. sub sendLoginPinCode {
  1229. my $self = shift;
  1230. # String's with PIN codes
  1231. my $pin1 = shift;
  1232. my $pin2 = shift;
  1233.         # Actually the Key
  1234. my $key_v = shift;
  1235. # 2 = set password
  1236. # 3 = enter password
  1237. my $type = shift;
  1238. my $encryptionKey = shift;
  1240. my $msg;
  1241. if ($pin1 !~ /^d*$/) {
  1242. ArgumentException->throw("PIN code 1 must contain only digits.");
  1243. }
  1244. if ($type == 2 && $pin2 !~ /^d*$/) {
  1245. ArgumentException->throw("PIN code 2 must contain only digits.");
  1246. }
  1247. if (!$encryptionKey) {
  1248. ArgumentException->throw("No encryption key given.");
  1249. }
  1251. my $crypton = new Utils::Crypton(pack("V*", @{$encryptionKey}), 32);
  1252. my $num1 = pin_encode($pin1, $key_v);
  1253. my $num2 = pin_encode($pin2, $key_v);
  1254. if ($type == 2) {
  1255. if ((length($pin1) > 3) && (length($pin1) < 9) && (length($pin2) > 3) && (length($pin2) < 9)) {
  1256. my $ciphertextblock1 = $crypton->encrypt(pack("V*", $num1, 0, 0, 0)); 
  1257. my $ciphertextblock2 = $crypton->encrypt(pack("V*", $num2, 0, 0, 0));
  1258. $msg = pack("C C v", 0x3B, 0x02, $type).$ciphertextblock1.$ciphertextblock2;
  1259. $self->sendToServer($msg);
  1260. } else {
  1261. ArgumentException->throw("Both PIN codes must be more than 3 and less than 9 characters long.");
  1262. }
  1263. } elsif ($type == 3) {
  1264. if ((length($pin1) > 3) && (length($pin1) < 9)) {
  1265. my $ciphertextblock1 = $crypton->encrypt(pack("V*", $num1, 0, 0, 0)); 
  1266. my $ciphertextblock2 = $crypton->encrypt(pack("V*", 0, 0, 0, 0)); 
  1267. $msg = pack("C C v", 0x3B, 0x02, $type).$ciphertextblock1.$ciphertextblock2;
  1268. $self->sendToServer($msg);
  1269. } else {
  1270. ArgumentException->throw("PIN code 1 must be more than 3 and less than 9 characters long.");
  1271. }
  1272. } else {
  1273. ArgumentException->throw("The 'type' argument has invalid value ($type).");
  1274. }
  1275. }
  1277. sub sendStand {
  1278. my $self = shift;
  1279. my $msg;
  1281. $msg = pack("C*", 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03);
  1283. $self->sendToServer($msg);
  1284. debug "Standingn", "sendPacket", 2;
  1285. }
  1287. sub sendSuperNoviceDoriDori {
  1288. my $msg = pack("C*", 0xE7, 0x01);
  1289. $_[0]->sendToServer($msg);
  1290. debug "Sent Super Novice dori dorin", "sendPacket", 2;
  1291. }
  1293. sub sendSuperNoviceExplosion {
  1294. my $msg = pack("C*", 0xED, 0x01);
  1295. $_[0]->sendToServer($msg);
  1296. debug "Sent Super Novice Explosionn", "sendPacket", 2;
  1297. }
  1299. sub sendSync {
  1300. my ($self, $initialSync) = @_;
  1301. my $msg;
  1302. # XKore mode 1 lets the client take care of syncing.
  1303. return if ($self->{net}->version == 1);
  1305. $syncSync = pack("V", getTickCount());
  1306. $msg = pack("C*", 0x7E, 0x00) . $syncSync;
  1308. $self->sendToServer($msg);
  1309. debug "Sent Syncn", "sendPacket", 2;
  1310. }
  1312. sub sendTake {
  1313. my ($self, $itemID) = @_;
  1314. my $msg;
  1315. $msg = pack("C*", 0x9F, 0x00) . $itemID;
  1316. $self->sendToServer($msg);
  1317. debug "Sent taken", "sendPacket", 2;
  1318. }
  1320. sub sendTalk {
  1321. my $self = shift;
  1322. my $ID = shift;
  1323. my $msg = pack("C*", 0x90, 0x00) . $ID . pack("C*",0x01);
  1324. $self->sendToServer($msg);
  1325. debug "Sent talk: ".getHex($ID)."n", "sendPacket", 2;
  1326. }
  1328. sub sendTalkCancel {
  1329. my $self = shift;
  1330. my $ID = shift;
  1331. my $msg = pack("C*", 0x46, 0x01) . $ID;
  1332. $self->sendToServer($msg);
  1333. debug "Sent talk cancel: ".getHex($ID)."n", "sendPacket", 2;
  1334. }
  1336. sub sendTalkContinue {
  1337. my $self = shift;
  1338. my $ID = shift;
  1339. my $msg = pack("C*", 0xB9, 0x00) . $ID;
  1340. $self->sendToServer($msg);
  1341. debug "Sent talk continue: ".getHex($ID)."n", "sendPacket", 2;
  1342. }
  1344. sub sendTalkResponse {
  1345. my $self = shift;
  1346. my $ID = shift;
  1347. my $response = shift;
  1348. my $msg = pack("C*", 0xB8, 0x00) . $ID. pack("C1",$response);
  1349. $self->sendToServer($msg);
  1350. debug "Sent talk respond: ".getHex($ID).", $responsen", "sendPacket", 2;
  1351. }
  1353. sub sendTalkNumber {
  1354. my $self = shift;
  1355. my $ID = shift;
  1356. my $number = shift;
  1357. my $msg = pack("C*", 0x43, 0x01) . $ID .
  1358. pack("V1", $number);
  1359. $self->sendToServer($msg);
  1360. debug "Sent talk number: ".getHex($ID).", $numbern", "sendPacket", 2;
  1361. }
  1363. sub sendTalkText {
  1364. my $self = shift;
  1365. my $ID = shift;
  1366. my $input = stringToBytes(shift);
  1367. my $msg = pack("C*", 0xD5, 0x01) . pack("v*", length($input)+length($ID)+5) . $ID . $input . chr(0);
  1368. $self->sendToServer($msg);
  1369. debug "Sent talk text: ".getHex($ID).", $inputn", "sendPacket", 2;
  1370. }
  1372. sub sendTeleport {
  1373. my $self = shift;
  1374. my $location = shift;
  1375. $location = substr($location, 0, 16) if (length($location) > 16);
  1376. $location .= chr(0) x (16 - length($location));
  1377. my $msg = pack("C*", 0x1B, 0x01, 0x1A, 0x00) . $location;
  1378. $self->sendToServer($msg);
  1379. debug "Sent Teleport: $locationn", "sendPacket", 2;
  1380. }
  1382. sub sendTop10Alchemist {
  1383. my $self = shift;
  1384. my $msg = pack("C*", 0x18, 0x02);
  1385. $self->sendToServer($msg);
  1386. debug "Sent Top 10 Alchemist requestn", "sendPacket", 2;
  1387. }
  1389. sub sendTop10Blacksmith {
  1390. my $self = shift;
  1391. my $msg = pack("C*", 0x17, 0x02);
  1392. $self->sendToServer($msg);
  1393. debug "Sent Top 10 Blacksmith requestn", "sendPacket", 2;
  1394. }
  1396. sub sendTop10PK {
  1397. my $self = shift;
  1398. my $msg = pack("C*", 0x37, 0x02);
  1399. $self->sendToServer($msg);
  1400. debug "Sent Top 10 PK requestn", "sendPacket", 2;
  1401. }
  1403. sub sendTop10Taekwon {
  1404. my $self = shift;
  1405. my $msg = pack("C*", 0x25, 0x02);
  1406. $self->sendToServer($msg);
  1407. debug "Sent Top 10 Taekwon requestn", "sendPacket", 2;
  1408. }
  1410. sub sendUnequip {
  1411. my $self = shift;
  1412. my $index = shift;
  1413. my $msg = pack("C*", 0xAB, 0x00) . pack("v*", $index);
  1414. $self->sendToServer($msg);
  1415. debug "Sent Unequip: $indexn", "sendPacket", 2;
  1416. }
  1418. sub sendWho {
  1419. my $self = shift;
  1420. my $msg = pack("C*", 0xC1, 0x00);
  1421. $self->sendToServer($msg);
  1422. debug "Sent Whon", "sendPacket", 2;
  1423. }
  1425. sub sendMessageIDEncryptionInitialized {
  1426. my $self = shift;
  1427. my $msg = pack("C*", 0xAF, 0x02);
  1428. $self->sendToServer($msg);
  1429. debug "Sent Message ID Encryption Initializedn", "sendPacket", 2;
  1430. }
  1432. sub sendMailboxOpen {
  1433. my $self = $_[0];
  1434. my $msg = pack("C*", 0x3F, 0x02);
  1435. $self->sendToServer($msg);
  1436. debug "Sent mailbox open.n", "sendPacket", 2;
  1437. }
  1439. sub sendMailRead {
  1440. my ($self, $mailID) = @_;
  1441. my $msg = pack("C2 V1", 0x41, 0x02, $mailID);
  1442. $self->sendToServer($msg);
  1443. debug "Sent read mail.n", "sendPacket", 2;
  1444. }
  1446. sub sendMailDelete {
  1447. my ($self, $mailID) = @_;
  1448. my $msg = pack("C2 V1", 0x43, 0x02, $mailID);
  1449. $self->sendToServer($msg);
  1450. debug "Sent delete mail.n", "sendPacket", 2;
  1451. }
  1453. sub sendMailReturn {
  1454. my ($self, $mailID, $sender) = @_;
  1455. my $msg = pack("C2 V1 Z24", 0x73, 0x02, $mailID, stringToBytes($sender));
  1456. $self->sendToServer($msg);
  1457. debug "Sent return mail.n", "sendPacket", 2;
  1458. }
  1460. sub sendMailOperateWindow {
  1461. my ($self, $window) = @_;
  1462. my $msg = pack("C2 C1 x1", 0x46, 0x02, $window);
  1463. $self->sendToServer($msg);
  1464. debug "Sent mail window.n", "sendPacket", 2;
  1465. }
  1467. sub sendMailGetAttach {
  1468. my ($self, $mailID) = @_;
  1469. my $msg = pack("C2 V1", 0x44, 0x02, $mailID);
  1470. $self->sendToServer($msg);
  1471. debug "Sent mail get attachment.n", "sendPacket", 2;
  1472. }
  1474. sub sendMailSetAttach {
  1475. my $self = $_[0];
  1476. my $amount = $_[1];
  1477. my $index = (defined $_[2]) ? $_[2] : 0; # 0 for zeny
  1478. my $msg = pack("C2 v1 V1", 0x47, 0x02, $index, $amount);
  1479. $self->sendToServer($msg);
  1480. debug "Sent mail set attachment.n", "sendPacket", 2;
  1481. }
  1483. sub sendMailSend {
  1484. my ($self, $length, $receiver, $title, $msglength, $mailmsg) = @_;
  1485. my $msg = pack("C2 v1 Z24 a40 C1 Z*", 0x48, 0x02, $length, stringToBytes($receiver), stringToBytes($title), $msglength, stringToBytes($mailmsg));
  1486. $self->sendToServer($msg);
  1487. debug "Sent mail send.n", "sendPacket", 2;
  1488. }
  1490. sub sendAuctionAddItemCancel {
  1491. my ($self) = @_;
  1492. my $msg = pack("C2 v1", 0x4B, 0x02, 1);
  1493. $self->sendToServer($msg);
  1494. debug "Sent Auction Add Item Cancel.n", "sendPacket", 2;
  1495. }
  1497. sub sendAuctionAddItem {
  1498. my ($self, $index, $amount) = @_;
  1499. my $msg = pack("C2 v1 V1", 0x4C, 0x02, $index, $amount);
  1500. $self->sendToServer($msg);
  1501. debug "Sent Auction Add Item.n", "sendPacket", 2;
  1502. }
  1504. sub sendAuctionCreate {
  1505. my ($self, $price, $buynow, $hours) = @_;
  1506. my $msg = pack("C2 V1 V1 v1", 0x4D, 0x02, $price, $buynow, $hours);
  1507. $self->sendToServer($msg);
  1508. debug "Sent Auction Create.n", "sendPacket", 2;
  1509. }
  1511. sub sendAuctionCancel {
  1512. my ($self, $id) = @_;
  1513. my $msg = pack("C2 V1", 0x4E, 0x02, $id);
  1514. $self->sendToServer($msg);
  1515. debug "Sent Auction Cancel.n", "sendPacket", 2;
  1516. }
  1518. sub sendAuctionBuy {
  1519. my ($self, $id, $bid) = @_;
  1520. my $msg = pack("C2 V1 V1", 0x4F, 0x02, $id, $bid);
  1521. $self->sendToServer($msg);
  1522. debug "Sent Auction Buy.n", "sendPacket", 2;
  1523. }
  1525. sub sendAuctionItemSearch {
  1526. my ($self, $type, $price, $text, $page) = @_;
  1527. $page = (defined $page) ? $page : 1;
  1528. my $msg = pack("C2 v1 V1 Z24 v1", 0x51, 0x02, $type, $price, stringToBytes($text), $page);
  1529. $self->sendToServer($msg);
  1530. debug "Sent Auction Item Search.n", "sendPacket", 2;
  1531. }
  1533. sub sendAuctionReqMyInfo {
  1534. my ($self, $type) = @_;
  1535. my $msg = pack("C2 v1", 0x5C, 0x02, $type);
  1536. $self->sendToServer($msg);
  1537. debug "Sent Auction Request My Info.n", "sendPacket", 2;
  1538. }
  1540. sub sendAuctionMySellStop {
  1541. my ($self, $id) = @_;
  1542. my $msg = pack("C2 V1", 0x5D, 0x02, $id);
  1543. $self->sendToServer($msg);
  1544. debug "Sent My Sell Stop.n", "sendPacket", 2;
  1545. }
  1547. 1;