API tools faq
paste
Advertisement
Guest User

writer.pl (Child:396/Child:397)

a guest
Apr 30th, 2014
328
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Perl 38.80 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/perl
  2. #
  3. # Copyright 2013 by Denis Erygin,
  4. # denis.erygin@gmail.com
  5. #
  6.  
  7. use JSON::XS;
  8. use DBI;
  9. use warnings;
  10. use strict;
  11.  
  12. use constant {
  13.     INSTANCE  => 11,      # Chernarus instance
  14.     DB_NAME   => 'dayz_epoch1042', # Set database name
  15.     DB_LOGIN  => 'dayz',  # Set database login
  16.     DB_PASSWD => 'epoch1980',  # Set database password
  17.  
  18.     CACHE_DIR => $ENV{'PWD'}.'/cache/',
  19.     # Start inventory of player
  20.     INVENTORY => '[[],[]]',
  21.     BACKPACK  => '["",[],[]]',
  22.     MODEL     => '"Survivor2_DZ"'
  23. };
  24.  
  25. my %cid_inv = ();
  26. my %obj_inv = ();
  27.  
  28. my $myPlayerCounter = 1;
  29.  
  30. my %FN_IPC  = (
  31.     11  => \&h_player_counter,
  32.     21  => \&h_player_split_inventory,
  33.     22  => \&h_player_split_backpack,
  34.     31  => \&h_object_change_lock_code,
  35.     33  => \&h_object_split_inventory,
  36.     39  => \&h_object_uid_split_inventory,
  37.     101 => \&h_load_player,
  38.     103 => \&h_log_login,
  39.     201 => \&h_player_update,
  40.     202 => \&h_player_death,
  41.     204 => \&h_player_disconnect,
  42.     303 => \&h_object_update_inventory,
  43.     304 => \&h_object_delete,
  44.     305 => \&h_vehicle_moved,
  45.     306 => \&h_vehicle_damaged,
  46.     308 => \&h_object_publish,
  47.     309 => \&h_object_uid_update_inventory,
  48.     310 => \&h_object_uid_delete,
  49. ### jahan start    
  50.     396 => \&h_object_reset_damage,
  51.     397 => \&h_object_uid_reset_damage,
  52. ### jahan end
  53.     398 => \&h_trade_object,
  54. );
  55.  
  56. my $dbh   = connect_to_db();
  57. my $coder = JSON::XS->new->ascii(1)->shrink(1)->allow_nonref(1)->max_depth(5)->max_size(1048576);
  58.  
  59. mkdir (CACHE_DIR) unless (-d CACHE_DIR);
  60.  
  61. init_traders           ();
  62. init_objects_id        ();
  63. init_objects           ();
  64. init_default_player    ();
  65. init_default_character ();
  66. update_players_cache   ();
  67.  
  68. open (LOG, ">>dump.log") or die $!;
  69. while (<STDIN>) {
  70.     next if ($_ =~ m/Duplicate magazine/ || $_ =~ m/arrived from nonowner/);
  71.     print STDERR $_;
  72.     print LOG $_;
  73.  
  74.     if ($_ =~ m/CHILD:/) {
  75.         chop;
  76.         my ($pref, $data) = split /CHILD:/ => $_;
  77.         my @arr = split /:/ => $data;
  78.         my $cmd = $arr[0];
  79.         next unless $cmd;
  80.        
  81.         my $fn = $FN_IPC{$cmd};
  82.         $fn->(\@arr) if $fn;
  83.     } else {
  84.         init_login_uid ($_);
  85.     }
  86. }
  87. close(LOG);
  88.  
  89. $dbh->disconnect;
  90. exit;
  91.  
  92. #---------------------------------------------------------------------------
  93. sub connect_to_db {
  94.     my $dbh = DBI->connect('dbi:mysql:'.DB_NAME, DB_LOGIN, DB_PASSWD,
  95.               {'PrintError' => 1, 'RaiseError' => 1, 'AutoCommit' => 1})
  96.               or die "Can't connect to mysql: $!";
  97.     $dbh->{'mysql_auto_reconnect'} = 1;
  98.     return $dbh;
  99. }
  100.  
  101. sub parse_json {
  102.     my $str = shift;
  103.     return unless $str;
  104.    
  105.     my $data;
  106.     eval { $data = $coder->decode ($str); };
  107.     return if $@;
  108.     return $data;
  109. }
  110.  
  111. sub init_traders {
  112.     h_load_trader_details();
  113. }
  114.  
  115. sub init_objects_id {
  116.     h_load_objects_id();
  117. }
  118.  
  119. sub init_objects {
  120.     h_stream_objects();
  121. }
  122.  
  123. sub init_default_player {
  124.     my $file = CACHE_DIR.'players/default.sqf';
  125.     open  (OUT, ">$file") or die "Can't open '$file'";
  126.     print OUT '["PASS",false,"1",[],'.INVENTORY.','.BACKPACK.',[0,0,0],'.MODEL.',0.96]';
  127.     close (OUT);
  128. }
  129.  
  130. sub init_default_character {
  131.     my $file = CACHE_DIR.'players/default-char.sqf';
  132.     open  (OUT, ">$file") or die "Can't open '$file'";
  133.     print OUT '["PASS",[],[0,0,0,0],[],[],2500,"1"]';
  134.     close (OUT);
  135. }
  136.  
  137. sub update_players_cache {
  138.     my $sql = 'SELECT PlayerUID FROM Player_DATA';
  139.     my $sth = $dbh->prepare ($sql);
  140.     my $res = $sth->execute ();
  141.     return unless $res;
  142.    
  143.     my $PLAYERS_DIR = CACHE_DIR.'players/'.$myPlayerCounter;
  144.     mkdir ($PLAYERS_DIR) unless (-d $PLAYERS_DIR);
  145.    
  146.     my @uids = ();
  147.     while (my ($playerId) = $sth->fetchrow_array) {
  148.         next unless $playerId;
  149.         my $file = $PLAYERS_DIR.'/'.$playerId.'.sqf';
  150.         next if (-f $file);
  151.    
  152.         push @uids, $playerId;
  153.     }
  154.     $sth->finish;
  155.     return unless @uids;
  156.    
  157.     for my $playerId (@uids) {
  158.         update_player_cache ($playerId);
  159.     }
  160. }
  161.  
  162. sub get_playerId_by_characterId {
  163.     my $characterId = shift;
  164.     return unless $characterId;
  165.    
  166.     my $sql = 'SELECT PlayerUID FROM Character_DATA WHERE CharacterID=?';
  167.     my $sth = $dbh->prepare ($sql);
  168.     my $res = $sth->execute ($characterId);
  169.     return unless $res;
  170.    
  171.     my ($playerId) = $sth->fetchrow_array;
  172.     $sth->finish;
  173.    
  174.     return $playerId;
  175. }
  176.  
  177. sub update_player_cache {
  178.     my $playerId = shift;
  179.     return unless $playerId;
  180.  
  181.     my $sql = "SELECT CharacterID, Worldspace, Inventory, Backpack,
  182.               TIMESTAMPDIFF(MINUTE, Datestamp, LastLogin) as SurvivalTime,
  183.               TIMESTAMPDIFF(MINUTE, LastAte, NOW()) as MinsLastAte,
  184.               TIMESTAMPDIFF(MINUTE, LastDrank, NOW()) as MinsLastDrank,
  185.               Model, Humanity, KillsZ, HeadshotsZ, KillsH, KillsB, CurrentState, Medical
  186.               FROM Character_DATA
  187.               WHERE PlayerUID=? AND Alive = 1 AND InstanceID=? ORDER BY CharacterID DESC LIMIT 1";
  188.     my $sth = $dbh->prepare ($sql);
  189.     my $res = $sth->execute ($playerId, INSTANCE);
  190.     #return unless $res;
  191.    
  192.     my ($characterId, $worldSpace, $inventory, $backpack, $survivalTime, $minsLastAte, $minsLastDrank, $model,
  193.         $humanity, $killsZ, $headshotsZ, $killsH, $killsB, $currentState, $medical) = $sth->fetchrow_array;
  194.     $sth->finish;
  195.     return unless (defined $characterId);
  196.    
  197.     my $survival = '[0,0,0]';
  198.     $survival    = '['.$survivalTime.','.$minsLastAte.','.$minsLastDrank.']' if (defined $survivalTime &&
  199.                                                                                  defined $minsLastAte  &&
  200.                                                                                  defined $minsLastDrank);
  201.     my $PLAYERS_DIR = CACHE_DIR.'players/'.$myPlayerCounter;
  202.     mkdir ($PLAYERS_DIR) unless (-d $PLAYERS_DIR);
  203.                                                                                  
  204.     my $file = $PLAYERS_DIR.'/'.$playerId.'.sqf';
  205.     open  (OUT, ">$file") or print STDERR $!;
  206.     print OUT '["PASS",false,"'.$characterId.'",'.$worldSpace.','.$inventory.','.$backpack.','.$survival.','.$model.',0.96]';
  207.     close (OUT);
  208.        
  209.     my $stats = '[0,0,0,0]';
  210.     $stats    = '['.$killsZ.','.$headshotsZ.','.$killsH.','.$killsB.']' if (defined $killsZ && defined $headshotsZ && defined $killsH && defined $killsB);
  211.    
  212.     $file = $PLAYERS_DIR.'/'.$playerId.'-char.sqf';
  213.     open  (OUT, ">$file") or print STDERR $!;
  214.     print OUT '["PASS",'.$medical.','.$stats.','.$currentState.','.$worldSpace.','.$humanity.',"'.$characterId.'"]';
  215.     close (OUT);
  216.    
  217.     return $characterId;
  218. }
  219.  
  220. sub init_login_uid {
  221.     my $dump = shift;
  222.     return unless $dump;
  223.        
  224.     return unless ($dump =~ m/\sconnected/);
  225.     return if ($dump =~ m/BattlEye Server: Player/);
  226.    
  227.     my ($p, $str)   = split (/Player\s/, $dump);
  228.     return unless (defined $str);
  229.    
  230.     my ($name, $uid) = split (/\sconnected\s/, $str);
  231.     return unless ($name && $uid);
  232.    
  233.     if ($uid =~ m/(\d+)/) {
  234.         $uid = $1;
  235.     }
  236.     return unless $uid;
  237.     print STDERR "$uid => $name\n";
  238.    
  239.     #my $PLAYERS_DIR = CACHE_DIR.'players/'.$myPlayerCounter;
  240.     #my $file        = $PLAYERS_DIR.'/'.$uid.'.sqf';
  241.     #return if (-e $file);
  242.    
  243.     h_load_player ([101, $uid, INSTANCE, $name]);
  244. }
  245.  
  246. # 11
  247. sub h_player_counter {
  248.     my $p = shift;
  249.     return unless ($p && ref($p) eq 'ARRAY');
  250.     my ($cmd, $counter) = @$p;
  251.     return unless ($counter && int($counter) > 0);
  252.     $counter = int($counter);
  253.    
  254.     my $old = CACHE_DIR.'players/'.$myPlayerCounter;
  255.     my $new = CACHE_DIR.'players/'.$counter;
  256.     if (-d $old) {
  257.         rename ($old, $new);
  258.     } else {
  259.         print STDERR "Error h_player_counter($counter): old '$myPlayerCounter' not found!\n";
  260.         mkdir ($new) or print STDERR $!,"\n";
  261.     }
  262.    
  263.     $myPlayerCounter = $counter;
  264. }
  265.  
  266. # 21
  267. sub h_player_split_inventory {
  268.     my $p = shift;
  269.     return unless ($p && ref($p) eq 'ARRAY');
  270.     my ($cmd, $cid, $idx, $data) = @$p;
  271.     unless ($cid && defined $idx && defined $data) {
  272.         print STDERR "Error h_player_split_inventory(): characterId or idx or data undefined!\n";
  273.         return;
  274.     }
  275.  
  276.     unless ( parse_json ($data) ) {
  277.         print STDERR "Error h_player_split_inventory(): data invalid json!\n";
  278.         $cid_inv{$cid} = undef;
  279.         return;
  280.     }
  281.  
  282.     # Save weapons
  283.     if ($idx == 0) {
  284.         $cid_inv{$cid} = $data;
  285.         return;
  286.     }
  287.     # Save weapons + magazines
  288.     if ($idx == 1 && $cid_inv{$cid}) {
  289.         my $inv        = '['.$cid_inv{$cid}.','.$data.']';
  290.         $cid_inv{$cid} = undef;
  291.         print STDERR "Size plr inv: ".length($inv)."\n";
  292.  
  293.         unless ( parse_json($inv) ) {
  294.             print STDERR "Error h_player_split_inventory(): inventory invalid json!\n";
  295.             return;
  296.         }
  297.  
  298.         my $sth = $dbh->prepare ('UPDATE Character_DATA SET Inventory=? WHERE CharacterID=?');
  299.         my $res = $sth->execute ($cid, $inv);
  300.         return $res;
  301.     }
  302. }
  303.  
  304. # 22
  305. sub h_player_split_backpack {
  306.     my $p = shift;
  307.     return unless ($p && ref($p) eq 'ARRAY');
  308.     my ($cmd, $cid, $data) = @$p;
  309.     unless ($cid && defined $data) {
  310.         print STDERR "Error h_player_split_backpack(): characterId or data undefined!\n";
  311.         return;
  312.     }
  313.  
  314.     unless ( parse_json ($data) ) {
  315.         print STDERR "Error h_player_split_backpack(): backpack invalid json!\n";
  316.         return;
  317.     }
  318.     return if ($data eq '[]');
  319.  
  320.     my $sth = $dbh->prepare ('UPDATE Character_DATA SET Backpack=? WHERE CharacterID=?');
  321.     my $res = $sth->execute ($cid, $data);
  322.     return $res;
  323. }
  324.  
  325. # 31
  326. sub h_object_change_lock_code {
  327.     my $p = shift;
  328.     return unless ($p && ref($p) eq 'ARRAY');
  329.     my ($cmd, $oid, $code) = @$p;
  330.     unless ($oid && $code) {
  331.         print STDERR "Error h_object_change_lock_code(): objectId or code undefined!\n";
  332.         return;
  333.     }
  334.     $oid =~ s/"//g;
  335.    
  336.     my $sth = $dbh->prepare ('UPDATE Object_DATA SET CharacterID=? WHERE ObjectID=? AND Instance=?');
  337.     my $res = $sth->execute ($code, $oid, INSTANCE);
  338.     return $res;
  339. }
  340.  
  341. # 33
  342. sub h_object_split_inventory {
  343.     my $p = shift;
  344.     return unless ($p && ref($p) eq 'ARRAY');
  345.     my ($cmd, $oid, $idx, $data) = @$p;
  346.     unless ($oid && defined $idx && defined $data) {
  347.         print STDERR "Error h_object_split_inventory(): objectId or idx or data undefined!\n";
  348.         return;
  349.     }
  350.     $oid =~ s/"//g;
  351.  
  352.     unless ( parse_json ($data) ) {
  353.         print STDERR "Error h_object_split_inventory($oid): data invalid json!\n";
  354.         $obj_inv{$oid} = undef;
  355.         return;
  356.     }
  357.  
  358.     # Save weapons
  359.     if ($idx == 0) {
  360.         $obj_inv{$oid} = $data;
  361.         return;
  362.     }
  363.     # Save weapons + magazines
  364.     if ($idx == 1 && $obj_inv{$oid}) {
  365.         $obj_inv{$oid} .= ','.$data;
  366.         return;
  367.     }
  368.     # Save weapons + magazines + backpack
  369.     if ($idx == 2 && $obj_inv{$oid}) {
  370.         my $inv        = '['.$obj_inv{$oid}.','.$data.']';
  371.         $obj_inv{$oid} = undef;
  372.         print STDERR "Size obj inv: ".length($inv)."\n";
  373.  
  374.         unless ( parse_json($inv) ) {
  375.             print STDERR "Error h_object_split_inventory($oid): inventory invalid json!\n";
  376.             return;
  377.         }
  378.  
  379.         my $sth = $dbh->prepare ('UPDATE Object_DATA SET Inventory=? WHERE ObjectID=? AND Instance=?');
  380.         my $res = $sth->execute ($inv, $oid, INSTANCE);
  381.         return $res;
  382.     }
  383. }
  384.  
  385. # 39
  386. sub h_object_uid_split_inventory {
  387.     my $p = shift;
  388.     return unless ($p && ref($p) eq 'ARRAY');
  389.     my ($cmd, $uid, $idx, $data) = @$p;
  390.     unless ($uid && defined $idx && defined $data) {
  391.         print STDERR "Error h_object_uid_split_inventory(): objectUID or idx or data undefined!\n";
  392.         return;
  393.     }
  394.     $uid =~ s/"//g;
  395.  
  396.     unless ( parse_json ($data) ) {
  397.         print STDERR "Error h_object_uid_split_inventory($uid): data invalid json!\n";
  398.         $obj_inv{$uid} = undef;
  399.         return;
  400.     }
  401.  
  402.     # Save weapons
  403.     if ($idx == 0) {
  404.         $obj_inv{$uid} = $data;
  405.         return;
  406.     }
  407.     # Save weapons + magazines
  408.     if ($idx == 1 && $obj_inv{$uid}) {
  409.         $obj_inv{$uid} .= ','.$data;
  410.         return;
  411.     }
  412.     # Save weapons + magazines + backpack
  413.     if ($idx == 2 && $obj_inv{$uid}) {
  414.         my $inv        = '['.$obj_inv{$uid}.','.$data.']';
  415.         $obj_inv{$uid} = undef;
  416.         print STDERR "Size obj uid inv: ".length($inv)."\n";
  417.  
  418.         unless ( parse_json($inv) ) {
  419.             print STDERR "Error h_object_uid_split_inventory($uid): inventory invalid json!\n";
  420.             return;
  421.         }
  422.  
  423.         my $sth = $dbh->prepare ('UPDATE Object_DATA SET Inventory=? WHERE ObjectUID=? AND Instance=?');
  424.         my $res = $sth->execute ($inv, $uid, INSTANCE);
  425.         return $res;
  426.     }
  427. }
  428.  
  429. # 101
  430. sub h_load_player {
  431.     my $p = shift;
  432.     return unless ($p && ref($p) eq 'ARRAY');
  433.     my ($cmd, $playerId, $serverId, $playerName) = @$p;
  434.     unless ($playerId && $serverId) {
  435.         print STDERR "Error h_load_player(): playerId or serverId undefined!\n";
  436.         return;
  437.     }
  438.     $playerId =~ s/[A-Z"]//g;
  439.     $serverId ||= INSTANCE;
  440.    
  441.     my $PLAYERS_DIR = CACHE_DIR.'players/'.$myPlayerCounter;
  442.     mkdir ($PLAYERS_DIR) unless (-d $PLAYERS_DIR);
  443.    
  444.     my $sql = 'SELECT PlayerName, PlayerSex FROM Player_DATA WHERE PlayerUID=?';
  445.     my $sth = $dbh->prepare ($sql);
  446.     my $res = $sth->execute ($playerId);
  447.    
  448.     my ($name, $sex) = $sth->fetchrow_array;
  449.     $sth->finish;
  450.    
  451.     my $newPlayer = 0;
  452.     if (defined $name) {
  453.         if ($playerName && $playerName ne $name) {
  454.             $sql = 'UPDATE Player_DATA SET PlayerName=? WHERE PlayerUID=?';
  455.             $sth = $dbh->prepare ($sql);
  456.             $res = $sth->execute ($playerName, $playerId);
  457.             print STDERR "Changed name of player $playerId from '$name' to '$playerName'\n";
  458.         }
  459.     } else {
  460.         $newPlayer  = 1;
  461.         $playerName = 'Unknown' unless $playerName;
  462.        
  463.         $sql = 'INSERT INTO Player_DATA(PlayerUID, PlayerName) VALUES (?, ?)';
  464.         $sth = $dbh->prepare ($sql);
  465.         $res = $sth->execute ($playerId, $playerName);
  466.         print STDERR "Created a new player $playerId named '$playerName'\n";
  467.     }
  468.    
  469.     $sql = "SELECT CharacterID, Worldspace, Inventory, Backpack,
  470.            TIMESTAMPDIFF(MINUTE, Datestamp, LastLogin) as SurvivalTime,
  471.            TIMESTAMPDIFF(MINUTE, LastAte, NOW()) as MinsLastAte,
  472.            TIMESTAMPDIFF(MINUTE, LastDrank, NOW()) as MinsLastDrank,
  473.            Model, Medical, Humanity, KillsZ, HeadshotsZ, KillsH, KillsB, CurrentState  
  474.            FROM  Character_DATA
  475.            WHERE PlayerUID=? AND Alive = 1 AND InstanceID=? ORDER BY CharacterID DESC LIMIT 1";
  476.     $sth = $dbh->prepare ($sql);
  477.     $res = $sth->execute ($playerId, $serverId);
  478.    
  479.     my ($characterId, $worldSpace, $inventory, $backpack, $survivalTime, $minsLastAte, $minsLastDrank,
  480.         $model, $medical, $humanity, $killsZ, $headshotsZ, $killsH, $killsB, $currentState) = $sth->fetchrow_array;
  481.     $sth->finish;
  482.    
  483.     $currentState = '[]'      unless (defined $currentState);
  484.     $humanity     = 2500      unless (defined $humanity);
  485.     $medical      = '[]'      unless (defined $medical);
  486.     $worldSpace   = '[]'      unless (defined $worldSpace);
  487.     $inventory    = INVENTORY unless (defined $inventory);  # '[]'
  488.     $backpack     = BACKPACK  unless (defined $backpack);   # '[]'
  489.     $model        = MODEL     unless (defined $model);      # ''
  490.    
  491.     my $survival = '[0,0,0]';
  492.     $survival    = '['.$survivalTime.','.$minsLastAte.','.$minsLastDrank.']' if (defined $survivalTime &&
  493.                                                                                  defined $minsLastAte  &&
  494.                                                                                  defined $minsLastDrank);
  495.     my $newChar = 0;
  496.     if (defined $characterId) {
  497.         $sql = 'UPDATE Character_DATA SET LastLogin = CURRENT_TIMESTAMP WHERE CharacterID=?';
  498.         $sth = $dbh->prepare ($sql);
  499.         $res = $sth->execute ($characterId);
  500.        
  501.         my $stats = '[0,0,0,0]';
  502.         $stats    = '['.$killsZ.','.$headshotsZ.','.$killsH.','.$killsB.']' if (defined $killsZ && defined $headshotsZ &&
  503.                                                                                 defined $killsH && defined $killsB);        
  504.         my $file = $PLAYERS_DIR.'/'.$playerId.'-char.sqf';
  505.         open  (OUT, ">$file");
  506.         print OUT '["PASS",'.$medical.','.$stats.','.$currentState.','.$worldSpace.','.$humanity.',"'.$characterId.'"]';
  507.         close (OUT);
  508.     } else {
  509.         $newChar = 1;
  510.        
  511.         $sql = "SELECT Generation, Humanity, Model FROM Character_DATA
  512.                WHERE PlayerUID=? AND Alive = 0 AND InstanceID=? ORDER BY CharacterID DESC LIMIT 1";
  513.         $sth = $dbh->prepare ($sql);
  514.         $res = $sth->execute ($playerId, $serverId);
  515.        
  516.         my ($generation, $humanity, $cmodel) = $sth->fetchrow_array;
  517.         $sth->finish;
  518.        
  519.         if (defined $generation) {
  520.             $generation++;
  521.         } else {
  522.             $generation = 1;
  523.         }
  524.        
  525.         $humanity = 2500    unless (defined $humanity);
  526.         $model    = $cmodel if (defined $cmodel);
  527.        
  528.         $sql = "INSERT INTO Character_DATA(PlayerUID, InstanceID, Worldspace, Inventory, Backpack, Medical,
  529.                                           Generation, Datestamp, LastLogin, LastAte, LastDrank, Humanity)
  530.                VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, ?)";
  531.         $sth = $dbh->prepare ($sql);
  532.         $res = $sth->execute ($playerId, $serverId, $worldSpace, $inventory, $backpack, $medical, $generation, $humanity);
  533.        
  534.         $sql = 'SELECT CharacterID FROM Character_DATA WHERE PlayerUID=? AND Alive = 1 AND InstanceID=? ORDER BY CharacterID DESC LIMIT 1';
  535.         $sth = $dbh->prepare ($sql);
  536.         $res = $sth->execute ($playerId, $serverId);
  537.        
  538.         ($characterId) = $sth->fetchrow_array;
  539.         $sth->finish;
  540.        
  541.         $playerName = 'Unknown' unless $playerName;
  542.        
  543.         if (defined $characterId) {
  544.             print STDERR "Created a new character $characterId for player '$playerName' ($playerId)\n";
  545.             my $file = $PLAYERS_DIR.'/'.$playerId.'-char.sqf';
  546.             open  (OUT, ">$file");
  547.             print OUT '["PASS",'.$medical.',[0,0,0,0],[],'.$worldSpace.','.$humanity.',"'.$characterId.'"]';
  548.             close (OUT);
  549.         } else {
  550.             print STDERR "Can't found new character for player '$playerName' ($playerId)\n";
  551.         }
  552.     }
  553.    
  554.     my $file = $PLAYERS_DIR.'/'.$playerId.'.sqf';
  555.     open  (OUT, ">$file");
  556.     print OUT '["PASS",false,"'.$characterId.'",'.$worldSpace.','.$inventory.','.$backpack.','.$survival.','.$model.',0.96]';
  557.     close (OUT);
  558.    
  559.     print STDERR "Save player: $file\n";
  560.     return $res;
  561. }
  562.  
  563. # 102
  564. sub h_load_character {
  565.     my $p = shift;
  566.     return unless ($p && ref($p) eq 'ARRAY');
  567.     my ($cmd, $characterId, $playerId) = @$p;
  568.     unless ($characterId) {
  569.         print STDERR "Error h_load_character(): characterId undefined!\n";
  570.         return;
  571.     }
  572.     $characterId =~ s/"//g;
  573.     $playerId    =~ s/[A-Z"]//g;
  574.    
  575.     if ($characterId == 1 && $playerId) {
  576.         my $sql = 'SELECT CharacterID FROM Character_DATA WHERE PlayerUID=? AND Alive = 1 AND InstanceID=? ORDER BY CharacterID DESC LIMIT 1';
  577.         my $sth = $dbh->prepare ($sql);
  578.         my $res = $sth->execute ($playerId, INSTANCE);
  579.         return unless $res;
  580.        
  581.         ($characterId) = $sth->fetchrow_array;
  582.         $sth->finish;
  583.     }
  584.     unless ($characterId) {
  585.         print STDERR "Error h_load_character(): characterId undefined!\n";
  586.         return;
  587.     }
  588.    
  589.     my $sql = "SELECT Worldspace, Medical, Generation, KillsZ, HeadshotsZ, KillsH, KillsB, CurrentState, Humanity, PlayerUID
  590.               FROM Character_DATA WHERE CharacterID=?";
  591.     my $sth = $dbh->prepare ($sql);
  592.     my $res = $sth->execute ($characterId);
  593.    
  594.     my ($worldSpace, $medical, $generation, $killsZ, $headshotsZ, $killsH, $killsB, $currentState, $humanity, $playerUID) = $sth->fetchrow_array;
  595.     $sth->finish;
  596.     return unless (defined $worldSpace);
  597.    
  598.     $playerId = $playerUID if (defined $playerUID);
  599.    
  600.     $worldSpace   ||= '[]';
  601.     $medical      ||= '[]';
  602.     $generation   ||= 1;
  603.     $currentState ||= '[]';
  604.     $humanity       = 2500 unless (defined $humanity);
  605.    
  606.     my $stats = '[0,0,0,0]';
  607.     $stats    = '['.$killsZ.','.$headshotsZ.','.$killsH.','.$killsB.']' if (defined $killsZ && defined $headshotsZ &&
  608.                                                                             defined $killsH && defined $killsB);
  609.    
  610.     my $file = CACHE_DIR.'players/'.$myPlayerCounter.'/'.$playerId.'-char.sqf';
  611.     open  (OUT, ">$file");
  612.     print OUT '["PASS",'.$medical.','.$stats.','.$currentState.','.$worldSpace.','.$humanity.',"'.$characterId.'"]';
  613.     close (OUT);
  614.    
  615.     print STDERR "Save character: $file\n";
  616.     return $res;
  617. }
  618.  
  619. # 103
  620. sub h_log_login {
  621.     my $p = shift;
  622.     return unless ($p && ref($p) eq 'ARRAY');
  623.     my ($cmd, $playerId, $characterId, $action) = @$p;
  624.     unless ($playerId) {
  625.         print STDERR "Error h_log_login(): playerId undefined!\n";
  626.         return;
  627.     }
  628.     $playerId    =~ s/[A-Z"]//g;
  629.     $characterId =~ s/"//g;
  630.    
  631.     my $sql = 'INSERT INTO Player_LOGIN(PlayerUID, CharacterID, Datestamp, Action) VALUES (?, ?, CURRENT_TIMESTAMP, ?)';
  632.     my $sth = $dbh->prepare ($sql);
  633.     my $res = $sth->execute ($playerId, $characterId, $action);
  634.     return $res;
  635. }
  636.  
  637. # 201
  638. sub h_player_update {
  639.     my $p = shift;
  640.     return unless ($p && ref($p) eq 'ARRAY');
  641.     my ($cmd, $characterId, $worldSpace, $inventory, $backpack, $medical, $justAte, $justDrank,
  642.         $killsZ, $headshotsZ, $distanceWalked, $durationLived, $currentState, $killsH, $killsB, $model,
  643.         $humanity) = @$p;
  644.     unless ($characterId) {
  645.         print STDERR "Error h_player_update(): characterId undefined!\n";
  646.         return;
  647.     }
  648.     $characterId =~ s/"//g;
  649.    
  650.     if ($worldSpace) {
  651.         my $ws = parse_json ($worldSpace);
  652.         unless ($ws) {
  653.             print STDERR "Error h_player_update(): worldSpace invalid json!\n";
  654.             return;
  655.         }
  656.         if (@$ws) {
  657.             if ($ws->[1] && ref($ws->[1]) eq 'ARRAY') {
  658.                 my ($x, $y) = @{$ws->[1]};
  659.                 if ($x && $x < -18000) {
  660.                     print STDERR "Error h_player_update(): worldSpace invalid!\n";
  661.                     return;
  662.                 }
  663.             }
  664.         }
  665.     }
  666.     if ($inventory) {
  667.         unless ( parse_json ($inventory) ) {
  668.             print STDERR "Error h_player_update(): inventory invalid json!\n";
  669.             $inventory = undef;
  670.         }
  671.     }
  672.     if ($backpack) {
  673.         unless ( parse_json ($backpack) ) {
  674.             print STDERR "Error h_player_update(): backpack invalid json!\n";
  675.             $backpack = undef;
  676.         }
  677.     }
  678.     if ($medical) {
  679.         unless ( parse_json ($medical) ) {
  680.             print STDERR "Error h_player_update(): medical invalid json!\n";
  681.             $medical = undef;
  682.         }
  683.     }
  684.     if ($currentState) {
  685.         unless ( parse_json ($currentState) ) {
  686.             print STDERR "Error h_player_update(): currentState invalid json!\n";
  687.             $currentState = undef;
  688.         }
  689.     }
  690.     if ($model) {
  691.         unless ( parse_json ($model) ) {
  692.             print STDERR "Error h_player_update(): model invalid json!\n";
  693.             $model = undef;
  694.         }
  695.     }
  696.    
  697.     my $str = '';
  698.     $str .= 'Worldspace='.$dbh->quote($worldSpace).','            if ($worldSpace && $worldSpace ne '[]');
  699.     $str .= 'Inventory='.$dbh->quote($inventory).','              if ($inventory  && $inventory  ne INVENTORY && $inventory ne '[]');
  700.     $str .= 'Backpack='.$dbh->quote($backpack).','                if ($backpack   && $backpack   ne BACKPACK && $backpack ne '[]');
  701.     $str .= 'Medical='.$dbh->quote($medical).','                  if ($medical    && $medical    ne '[]');
  702.     $str .= 'CurrentState='.$dbh->quote($currentState).','        if ($currentState && $currentState ne '[]');
  703.     $str .= 'Model='.$dbh->quote($model).','                      if ($model && $model ne MODEL);
  704.    
  705.     $str .= 'LastAte=CURRENT_TIMESTAMP,'                          if ($justAte   && $justAte   eq 'true');
  706.     $str .= 'LastDrank=CURRENT_TIMESTAMP,'                        if ($justDrank && $justDrank eq 'true');
  707.    
  708.     $str .= 'KillsZ=KillsZ+'.int($killsZ).','                     if ($killsZ     && $killsZ > 0);
  709.     $str .= 'HeadshotsZ=HeadshotsZ+'.int($headshotsZ).','         if ($headshotsZ && $headshotsZ > 0);
  710.     $str .= 'DistanceFoot=DistanceFoot+'.int($distanceWalked).',' if ($distanceWalked && $distanceWalked > 0);
  711.     $str .= 'KillsH=KillsH+'.int($killsH).','                     if ($killsH     && $killsH > 0);
  712.     $str .= 'KillsB=KillsB+'.int($killsB).','                     if ($killsB     && $killsB > 0);
  713.    
  714.     if ($humanity) {    
  715.         if ($humanity < 0) {
  716.             $str .= 'Humanity=Humanity-'.int(-1*$humanity).',';
  717.         } else {
  718.             $str .= 'Humanity=Humanity+'.int($humanity).',';
  719.         }
  720.     }
  721.      
  722.     return unless $str;
  723.    
  724.     $str .= 'Duration=Duration+'.int($durationLived || 0);
  725.    
  726.     my $sql = 'UPDATE Character_DATA SET ';
  727.     $sql   .= $str;
  728.     $sql   .= ' WHERE CharacterID=?';
  729.    
  730.     my $sth = $dbh->prepare ($sql);
  731.     my $res = $sth->execute ($characterId);
  732.     return $res;
  733. }
  734.  
  735. # 202
  736. sub h_player_death {
  737.     my $p = shift;
  738.     return unless ($p && ref($p) eq 'ARRAY');
  739.     my ($cmd, $characterId, $duration) = @$p;
  740.     unless ($characterId) {
  741.         print STDERR "Error h_player_death(): characterId undefined!\n";
  742.         return;
  743.     }
  744.     $characterId =~ s/"//g;
  745.    
  746.     my $sql =  "UPDATE Character_DATA SET Alive = 0, LastLogin = DATE_SUB(CURRENT_TIMESTAMP, INTERVAL ? MINUTE)
  747.                WHERE CharacterID=? AND Alive = 1";
  748.     my $sth = $dbh->prepare ($sql);
  749.     my $res = $sth->execute (int($duration), $characterId);
  750.     return unless $res;    
  751.    
  752.     # Reset profile
  753.     my $playerId = get_playerId_by_characterId ($characterId);
  754.     if ($playerId) {    
  755.         h_load_player ([101, $playerId, INSTANCE]);
  756.     } else {
  757.         print STDERR "Error h_player_death('$characterId'): playerId not found!\n";
  758.     }
  759. }
  760.  
  761. # 204
  762. sub h_player_disconnect {
  763.     my $p = shift;
  764.     return unless ($p && ref($p) eq 'ARRAY');
  765.     my ($cmd, $playerId) = @$p;
  766.     $playerId =~ s/[A-Z"]//g;
  767.    
  768.     update_player_cache ($playerId);
  769. }
  770.  
  771. # 302
  772. sub h_stream_objects {
  773.     # Clean objects
  774.     for my $sql ('DELETE FROM Object_DATA WHERE Instance=? AND ClassName="TentStorage" AND (Inventory="[[[],[]],[[],[]],[[],[]]]" OR Damage=1)',
  775.                  'DELETE FROM Object_DATA where Instance=? AND Damage > 0.9 AND ObjectID > 89') {
  776.         my $sth = $dbh->prepare ($sql);
  777.         $sth->execute (INSTANCE);
  778.     }
  779.    
  780.     my $sql = "SELECT ObjectID, CharacterID, Worldspace, Inventory, Hitpoints, Fuel, Damage
  781.                 FROM Object_init_DATA WHERE Instance=? AND Classname IS NOT NULL ORDER BY ObjectID";
  782.     my $sth = $dbh->prepare ($sql);
  783.     my $res = $sth->execute (INSTANCE);
  784.     return unless $res;
  785.    
  786.     my %init = ();
  787.     while (my ($objId, $ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage) = $sth->fetchrow_array) {
  788.         next unless $objId;
  789.  
  790.         $ownerId    ||= 0;
  791.         $worldSpace ||= '[]';
  792.         $inventory  ||= '[]';
  793.         $hitpoints  ||= '[]';
  794.         $fuel       ||= 0;
  795.         $damage     ||= 0;
  796.    
  797.         $init{$objId} = [$ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage];
  798.     }
  799.     $sth->finish;
  800.    
  801.     $sql = "SELECT ObjectID, Classname, CharacterID, Worldspace, Inventory, Hitpoints, Fuel, Damage
  802.            FROM Object_DATA WHERE Instance=? AND Classname IS NOT NULL ORDER BY ObjectID";
  803.     $sth = $dbh->prepare ($sql);
  804.     $res = $sth->execute (INSTANCE);
  805.     return unless $res;
  806.    
  807.     my $str     = '';
  808.     my @updates = ();
  809.     while (my ($objId, $className, $ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage) = $sth->fetchrow_array) {
  810.         if ( $objId && $damage && $damage > 0.7 && $init{$objId} ) {
  811.             print STDERR "Respawn '$className' ($objId)\n";
  812.             ($ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage) = @{$init{$objId}};
  813.             push @updates, $objId;
  814.         }
  815.        
  816.         $ownerId    ||= 0;
  817.         $worldSpace ||= '[]';
  818.         $inventory  ||= '[]';
  819.         $hitpoints  ||= '[]';
  820.         $fuel       ||= 0;
  821.         $damage     ||= 0;
  822.        
  823.         $fuel   = sprintf ("%.3f", $fuel);
  824.         $damage = sprintf ("%.3f", $damage);
  825.        
  826.         $str .= ',' if $str;
  827.         $str .= '["OBJ","'.$objId.'","'.$className.'","'.$ownerId.'",'.$worldSpace.','.$inventory.','.$hitpoints.','.$fuel.','.$damage.']';
  828.     }
  829.     $sth->finish;
  830.    
  831.     for my $objId (@updates) {
  832.         my ($ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage) = @{$init{$objId}};
  833.         $sql = 'UPDATE Object_DATA SET CharacterID=?, Worldspace=?, Inventory=?, Hitpoints=?, Fuel=?, Damage=? WHERE Instance=? AND ObjectID=?';
  834.         $sth = $dbh->prepare ($sql);
  835.         $res = $sth->execute ($ownerId, $worldSpace, $inventory, $hitpoints, $fuel, $damage, INSTANCE, $objId);
  836.     }    
  837.     #return unless $str;
  838.    
  839.     my $file = CACHE_DIR.'objects.sqf';
  840.     open  (OUT, ">$file");
  841.     print OUT '['.$str.']';
  842.     close (OUT);    
  843. }
  844.  
  845. # 303
  846. sub h_object_update_inventory {
  847.     my $p = shift;
  848.     return unless ($p && ref($p) eq 'ARRAY');
  849.     my ($cmd, $objectId, $inventory) = @$p;
  850.     unless ($objectId && $inventory) {
  851.         print STDERR "Error h_object_update_inventory(): objectId or inventory undefined!\n";
  852.         return;
  853.     }
  854.     $objectId =~ s/"//g;
  855.    
  856.     unless ( parse_json ($inventory) ) {
  857.         print STDERR "Error h_object_update_inventory($objectId): inventory invalid json!\n";
  858.         return;
  859.     }
  860.    
  861.     my $sql = 'UPDATE Object_DATA SET Inventory=? WHERE ObjectID=? AND Instance=?';
  862.     my $sth = $dbh->prepare ($sql);
  863.     my $res = $sth->execute ($inventory, $objectId, INSTANCE);
  864.     return $res;
  865. }
  866.  
  867. # 304
  868. sub h_object_delete {
  869.     my $p = shift;
  870.     return unless ($p && ref($p) eq 'ARRAY');
  871.     my ($cmd, $objectId) = @$p;
  872.     unless ($objectId) {
  873.         print STDERR "Error h_object_delete(): objectId undefined!\n";
  874.         return;
  875.     }
  876.     $objectId =~ s/"//g;
  877.    
  878.     my $sql = 'DELETE FROM Object_DATA WHERE ObjectID=? AND Instance=?';
  879.     my $sth = $dbh->prepare ($sql);
  880.     my $res = $sth->execute ($objectId, INSTANCE);
  881.    
  882.     if ($res) {
  883.         $sql = 'DELETE FROM Object_init_DATA WHERE ObjectID=? AND Instance=?';
  884.         $sth = $dbh->prepare ($sql);
  885.         $res = $sth->execute ($objectId, INSTANCE);
  886.     }    
  887.     return $res;
  888. }
  889.  
  890. # 305
  891. sub h_vehicle_moved {
  892.     my $p = shift;
  893.     return unless ($p && ref($p) eq 'ARRAY');
  894.     my ($cmd, $objectId, $worldSpace, $fuel) = @$p;
  895.     unless ($objectId && $worldSpace) {
  896.         print STDERR "Error h_vehicle_moved(): objectId undefined!\n";
  897.         return;
  898.     }
  899.     $objectId =~ s/"//g;
  900.    
  901.     unless ( parse_json ($worldSpace) ) {
  902.         print STDERR "Error h_vehicle_moved($objectId): worldSpace invalid json!\n";
  903.         return;
  904.     }
  905.    
  906.     my $sql = 'UPDATE Object_DATA SET Worldspace=?, Fuel=? WHERE ObjectID=? AND Instance=?';
  907.     my $sth = $dbh->prepare ($sql);
  908.     my $res = $sth->execute ($worldSpace, $fuel, $objectId, INSTANCE);
  909.     return $res;
  910. }
  911.  
  912. # 306
  913. sub h_vehicle_damaged {
  914.     my $p = shift;
  915.     return unless ($p && ref($p) eq 'ARRAY');
  916.     my ($cmd, $objectId, $hitPoints, $damage) = @$p;
  917.     unless ($objectId && defined $hitPoints && defined $damage) {
  918.         print STDERR "Error h_vehicle_damaged(): objectId undefined!\n";
  919.         return;
  920.     }
  921.     $objectId =~ s/"//g;
  922.    
  923.     if ($hitPoints) {
  924.         unless ( parse_json ($hitPoints) ) {
  925.             print STDERR "Error h_vehicle_damaged($objectId): hitPoints invalid json!\n";
  926.             return;
  927.         }
  928.     }
  929.    
  930.     $hitPoints ||= '[]';
  931.     $damage    ||= 0;
  932.    
  933.     my $sql = 'UPDATE Object_DATA SET Hitpoints=?, Damage=? WHERE ObjectID=? AND Instance=?';
  934.     my $sth = $dbh->prepare ($sql);
  935.     my $res = $sth->execute ($hitPoints, $damage, $objectId, INSTANCE);
  936.     return $res;
  937. }
  938.  
  939. # 308
  940. sub h_object_publish {
  941.     my $p = shift;
  942.     return unless ($p && ref($p) eq 'ARRAY');
  943.     my ($cmd, $serverId, $className, $damage, $characterId, $worldSpace, $inventory, $hitPoints, $fuel, $objectUID) = @$p;
  944.     unless ($className) {
  945.         print STDERR "Error h_object_publish(): className undefined!\n";
  946.         return;
  947.     }
  948.     $characterId =~ s/"//g;
  949.     $objectUID   =~ s/"//g;
  950.    
  951.     if ($worldSpace) {
  952.         unless ( parse_json ($worldSpace) ) {
  953.             print STDERR "Error h_object_publish($className): worldSpace invalid json!\n";
  954.             return;
  955.         }
  956.     }
  957.     if ($inventory) {
  958.         unless ( parse_json ($inventory) ) {
  959.             print STDERR "Error h_object_publish($className): inventory invalid json!\n";
  960.             $inventory = '[]';
  961.         }
  962.     }
  963.     if ($hitPoints) {
  964.         unless ( parse_json ($hitPoints) ) {
  965.             print STDERR "Error h_object_publish($className): hitPoints invalid json!\n";
  966.             $hitPoints = '[]';
  967.         }
  968.     }
  969.    
  970.     $serverId   ||= INSTANCE;
  971.     $worldSpace ||= '[]';
  972.     $inventory  ||= '[]';
  973.     $hitPoints  ||= '[]';
  974.     $damage     ||= 0;
  975.     $fuel       ||= 0;
  976.    
  977.     my $sql = "INSERT INTO Object_DATA(ObjectUID, Instance, Classname, Damage, CharacterID, Worldspace, Inventory,
  978.                                       Hitpoints, Fuel, Datestamp)
  979.               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)";
  980.     my $sth = $dbh->prepare ($sql);
  981.     my $res = $sth->execute ($objectUID, $serverId, $className, $damage, $characterId, $worldSpace, $inventory, $hitPoints, $fuel);
  982.    
  983.     # Cache object ID
  984.     $sql = 'SELECT ObjectID FROM Object_DATA WHERE ObjectUID=? AND Instance=?';
  985.     $sth = $dbh->prepare ($sql);
  986.     $res = $sth->execute ($objectUID, $serverId);
  987.     return unless $res;
  988.                
  989.     my ($objectId) = $sth->fetchrow_array;
  990.     $sth->finish;
  991.     return unless (defined $objectId);
  992.  
  993.     my $file = CACHE_DIR.'objects/'.$objectUID.'.sqf';
  994.     open  (OUT, ">$file");
  995.     print OUT '["PASS","'.$objectId.'"]';
  996.     close (OUT);
  997. }
  998.  
  999. # 309
  1000. sub h_object_uid_update_inventory {
  1001.     my $p = shift;
  1002.     return unless ($p && ref($p) eq 'ARRAY');
  1003.     my ($cmd, $objectUID, $inventory) = @$p;
  1004.     unless ($objectUID && $inventory) {
  1005.         print STDERR "Error h_object_uid_update_inventory(): objectUID or inventory undefined!\n";
  1006.         return;
  1007.     }
  1008.     $objectUID =~ s/"//g;
  1009.    
  1010.     unless ( parse_json ($inventory) ) {
  1011.         print STDERR "Error h_object_uid_update_inventory($objectUID): inventory invalid json!\n";
  1012.         return;
  1013.     }
  1014.    
  1015.     my $sql = 'UPDATE Object_DATA SET Inventory=? WHERE ObjectUID=? AND Instance=?';
  1016.     my $sth = $dbh->prepare ($sql);
  1017.     my $res = $sth->execute ($inventory, $objectUID, INSTANCE);
  1018.     return $res;
  1019. }
  1020.  
  1021. # 310
  1022. sub h_object_uid_delete {
  1023.     my $p = shift;
  1024.     return unless ($p && ref($p) eq 'ARRAY');
  1025.     my ($cmd, $objectUID) = @$p;
  1026.     unless ($objectUID) {
  1027.         print STDERR "Error h_object_uid_delete(): objectUID undefined!\n";
  1028.         return;
  1029.     }
  1030.     $objectUID =~ s/"//g;
  1031.    
  1032.     my $sql = 'DELETE FROM Object_DATA WHERE ObjectUID=? AND Instance=?';
  1033.     my $sth = $dbh->prepare ($sql);
  1034.     my $res = $sth->execute ($objectUID, INSTANCE);
  1035.    
  1036.     if ($res) {
  1037.         $sql = 'DELETE FROM Object_init_DATA WHERE ObjectUID=? AND Instance=?';
  1038.         $sth = $dbh->prepare ($sql);
  1039.         $res = $sth->execute ($objectUID, INSTANCE);
  1040.     }
  1041.     return $res;
  1042. }
  1043.  
  1044. # 388 - loadObjectID
  1045. sub h_load_objects_id {
  1046.     my $sql = 'SELECT ObjectID, ObjectUID FROM Object_DATA WHERE Instance=? ORDER BY ObjectUID';
  1047.     my $sth = $dbh->prepare ($sql);
  1048.     my $res = $sth->execute (INSTANCE);
  1049.     #return unless $res;
  1050.    
  1051.     while (my ($objectId, $objectUID) = $sth->fetchrow_array) {
  1052.         next unless (defined $objectId);
  1053.        
  1054.         my $file = CACHE_DIR.'objects/'.$objectUID.'.sqf';
  1055.         open  (OUT, ">$file");
  1056.         print OUT '["PASS","'.$objectId.'"]';
  1057.         close (OUT);
  1058.     }
  1059.     $sth->finish;
  1060. }
  1061.  
  1062. ### jahan start
  1063. # 396
  1064. sub h_object_reset_damage {
  1065.     my $p = shift;
  1066.     return unless ($p && ref($p) eq 'ARRAY');
  1067.     my ($cmd, $oid) = @$p;
  1068.     unless ($oid) {
  1069.         print STDERR "Error h_object_reset_damage(): objectId undefined!\n";
  1070.         return;
  1071.     }
  1072.     $oid =~ s/"//g;
  1073.  
  1074.     my $sth = $dbh->prepare ('UPDATE Object_DATA SET Damage=0.00000 WHERE ObjectID=? AND Instance=?');
  1075.     my $res = $sth->execute ($oid, INSTANCE);
  1076.     return $res;
  1077. }
  1078.  
  1079. # 397
  1080. sub h_object_uid_reset_damage {
  1081.     my $p = shift;
  1082.     return unless ($p && ref($p) eq 'ARRAY');
  1083.     my ($cmd, $uid) = @$p;
  1084.     unless ($uid) {
  1085.         print STDERR "Error h_object_uid_reset_damage(): objectUID undefined!\n";
  1086.         return;
  1087.     }
  1088.     $uid =~ s/"//g;
  1089.  
  1090.     my $sth = $dbh->prepare ('UPDATE Object_DATA SET Damage=0.00000 WHERE ObjectUID=? AND Instance=?');
  1091.     my $res = $sth->execute ($uid, INSTANCE);
  1092.     return $res;
  1093. }
  1094. ### jahan end
  1095.  
  1096. # 398 - tradeObject
  1097. sub h_trade_object {
  1098.     my $p = shift;
  1099.     return unless ($p && ref($p) eq 'ARRAY');
  1100.     my ($cmd, $traderObjectId, $action) = @$p;
  1101.     return unless ($traderObjectId && defined $action);
  1102.    
  1103.     my $sql;
  1104.     if ($action == 0) {
  1105.         $sql = 'UPDATE Traders_DATA SET qty = qty - 1 WHERE id=? AND qty > 0';
  1106.     } else {
  1107.         $sql = 'UPDATE Traders_DATA SET qty = qty + 1 WHERE id=?';
  1108.     }
  1109.     my $sth = $dbh->prepare ($sql);
  1110.     my $res = $sth->execute ($traderObjectId);    
  1111.     return $res;
  1112. }
  1113.  
  1114. # 399 - loadTraderDetails
  1115. sub h_load_trader_details {
  1116.     my $sql = 'SELECT id, item, qty, buy, sell, `order`, tid, afile FROM Traders_DATA';
  1117.     my $sth = $dbh->prepare ($sql);
  1118.     my $res = $sth->execute ();
  1119.     return unless $res;
  1120.    
  1121.     my %tids = ();
  1122.     my $charecterId = 0;
  1123.     while (my ($id, $item, $qty, $buy, $sell, $order, $tid, $afile) = $sth->fetchrow_array) {
  1124.         next unless $tid;
  1125.         $tids{$tid} = [] unless $tids{$tid};
  1126.        
  1127.         push @{$tids{$tid}}, '['.$id.','.$item.','.$qty.','.$buy.','.$sell.','.$order.','.$tid.',"'.$afile.'"]';
  1128.     }    
  1129.     $sth->finish;
  1130.    
  1131.     return unless %tids;
  1132.    
  1133.     while (my ($tid, $v) = each %tids) {
  1134.         next unless ($v && @$v);
  1135.         my $str = join (',', @$v);
  1136.    
  1137.         my $file = CACHE_DIR.'traders/'.$tid.'.sqf';
  1138.         open  (OUT, ">$file");
  1139.         print OUT '['.$str.']';
  1140.         close (OUT);
  1141.     }
  1142.    
  1143.     undef %tids;
  1144. }
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!