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

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

外挂编程

开发平台：

Windows_Unix

FileParsers.pm.svn-base：源码内容
  1. #########################################################################
  2. #  OpenKore - Config File Parsers
  3. #
  4. #  This software is open source, licensed under the GNU General Public
  5. #  License, version 2.
  6. #  Basically, this means that you're allowed to modify and distribute
  7. #  this software. However, if you distribute modified versions, you MUST
  8. #  also distribute the source code.
  9. #  See http://www.gnu.org/licenses/gpl.html for the full license.
  10. #
  11. #  $Revision$
  12. #  $Id$
  13. #
  14. #########################################################################
  15. ##
  16. # MODULE DESCRIPTION: Configuration file parsers
  17. #
  18. # This module contains functions for parsing an writing config/* and
  19. # tables/* files.
  21. package FileParsers;
  23. use strict;
  24. use File::Spec;
  25. use Exporter;
  26. use base qw(Exporter);
  27. use encoding 'utf8';
  28. use Carp;
  30. use Utils;
  31. use Utils::TextReader;
  32. use Plugins;
  33. use Log qw(warning error);
  35. our @EXPORT = qw(
  36. parseArrayFile
  37. parseAvoidControl
  38. parseChatResp
  39. parseCommandsDescription
  40. parseConfigFile
  41. parseDataFile
  42. parseDataFile_lc
  43. parseDataFile2
  44. parseEmotionsFile
  45. parseItemsControl
  46. parseList
  47. parseNPCs
  48. parseMonControl
  49. parsePortals
  50. parsePortalsLOS
  51. parsePriority
  52. parseResponses
  53. parseROLUT
  54. parseRODescLUT
  55. parseROSlotsLUT
  56. parseSectionedFile
  57. parseShopControl
  58. parseSkillsSPLUT
  59. parseTimeouts
  60. parseWaypoint
  61. processUltimate
  62. writeDataFile
  63. writeDataFileIntact
  64. writeDataFileIntact2
  65. writePortalsLOS
  66. writeSectionedFileIntact
  67. updateMonsterLUT
  68. updatePortalLUT
  69. updateNPCLUT
  70. );
  73. sub parseArrayFile {
  74. my $file = shift;
  75. my $r_array = shift;
  76. undef @{$r_array};
  78. my @lines;
  79. my $reader = new Utils::TextReader($file);
  80. while (!$reader->eof()) {
  81. my $line = $reader->readLine();
  82. $line =~ s/[rnx{FEFF}]//g;
  83. push @lines, $line;
  84. }
  85. @{$r_array} = scalar(@lines) + 1;
  86. my $i = 1;
  87. foreach (@lines) {
  88. $r_array->[$i] = $_;
  89. $i++;
  90. }
  91. return 1;
  92. }
  94. sub parseAvoidControl {
  95. my $file = shift;
  96. my $r_hash = shift;
  97. undef %{$r_hash};
  98. my ($key,@args,$args);
  99. my $reader = new Utils::TextReader($file);
  101. my $section = "";
  102. while (!$reader->eof()) {
  103. my $line = $reader->readLine();
  104. $line =~ s/x{FEFF}//g;
  105. next if ($line =~ /^#/);
  106. $line =~ s/[rn]//g;
  107. $line =~ s/s+$//g;
  109. next if ($line eq "");
  111. if ($line =~ /^[(.*)]$/) {
  112. $section = $1;
  113. next;
  115. } else {
  116. ($key, $args) = lc($line) =~ /([sS]+?)[s]+(d+[sS]*)/;
  117. @args = split / /,$args;
  118. if ($key ne "") {
  119. $r_hash->{$section}{$key}{disconnect_on_sight} = $args[0];
  120. $r_hash->{$section}{$key}{teleport_on_sight} = $args[1];
  121. $r_hash->{$section}{$key}{disconnect_on_chat} = $args[2];
  122. }
  123. }
  124. }
  125. return 1;
  126. }
  128. sub parseChatResp {
  129. my $file = shift;
  130. my $r_array = shift;
  132. my $reader = new Utils::TextReader($file);
  133. while (!$reader->eof()) {
  134. my $line = $reader->readLine();
  135. $line =~ s/[rnx{FEFF}]//g;
  136. next if ($line eq "" || $line =~ /^#/);
  137. if ($line =~ /^first_resp_/) {
  138. Log::error(Translation::T("The chat_resp.txt format has changed. Please read News.txt and upgrade to the new format.n"));
  139. return;
  140. }
  142. my ($key, $value) = split /t+/, lc($line), 2;
  143. my @input = split /,+/, $key;
  144. my @responses = split /,+/, $value;
  146. foreach my $word (@input) {
  147. my %args = (
  148. word => $word,
  149. responses => @responses
  150. );
  151. push @{$r_array}, %args;
  152. }
  153. }
  154. return 1;
  155. }
  157. sub parseCommandsDescription {
  158. my $file = shift;
  159. my $r_hash = shift;
  160. my $no_undef = shift;
  162. undef %{$r_hash} unless $no_undef;
  163. my ($key, $commentBlock, $description);
  165. my $reader = new Utils::TextReader($file);
  166. while (!$reader->eof()) {
  167. my $line = $reader->readLine();
  168. $line =~ s/x{FEFF}//g;
  169. next if ($line =~ /^[st]*#/);
  170. $line =~ s/[rn]//g; # Remove line endings
  171. $line =~ s/^[ts]*//; # Remove leading tabs and whitespace
  172. $line =~ s/s+$//g; # Remove trailing whitespace
  173. next if ($line eq "");
  175. if (!defined $commentBlock && $line =~ /^/*/) {
  176. $commentBlock = 1;
  177. next;
  179. } elsif ($line =~ m/*/$/) {
  180. undef $commentBlock;
  181. next;
  183. } elsif (defined $commentBlock) {
  184. next;
  186. } elsif ($description) {
  187. $description = 0;
  188. push @{$r_hash->{$key}}, $line;
  190. } elsif ($line =~ /^[(w+)]$/) {
  191. $key = $1;
  192. $description = 1;
  193. $r_hash->{$key} = [];
  195. } elsif ($line =~ /^(.*?)t+(.*)$/) {
  196. push @{$r_hash->{$key}}, [$1, $2];
  197. }
  198. }
  199. return 1;
  200. }
  202. sub parseConfigFile {
  203. my $file = shift;
  204. my $r_hash = shift;
  205. my $no_undef = shift;
  207. undef %{$r_hash} unless $no_undef;
  208. my ($key, $value, $inBlock, $commentBlock, %blocks);
  210. my $reader = new Utils::TextReader($file);
  211. while (!$reader->eof()) {
  212. my $line = $reader->readLine();
  213. $line =~ s/x{FEFF}//g;
  214. next if ($line =~ /^[st]*#/);
  215. $line =~ s/[rn]//g; # Remove line endings
  216. $line =~ s/^[ts]*//; # Remove leading tabs and whitespace
  217. $line =~ s/s+$//g; # Remove trailing whitespace
  218. next if ($line eq "");
  220. if (!defined $commentBlock && $line =~ /^/*/) {
  221. $commentBlock = 1;
  222. next;
  224. } elsif (defined $commentBlock && $line =~ m/*/$/) {
  225. undef $commentBlock;
  226. next;
  228. } elsif (defined $commentBlock) {
  229. next;
  231. } elsif (!defined $inBlock && $line =~ /{$/) {
  232. # Begin of block
  233. $line =~ s/ *{$//;
  234. ($key, $value) = $line =~ /^(.*?) (.*)/;
  235. $key = $line if ($key eq '');
  237. if (!exists $blocks{$key}) {
  238. $blocks{$key} = 0;
  239. } else {
  240. $blocks{$key}++;
  241. }
  242. if ($key ne 'teleportAuto'){
  243. $inBlock = "${key}_$blocks{$key}";
  244. } else {
  245. $inBlock = "${key}";
  246. }
  247. $r_hash->{$inBlock} = $value;
  249. } elsif (defined $inBlock && $line eq "}") {
  250. # End of block
  251. undef $inBlock;
  253. } else {
  254. # Option
  255. ($key, $value) = $line =~ /^(.*?) (.*)/;
  256. if ($key eq "") {
  257. $key = $line;
  258. $key =~ s/ *$//;
  259. }
  260. #$value = $r_hash->{$1} if ($value =~ /^constant.(.*)/);
  261. $key = "${inBlock}_${key}" if (defined $inBlock);
  263. if ($key eq "!include") {
  264. # Process special !include directives
  265. # The filename can be relative to the current file
  266. my $f = $value;
  267. if (!File::Spec->file_name_is_absolute($value) && $value !~ /^//) {
  268. if ($file =~ /[/\]/) {
  269. $f = $file;
  270. $f =~ s/(.*)[/\].*/$1/;
  271. $f = File::Spec->catfile($f, $value);
  272. } else {
  273. $f = $value;
  274. }
  275. }
  276. if (-f $f) {
  277. my $ret = parseConfigFile($f, $r_hash, 1);
  278. return $ret unless $ret;
  279. } else {
  280. error Translation::TF("%s: Include file not found: %sn", $file, $f);
  281. return 0;
  282. }
  284. } else {
  285. $r_hash->{$key} = $value;
  286. }
  287. }
  288. }
  290. if ($inBlock) {
  291. error Translation::TF("%s: Unclosed { at EOFn", $file);
  292. return 0;
  293. }
  294. return 1;
  295. }
  297. sub parseEmotionsFile {
  298. my $file = shift;
  299. my $r_hash = shift;
  300. undef %{$r_hash};
  301. my ($key, $word, $name);
  302. my $reader = new Utils::TextReader($file);
  303. while (!$reader->eof()) {
  304. my $line = $reader->readLine();
  305. $line =~ s/x{FEFF}//g;
  306. next if ($line =~ /^#/);
  307. $line =~ s/[rn]//g;
  308. $line =~ s/s+$//g;
  310. ($key, $word, $name) = $line =~ /^(d+) (S+) (.*)$/;
  312. if ($key ne "") {
  313. $$r_hash{$key}{command} = $word;
  314. $$r_hash{$key}{display} = $name;
  315. }
  316. }
  317. return 1;
  318. }
  321. sub parseDataFile {
  322. my $file = shift;
  323. my $r_hash = shift;
  324. undef %{$r_hash};
  325. my ($key,$value);
  326. my $reader = new Utils::TextReader($file);
  327. while (!$reader->eof()) {
  328. my $line = $reader->readLine();
  329. $line =~ s/x{FEFF}//g;
  330. next if ($line =~ /^#/);
  331. $line =~ s/[rn]//g;
  332. $line =~ s/s+$//g;
  333. ($key, $value) = $line =~ /([sS]*) ([sS]*?)$/;
  334. if ($key ne "" && $value ne "") {
  335. $$r_hash{$key} = $value;
  336. }
  337. }
  338. return 1;
  339. }
  341. sub parseDataFile_lc {
  342. my $file = shift;
  343. my $r_hash = shift;
  344. undef %{$r_hash};
  345. my ($key,$value);
  346. my $reader = new Utils::TextReader($file);
  347. while (!$reader->eof()) {
  348. my $line = $reader->readLine();
  349. $line =~ s/x{FEFF}//g;
  350. next if ($line =~ /^#/);
  351. $line =~ s/[rn]//g;
  352. $line =~ s/s+$//g;
  353. ($key, $value) = $line =~ /([sS]*) ([sS]*?)$/;
  354. if ($key ne "" && $value ne "") {
  355. $$r_hash{lc($key)} = $value;
  356. }
  357. }
  358. return 1;
  359. }
  361. sub parseDataFile2 {
  362. my ($file, $r_hash) = @_;
  364. %{$r_hash} = ();
  365. my $reader = new Utils::TextReader($file);
  366. while (!$reader->eof()) {
  367. my $line = $reader->readLine();
  368. $line =~ s/x{FEFF}//g;
  369. next if ($line =~ /^#/);
  370. $line =~ s/[rn]//g;
  371. next if (length($line) == 0);
  373. my ($key, $value) = split / /, $line, 2;
  374. $r_hash->{$key} = $value;
  375. }
  376. close FILE;
  377. return 1;
  378. }
  380. sub parseList {
  381. my $file = shift;
  382. my $r_hash = shift;
  384. undef %{$r_hash};
  386. my $reader = new Utils::TextReader($file);
  387. while (!$reader->eof()) {
  388. my $line = $reader->readLine();
  389. chomp($line);
  390. $r_hash->{$line} = 1;
  391. }
  392. return 1;
  393. }
  395. ##
  396. # parseShopControl(file, shop)
  397. # file: Filename to parse
  398. # shop: Return hash
  399. #
  400. # Parses a shop control file. The shop control file should have the shop title
  401. # on its first line, followed by "$itemt$pricet$quantity" on subsequent
  402. # lines. Blank lines, or lines starting with "#" are ignored. If $price
  403. # contains commas, then they are checked for syntactical validity (e.g.
  404. # "1,000,000" instead of "1,000,00") to protect the user from entering the
  405. # wrong price. If $quantity is missing, all available will be sold.
  406. #
  407. # Example:
  408. # My Shop!
  409. # Poring Card 1,000
  410. # Andre Card 1,000,000 3
  411. # +8 Chain [3] 500,000
  412. sub parseShopControl {
  413. my ($file, $shop) = @_;
  415. %{$shop} = ();
  416. my $reader = new Utils::TextReader($file);
  418. # Read shop items
  419. $shop->{items} = [];
  420. my $linenum = 0;
  421. my @errors = ();
  422. my $line;
  424. while (!$reader->eof()) {
  425. $line = $reader->readLine();
  426. $linenum++;
  427. chomp;
  428. $line =~ s/[rnx{FEFF}]//g;
  429. next if $line =~ /^$/ || $line =~ /^#/;
  431. if (!$shop->{title_line}) { 
  432. $shop->{title_line} = $line;
  433. next;
  434. }
  436. my ($name, $price, $amount) = split(/t+/, $line);
  437. $price =~ s/^s+//g;
  438. $amount =~ s/^s+//g;
  439. my $real_price = $price;
  440. $real_price =~ s/,//g;
  442. my $loc = Translation::TF("Line %s: Item '%s'", $linenum, $name);
  443. if ($real_price !~ /^d+$/) {
  444. push(@errors, Translation::TF("%s has non-integer price: %s", $loc, $price));
  445. } elsif ($price ne $real_price && formatNumber($real_price) ne $price) {
  446. push(@errors, Translation::TF("%s has incorrect comma placement in price: %s", $loc, $price));
  447. } elsif ($real_price < 0) {
  448. push(@errors, Translation::TF("%s has non-positive price: %s", $loc, $price));
  449. } elsif ($real_price > 1000000000) {
  450. push(@errors, Translation::TF("%s has price over 1,000,000,000: %s", $loc, $price));
  451. }
  453. if ($amount > 30000) {
  454. push(@errors, Translation::TF("%s has amount over 30,000: %s", $loc, $amount));
  455. }
  457. push(@{$shop->{items}}, {name => $name, price => $real_price, amount => $amount});
  458. }
  460. if (@errors) {
  461. error Translation::TF("Errors were found in %s:n", $file);
  462. foreach (@errors) { error("$linen"); }
  463. error Translation::TF("Please correct the above errors and type 'reload %s'.n", $file);
  464. return 0;
  465. }
  466. return 1;
  467. }
  469. sub parseItemsControl {
  470. my $file = shift;
  471. my $r_hash = shift;
  472. undef %{$r_hash};
  473. my ($key, $args_text, %cache);
  475. my $reader = new Utils::TextReader($file);
  476. while (!$reader->eof()) {
  477. my $line = $reader->readLine();
  478. $line =~ s/x{FEFF}//g;
  479. next if ($line =~ /^#/);
  480. $line =~ s/[rn]//g;
  481. $line =~ s/s+$//g;
  482. ($key, $args_text) = lc($line) =~ /([sS]+?) (d+[sS]*)/;
  483. next if ($key eq "");
  485. if ($cache{$args_text}) {
  486. $r_hash->{$key} = $cache{$args_text};
  487. } else {
  488. my @args = split / /, $args_text;
  489. my %item = (
  490. keep => $args[0],
  491. storage => $args[1],
  492. sell => $args[2],
  493. cart_add => $args[3],
  494. cart_get => $args[4]
  495. );
  496. # Cache similar entries to save memory.
  497. $r_hash->{$key} = $cache{$args_text} = %item;
  498. }
  499. }
  500. return 1;
  501. }
  503. sub parseNPCs {
  504. my $file = shift;
  505. my $r_hash = shift;
  506. my ($i, $string);
  507. undef %{$r_hash};
  508. my ($key, $value, @args);
  509. my $reader = new Utils::TextReader($file);
  510. while (!$reader->eof()) {
  511. my $line = $reader->readLine();
  512. $line =~ s/cM|cJ//g;
  513. $line =~ s/^s+|s+$//g;
  514. next if $line =~ /^#/ || $line eq '';
  515. #izlude 135 78 Charfri
  516. my ($map,$x,$y,$name) = split /s+/, $line,4;
  517. next unless $name;
  518. $$r_hash{"$map $x $y"} = $name;
  519. }
  520. return 1;
  521. }
  523. sub parseMonControl {
  524. my $file = shift;
  525. my $r_hash = shift;
  526. undef %{$r_hash};
  527. my ($key,@args,$args);
  529. my $reader = new Utils::TextReader($file);
  530. while (!$reader->eof()) {
  531. my $line = $reader->readLine();
  532. $line =~ s/x{FEFF}//g;
  533. next if ($line =~ /^#/);
  534. $line =~ s/[rn]//g;
  535. $line =~ s/s+$//g;
  537. if ($line =~ /t/) {
  538. ($key, $args) = split /t+/, lc($line);
  539. } else {
  540. ($key, $args) = lc($line) =~ /([sS]+?) ([-d.]+[sS]*)/;
  541. }
  543. @args = split / /, $args;
  544. if ($key ne "") {
  545. $r_hash->{$key}{attack_auto} = $args[0];
  546. $r_hash->{$key}{teleport_auto} = $args[1];
  547. $r_hash->{$key}{teleport_search} = $args[2];
  548. $r_hash->{$key}{skillcancel_auto} = $args[3];
  549. $r_hash->{$key}{attack_lvl} = $args[4];
  550. $r_hash->{$key}{attack_jlvl} = $args[5];
  551. $r_hash->{$key}{attack_hp} = $args[6];
  552. $r_hash->{$key}{attack_sp} = $args[7];
  553. $r_hash->{$key}{weight} = $args[8];
  554. }
  555. }
  556. return 1;
  557. }
  559. sub parsePortals {
  560. my $file = shift;
  561. my $r_hash = shift;
  562. undef %{$r_hash};
  563. open FILE, "<", $file;
  564. while (my $line = <FILE>) {
  565. next if $line =~ /^#/;
  566. $line =~ s/cM|cJ//g;
  567. $line =~ s/s+/ /g;
  568. $line =~ s/^s+|s+$//g;
  569. my @args = split /s/, $line, 8;
  570. if (@args > 5) {
  571. my $portal = "$args[0] $args[1] $args[2]";
  572. my $dest = "$args[3] $args[4] $args[5]";
  573. $$r_hash{$portal}{'source'}{'map'} = $args[0];
  574. $$r_hash{$portal}{'source'}{'x'} = $args[1];
  575. $$r_hash{$portal}{'source'}{'y'} = $args[2];
  576. $$r_hash{$portal}{'dest'}{$dest}{'map'} = $args[3];
  577. $$r_hash{$portal}{'dest'}{$dest}{'x'} = $args[4];
  578. $$r_hash{$portal}{'dest'}{$dest}{'y'} = $args[5];
  579. $$r_hash{$portal}{'dest'}{$dest}{'cost'} = $args[6];
  580. $$r_hash{$portal}{'dest'}{$dest}{'steps'} = $args[7];
  581. }
  582. }
  583. close FILE;
  584. return 1;
  585. }
  587. sub parsePortalsLOS {
  588. my $file = shift;
  589. my $r_hash = shift;
  590. undef %{$r_hash};
  591. my $key;
  592. open FILE, "<", $file;
  593. foreach (<FILE>) {
  594. s/x{FEFF}//g;
  595. next if (/^#/);
  596. s/[rn]//g;
  597. s/s+/ /g;
  598. s/s+$//g;
  599. my @args = split /s/, $_;
  600. if (@args) {
  601. my $map = shift @args;
  602. my $x = shift @args;
  603. my $y = shift @args;
  604. for (my $i = 0; $i < @args; $i += 4) {
  605. $$r_hash{"$map $x $y"}{"$args[$i] $args[$i+1] $args[$i+2]"} = $args[$i+3];
  606. }
  607. }
  608. }
  609. close FILE;
  610. return 1;
  611. }
  613. sub parsePriority {
  614. my $file = shift;
  615. my $r_hash = shift;
  616. return unless my $reader = new Utils::TextReader($file);
  618. my @lines;
  619. while (!$reader->eof()) {
  620. push @lines, $reader->readLine();
  621. }
  622. my $pri = $#lines;
  623. foreach (@lines) {
  624. s/x{FEFF}//g;
  625. next if (/^#/);
  626. s/[rn]//g;
  627. $$r_hash{lc($_)} = $pri + 1;
  628. $pri--;
  629. }
  630. return 1;
  631. }
  633. sub parseResponses {
  634. my $file = shift;
  635. my $r_hash = shift;
  636. undef %{$r_hash};
  637. my ($i, $key,$value);
  638. my $reader = new Utils::TextReader($file);
  639. while (!$reader->eof()) {
  640. my $line = $reader->readLine();
  641. $line =~ s/x{FEFF}//g;
  642. next if ($line =~ /^#/);
  643. $line =~ s/[rn]//g;
  644. ($key, $value) = $line =~ /([sS]*?) ([sS]*)$/;
  645. if ($key ne "" && $value ne "") {
  646. $i = 0;
  647. while ($$r_hash{"$key_$i"} ne "") {
  648. $i++;
  649. }
  650. $$r_hash{"$key_$i"} = $value;
  651. }
  652. }
  653. return 1;
  654. }
  656. sub parseROLUT {
  657. my ($file, $r_hash) = @_;
  659. my %ret = (
  660. file => $file,
  661. hash => $r_hash
  662.     );
  663. Plugins::callHook("FileParsers::ROLUT", %ret);
  664. return if ($ret{return});
  666. undef %{$r_hash};
  667. my $reader = new Utils::TextReader($file);
  668. while (!$reader->eof()) {
  669. my $line = $reader->readLine();
  670. $line =~ s/[rnx{FEFF}]//g;
  671. next if (length($line) == 0 || $line =~ /^///);
  673. my ($id, $name) = split /#/, $line, 3;
  674. if ($id ne "" && $name ne "") {
  675. $name =~ s/_/ /g;
  676. $r_hash->{$id} = $name;
  677. }
  678. }
  679. return 1;
  680. }
  682. sub parseRODescLUT {
  683. my ($file, $r_hash) = @_;
  685. my %ret = (
  686. file => $file,
  687. hash => $r_hash
  688.     );
  689. Plugins::callHook("FileParsers::RODescLUT", %ret);
  690. return if ($ret{return});
  692. undef %{$r_hash};
  693. my $ID;
  694. my $IDdesc;
  695. open FILE, "< $file";
  696. foreach (<FILE>) {
  697. s/r//g;
  698. if (/^#/) {
  699. $$r_hash{$ID} = $IDdesc;
  700. undef $ID;
  701. undef $IDdesc;
  702. } elsif (!$ID) {
  703. ($ID) = /([sS]+)#/;
  704. } else {
  705. $IDdesc .= $_;
  706. $IDdesc =~ s/^......//g;
  707. $IDdesc =~ s/_/--------------/g;
  708. }
  709. }
  710. close FILE;
  711. return 1;
  712. }
  714. sub parseROSlotsLUT {
  715. my $file = shift;
  716. my $r_hash = shift;
  717. undef %{$r_hash};
  718. my $ID;
  719. open FILE, $file;
  720. foreach (<FILE>) {
  721. if (!$ID) {
  722. ($ID) = /(d+)#/;
  723. } else {
  724. ($$r_hash{$ID}) = /(d+)#/;
  725. undef $ID;
  726. }
  727. }
  728. close FILE;
  729. return 1;
  730. }
  732. sub parseSectionedFile {
  733. my $file = shift;
  734. my $r_hash = shift;
  735. undef %{$r_hash};
  736. my $reader = new Utils::TextReader($file);
  738. my $section = "";
  739. while (!$reader->eof()) {
  740. my $line = $reader->readLine();
  741. $line =~ s/x{FEFF}//g;
  742. next if ($line =~ /^#/);
  743. $line =~ s/[rn]//g;
  744. $line =~ s/s+$//g;
  745. next if ($line eq "");
  747. if ($line =~ /^[(.*)]$/i) {
  748. $section = $1;
  749. next;
  750. } else {
  751. my ($key, $value);
  752. if ($line =~ / /) {
  753. ($key, $value) = $line =~ /^(.*?) (.*)/;
  754. } else {
  755. $key = $line;
  756. }
  757. $r_hash->{$section}{$key} = $value;
  758. }
  759. }
  760. return 1;
  761. }
  763. sub parseSkillsSPLUT {
  764. my $file = shift;
  765. my $r_hash = shift;
  766. undef %{$r_hash};
  767. my $ID;
  768. my $i;
  769. $i = 1;
  770. open(FILE, "< $file");
  771. foreach (<FILE>) {
  772. if (/^@/) {
  773. undef $ID;
  774. $i = 1;
  775. } elsif (!$ID) {
  776. ($ID) = /([sS]+)#/;
  777. } else {
  778. ($$r_hash{$ID}{$i++}) = /(d+)#/;
  779. }
  780. }
  781. close FILE;
  782. return 1;
  783. }
  785. sub parseTimeouts {
  786. my $file = shift;
  787. my $r_hash = shift;
  788. my $reader = new Utils::TextReader($file);
  789. while (!$reader->eof()) {
  790. my $line = $reader->readLine();
  791. $line =~ s/x{FEFF}//g;
  792. next if ($line =~ /^#/);
  793. $line =~ s/[rn]//g;
  795. my ($key, $value) = $line =~ /([sS]+?) ([sS]*?)$/;
  796. my @args = split (/ /, $value);
  797. if ($key ne "") {
  798. $$r_hash{$key}{'timeout'} = $args[0];
  799. }
  800. }
  801. return 1;
  802. }
  804. sub parseWaypoint {
  805. my $file = shift;
  806. my $r_array = shift;
  807. @{$r_array} = ();
  809. open FILE, "< $file";
  810. foreach (<FILE>) {
  811. s/x{FEFF}//g;
  812. next if (/^#/ || /^$/);
  813. s/[rn]//g;
  815. my @items = split / +/, $_;
  816. my %point = (
  817. map => $items[0],
  818. x => $items[1],
  819. y => $items[2]
  820. );
  821. push @{$r_array}, %point;
  822. }
  823. close FILE;
  824. return 1;
  825. }
  828. # The ultimate config file format. This function is a parser and writer in one.
  829. # The config file can be divided in section, example:
  830. #
  831. #   foo 1
  832. #   bar 2
  833. #
  834. #   [Options]
  835. #   username me
  836. #   password p
  837. #
  838. #   [Names]
  839. #   joe
  840. #   mike
  841. #
  842. # Sections can be treated as hashes or arrays. It's defined by $rules.
  843. # If you want [Names] to be an array:
  844. # %rule = (Names => 'list');
  845. #
  846. # processUltimate("file", %hash, %rule) returns:
  847. # {
  848. #   foo => 1,
  849. #   bar => 2,
  850. #   Options => {
  851. #       username => 'me',
  852. #       password => 'p';
  853. #   },
  854. #   Names => [
  855. #       "joe",
  856. #       "mike"
  857. #   ]
  858. # }
  859. #
  860. # When in write mode, this function will automatically add new keys and lines,
  861. # while preserving comments.
  862. sub processUltimate {
  863. my ($file, $hash, $rules, $writeMode) = @_;
  864. my $f;
  865. my $secname = '';
  866. my ($section, $rule, @lines, %written, %sectionsWritten);
  868. undef %{$hash} if (!$writeMode);
  869. if (-f $file) {
  870. my $reader = new Utils::TextReader($file);
  871. while (!$reader->eof()) {
  872. my $line = $reader->readLine();
  873. $line =~ s/x{FEFF}//g;
  874. $line =~ s/[rn]//g;
  876. if ($line eq '' || $line =~ /^[ t]*#/) {
  877. push @lines, $line if ($writeMode);
  878. next;
  879. }
  881. if ($line =~ /^[(.+)]$/) {
  882. # New section
  883. if ($writeMode) {
  884. # First, finish writing everything in the previous section
  885. my $h = (defined $section) ? $section : $hash;
  886. my @add;
  888. if ($rule ne 'list') {
  889. foreach my $key (keys %{$h}) {
  890. if (!$written{$key} && !ref($h->{$key})) {
  891. push @add, "$key $h->{$key}";
  892. }
  893. }
  895. } else {
  896. foreach (@{$h}) {
  897. push @add, $_ if (!$written{$_});
  898. }
  899. }
  901. # Add after the first non-empty line from the end
  902. my $linesFromEnd;
  903. for (my $i = @lines - 1; $i >= 0; $i--) {
  904. if ($lines[$i] ne '') {
  905. $linesFromEnd = @lines - $i - 1;
  906. for (my $j = $i + 1; $j < @lines; $j++) {
  907. delete $lines[$j];
  908. }
  909. push @lines, @add;
  910. for (my $j = 0; $j < $linesFromEnd; $j++) {
  911. push @lines, '';
  912. }
  913. last;
  914. }
  915. }
  916. undef %written;
  917. }
  919. # Parse the new section
  920. $secname = $1;
  921. $rule = $rules->{$secname};
  922. if ($writeMode) {
  923. $section = $hash->{$secname};
  924. push @lines, $line;
  925. $sectionsWritten{$secname} = 1;
  927. } else {
  928. if ($rule ne 'list') {
  929. $section = {};
  930. } else {
  931. $section = [];
  932. }
  933. $hash->{$secname} = $section;
  934. }
  936. } elsif ($rule ne 'list') {
  937. # Line is a key-value pair
  938. my ($key, $val) = split / /, $line, 2;
  939. my $h = (defined $section) ? $section : $hash;
  941. if ($writeMode) {
  942. # Delete line if value doesn't exist
  943. if (exists $h->{$key}) {
  944. if (!defined $h->{$key}) {
  945. push @lines, $key;
  946. } else {
  947. push @lines, "$key $h->{$key}";
  948. }
  949. $written{$key} = 1;
  950. }
  952. } else {
  953. $h->{$key} = $val;
  954. }
  956. } else {
  957. # Line is part of a list
  958. if ($writeMode) {
  959. # Add line only if it exists in the hash
  960. push @lines, $line if (defined(binFind($section, $line)));
  961. $written{$line} = 1;
  963. } else {
  964. push @{$section}, $line;
  965. }
  966. }
  967. }
  968. }
  970. if ($writeMode) {
  971. # Add stuff that haven't already been added
  972. my $h = (defined $section) ? $section : $hash;
  974. if ($rule ne 'list') {
  975. foreach my $key (keys %{$h}) {
  976. if (!$written{$key} && !ref($h->{$key})) {
  977. push @lines, "$key $h->{$key}";
  978. }
  979. }
  981. } else {
  982. foreach my $line (@{$h}) {
  983. push @lines, $line if (!$written{$line});
  984. }
  985. }
  987. # Write sections that aren't already in the file
  988. foreach my $section (keys %{$hash}) {
  989. next if (!ref($hash->{$section}) || $sectionsWritten{$section});
  990. push @lines, "", "[$section]";
  991. if ($rules->{$section} eq 'list') {
  992. push @lines, @{$hash->{$section}};
  993. } else {
  994. foreach my $key (keys %{$hash->{$section}}) {
  995. push @lines, "$key $hash->{$section}{$key}";
  996. }
  997. }
  998. }
  1000. open($f, ">:utf8", $file);
  1001. print $f join("n", @lines) . "n";
  1002. close $f;
  1003. }
  1004. return 1;
  1005. }
  1007. sub writeDataFile {
  1008. my $file = shift;
  1009. my $r_hash = shift;
  1010. my ($key,$value);
  1011. open(FILE, ">>:utf8", $file);
  1012. foreach (keys %{$r_hash}) {
  1013. if ($_ ne "") {
  1014. print FILE $_;
  1015. print FILE " $$r_hash{$_}" if $$r_hash{$_} ne '';
  1016. print FILE "n";
  1017. }
  1018. }
  1019. close FILE;
  1020. }
  1022. sub writeDataFileIntact {
  1023. my $file = shift;
  1024. my $r_hash = shift;
  1025. my $no_undef = shift;
  1027. my (@lines, $key, $value, $inBlock, $commentBlock, %blocks);
  1028. my $reader = new Utils::TextReader($file);
  1029. while (!$reader->eof()) {
  1030. my $lines = $reader->readLine();
  1031. $lines =~ s/x{FEFF}//g;
  1032. $lines =~ s/[rn]//g; # Remove line endings
  1033. if ($lines =~ /^[st]*#/ || $lines =~ /^[st]*$/ || $lines =~ /^!include( |$)/) {
  1034. push @lines, $lines;
  1035. next;
  1036. }
  1037. $lines =~ s/^[ts]*//; # Remove leading tabs and whitespace
  1038. $lines =~ s/s+$//g; # Remove trailing whitespace
  1040. if (!defined $commentBlock && $lines =~ /^/*/) {
  1041. push @lines, "$lines";
  1042. $commentBlock = 1;
  1043. next;
  1045. } elsif ($lines =~ m/*/$/) {
  1046. push @lines, "$lines";
  1047. undef $commentBlock;
  1048. next;
  1050. } elsif ($commentBlock) {
  1051. push @lines, "$lines";
  1052. next;
  1054. } elsif (!defined $inBlock && $lines =~ /{$/) {
  1055. # Begin of block
  1056. $lines =~ s/ *{$//;
  1057. ($key, $value) = $lines =~ /^(.*?) (.*)/;
  1058. $key = $lines if ($key eq '');
  1060. if (!exists $blocks{$key}) {
  1061. $blocks{$key} = 0;
  1062. } else {
  1063. $blocks{$key}++;
  1064. }
  1065. if ($key ne 'teleportAuto'){
  1066. $inBlock = "${key}_$blocks{$key}";
  1067. } else {
  1068. $inBlock = "${key}";
  1069. }
  1071. my $line = $key;
  1072. $line .= " $r_hash->{$inBlock}" if ($r_hash->{$inBlock} ne '');
  1073. push @lines, "$line {";
  1075. } elsif (defined $inBlock && $lines eq "}") {
  1076. # End of block
  1077. undef $inBlock;
  1078. push @lines, "}";
  1080. } else {
  1081. # Option
  1082. ($key, $value) = $lines =~ /^(.*?) (.*)/;
  1083. if ($key eq "") {
  1084. $key = $lines;
  1085. $key =~ s/ *$//;
  1086. }
  1087. if (defined $inBlock) {
  1088. my $realKey = "${inBlock}_${key}";
  1089. my $line = "t$key";
  1090. $line .= " $r_hash->{$realKey}" if ($r_hash->{$realKey} ne '');
  1091. push @lines, $line;
  1092. } else {
  1093. my $line = $key;
  1094. $line .= " $r_hash->{$key}" if ($r_hash->{$key} ne '');
  1095. push @lines, $line;
  1096. }
  1097. }
  1098. }
  1099. close FILE;
  1101. open FILE, ">:utf8", $file;
  1102. print FILE join("n", @lines) . "n";
  1103. close FILE;
  1104. }
  1106. sub writeDataFileIntact2 {
  1107. my $file = shift;
  1108. my $r_hash = shift;
  1109. my $data;
  1110. my $key;
  1112. my $reader = new Utils::TextReader($file);
  1113. while (!$reader->eof()) {
  1114. my $line = $reader->readLine();
  1115. $line =~ s/x{FEFF}//g;
  1116. if ($line =~ /^#/ || $line =~ /^n/ || $line =~ /^r/) {
  1117. $data .= $line;
  1118. next;
  1119. }
  1120. ($key) = $line =~ /^(w+)/;
  1121. $data .= $key;
  1122. $data .= " $$r_hash{$key}{'timeout'}" if $$r_hash{$key}{'timeout'} ne '';
  1123. $data .= "n";
  1124. }
  1125. close FILE;
  1126. open(FILE, ">:utf8", $file);
  1127. print FILE $data;
  1128. close FILE;
  1129. }
  1131. sub writePortalsLOS {
  1132. my $file = shift;
  1133. my $r_hash = shift;
  1134. open(FILE, "+> $file");
  1135. foreach my $key (sort keys %{$r_hash}) {
  1136. next if (!$$r_hash{$key} || !(keys %{$$r_hash{$key}}));
  1137. print FILE $key;
  1138. foreach (keys %{$$r_hash{$key}}) {
  1139. print FILE " $_ $$r_hash{$key}{$_}";
  1140. }
  1141. print FILE "n";
  1142. }
  1143. close FILE;
  1144. }
  1146. sub writeSectionedFileIntact {
  1147. my $file = shift;
  1148. my $r_hash = shift;
  1149. my $section = "";
  1150. my @lines;
  1152. my $reader = new Utils::TextReader($file);
  1153. while (!$reader->eof()) {
  1154. my $line = $reader->readLine();
  1155. $line =~ s/[rn]//g;
  1156. if ($line =~ /^#/ || $line =~ /^ *$/) {
  1157. push @lines, $line;
  1158. next;
  1159. }
  1161. if ($line =~ /^[(.*)]$/) {
  1162. $section = $1;
  1163. push @lines, $line;
  1164. } else {
  1165. my ($key, $value);
  1166. if ($line =~ / /) {
  1167. ($key) = $line =~ /^(.*?) /;
  1168. } else {
  1169. $key = $line;
  1170. }
  1171. $value = $r_hash->{$section}{$key};
  1172. push @lines, "$key $value";
  1173. }
  1174. }
  1175. close FILE;
  1177. open(FILE, ">:utf8", $file);
  1178. print FILE join("n", @lines) . "n";
  1179. close FILE;
  1180. }
  1182. sub updateMonsterLUT {
  1183. my $file = shift;
  1184. my $ID = shift;
  1185. my $name = shift;
  1186. open FILE, ">>:utf8", $file;
  1187. print FILE "$ID $namen";
  1188. close FILE;
  1189. }
  1191. sub updatePortalLUT {
  1192. my ($file, $src, $x1, $y1, $dest, $x2, $y2) = @_;
  1193. open FILE, ">> $file";
  1194. print FILE "$src $x1 $y1 $dest $x2 $y2n";
  1195. close FILE;
  1196. }
  1198. sub updateNPCLUT {
  1199. my ($file, $location, $name) = @_;
  1200. return unless $name;
  1201. open FILE, ">>:utf8", $file;
  1202. print FILE "$location $namen";
  1203. close FILE;
  1204. }
  1206. 1;