hlstatsx/scripts/HLstats_Player.pm

1124 lines
26 KiB
Perl

package HLstats_Player;
# HLstatsX Community Edition - Real-time player and clan rankings and statistics
# Copyleft (L) 2008-20XX Nicholas Hastings (nshastings@gmail.com)
# http://www.hlxcommunity.com
#
# HLstatsX Community Edition is a continuation of
# ELstatsNEO - Real-time player and clan rankings and statistics
# Copyleft (L) 2008-20XX Malte Bayer (steam@neo-soft.org)
# http://ovrsized.neo-soft.org/
#
# ELstatsNEO is an very improved & enhanced - so called Ultra-Humongus Edition of HLstatsX
# HLstatsX - Real-time player and clan rankings and statistics for Half-Life 2
# http://www.hlstatsx.com/
# Copyright (C) 2005-2007 Tobias Oetzel (Tobi@hlstatsx.com)
#
# HLstatsX is an enhanced version of HLstats made by Simon Garner
# HLstats - Real-time player and clan rankings and statistics for Half-Life
# http://sourceforge.net/projects/hlstats/
# Copyright (C) 2001 Simon Garner
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#
# For support and installation notes visit http://www.hlxcommunity.com
#
# Constructor
#
use Encode;
do "$::opt_libdir/HLstats_GameConstants.plib";
sub new
{
my $class_name = shift;
my %params = @_;
my $self = {};
bless($self, $class_name);
# Initialise Properties
$self->{userid} = 0;
$self->{server} = "";
$self->{server_id} = 1;
$self->{name} = "";
$self->{uniqueid} = "";
$self->{plain_uniqueid} = "";
$self->{address} = "";
$self->{cli_port} = "";
$self->{ping} = 0;
$self->{connect_time} = time();
$self->{last_update} = 0;
$self->{last_update_skill} = 0;
$self->{day_skill_change} = 0;
$self->{city} = "";
$self->{state} = "";
$self->{country} = "";
$self->{flag} = "";
$self->{lat} = undef;
$self->{lng} = undef;
$self->{playerid} = 0;
$self->{clan} = 0;
$self->{kills} = 0;
$self->{total_kills} = 0;
$self->{deaths} = 0;
$self->{suicides} = 0;
$self->{skill} = 1000;
$self->{game} = "";
$self->{team} = "";
$self->{role} = "";
$self->{timestamp} = 0;
$self->{headshots} = 0;
$self->{shots} = 0;
$self->{hits} = 0;
$self->{teamkills} = 0;
$self->{kill_streak} = 0;
$self->{death_streak} = 0;
$self->{auto_command} = "";
$self->{auto_type} = "";
$self->{auto_time} = 0;
$self->{auto_time_count} = 0;
$self->{session_skill} = 0;
$self->{session_kills} = 0;
$self->{session_deaths} = 0;
$self->{session_suicides} = 0;
$self->{session_headshots} = 0;
$self->{session_shots} = 0;
$self->{session_hits} = 0;
$self->{session_start_pos} = -1;
$self->{map_kills} = 0;
$self->{map_deaths} = 0;
$self->{map_suicides} = 0;
$self->{map_headshots} = 0;
$self->{map_shots} = 0;
$self->{map_hits} = 0;
$self->{is_dead} = 0;
$self->{has_bomb} = 0;
$self->{is_banned} = 0;
$self->{is_bot} = 0;
$self->{display_events} = 1;
$self->{display_chat} = 1;
$self->{kills_per_life} = 0;
$self->{last_history_day} = "";
$self->{last_death_weapon} = 0;
$self->{last_sg_build} = 0;
$self->{last_disp_build} = 0;
$self->{last_entrance_build} = 0;
$self->{last_exit_build} = 0;
$self->{last_team_change} = "";
$self->{deaths_in_a_row} = 0;
$self->{trackable} = 0;
$self->{needsupdate} = 0;
# Set Property Values
die("HLstats_Player->new(): must specify player's uniqueid\n")
unless (defined($params{uniqueid}));
while (my($key, $value) = each(%params))
{
if ($key ne "name" && $key ne "uniqueid")
{
$self->set($key, $value);
}
}
$self->updateTrackable();
$self->{plain_uniqueid} = $params{plain_uniqueid};
$self->setUniqueId($params{uniqueid});
if ($::g_stdin == 0 && $self->{userid} > 0) {
$self->insertPlayerLivestats();
}
$self->setName($params{name});
$self->getAddress();
$self->flushDB();
&::printNotice("Created new player object " . $self->getInfoString());
return $self;
}
sub playerCleanup
{
my ($self) = @_;
$self->flushDB();
$self->deleteLivestats();
}
#
# Set property 'key' to 'value'
#
sub set
{
my ($self, $key, $value, $no_updatetime) = @_;
if (defined($self->{$key}))
{
if ($no_updatetime == 0) {
$self->{timestamp} = $::ev_daemontime;
}
if ($self->{$key} eq $value)
{
if ($::g_debug > 2)
{
&::printNotice("Hlstats_Player->set ignored: Value of \"$key\" is already \"$value\"");
}
return 0;
}
if ($key eq "uniqueid")
{
return $self->setUniqueId($value);
}
elsif ($key eq "name")
{
return $self->setName($value);
}
elsif ($key eq "skill" && $self->{userid} < 1)
{
return $self->{skill};
}
else
{
$self->{$key} = $value;
return 1;
}
}
else
{
warn("HLstats_Player->set: \"$key\" is not a valid property name\n");
return 0;
}
}
#
# Increment (or decrement) the value of 'key' by 'amount' (or 1 by default)
#
sub increment
{
my ($self, $key, $amount, $no_updatetime) = @_;
if ($key eq "skill" && $self->{userid} < 1) {
return $self->{skill};
}
$amount = 1 if (!defined($amount));
if ($amount != 0) {
my $value = $self->{$key};
$self->set($key, $value + $amount, $no_updatetime);
}
}
sub check_history
{
my ($self) = @_;
#my ($sec,$min,$hour,$mday,$mon,$year) = localtime(time());
my ($sec,$min,$hour,$mday,$mon,$year) = localtime($::ev_unixtime);
my $date = sprintf("%04d-%02d-%02d", $year+1900, $mon+1, $mday, $hour, $min, $sec);
my $srv_addr = $self->{server};
my $is_bot = 0;
my $playerId = $self->{playerid};
if ($self->{is_bot} || $self->{userid} < 0) {
$is_bot = 1;
}
if (($playerId > 0) && ($::g_stdin == 0 || $::g_timestamp > 0))
{
if (($is_bot == 0) || (($is_bot == 1) && ($::g_servers{$srv_addr}->{ignore_bots} == 0))) {
$self->{last_history_day} = sprintf("%02d", $mday);
my $query = "
SELECT
skill_change
FROM
hlstats_Players_History
WHERE
playerId=" . $playerId . "
AND eventTime='".$date."'
AND game='".&::quoteSQL($::g_servers{$srv_addr}->{game})."'
";
my $result = &::doQuery($query);
if ($result->rows < 1)
{
my $query = "
INSERT INTO
hlstats_Players_History
(
playerId,
eventTime,
game
)
VALUES
(
$playerId,
'$date',
'" . &::quoteSQL($::g_servers{$srv_addr}->{game}) . "'
)
";
&::execNonQuery($query);
$self->{day_skill_change} = 0;
} else {
($self->{day_skill_change}) = $result->fetchrow_array;
}
$result->finish;
}
}
}
#
# Set player's uniqueid
#
sub setUniqueId
{
my ($self, $uniqueid) = @_;
my $tempPlayerId = &::getPlayerId($uniqueid);
if ($tempPlayerId > 0)
{
$self->{playerid} = $tempPlayerId;
# An existing player. Get their skill rating.
my $query = "
SELECT
skill, kills, displayEvents, flag
FROM
hlstats_Players
WHERE
playerId=$tempPlayerId
";
my $result = &::doQuery($query);
if ($result->rows > 0) {
($self->{skill}, $self->{total_kills}, $self->{display_events},$self->{flag}) = $result->fetchrow_array;
} else {
# Have record in hlstats_PlayerUniqueIds but not in hlstats_Players
$self->insertPlayer($tempPlayerId);
}
$self->{session_start_pos} = $self->getRank();
$result->finish;
}
else
{
# This is a new player. Create a new record for them in the Players
# table.
$self->insertPlayer();
$query = "
INSERT INTO
hlstats_PlayerUniqueIds
(
playerId,
uniqueId,
game
)
VALUES
(
".$self->{playerid}.",
'" . &::quoteSQL($uniqueid) . "',
'" . &::quoteSQL($::g_servers{$self->{server}}->{game}) . "'
)
";
&::execNonQuery($query);
}
$self->{uniqueid} = $uniqueid;
$self->check_history();
return 1;
}
#
# Inserts new player
#
sub insertPlayer
{
my ($self, $playerid) = @_;
my $hideval = 0;
my $playeridins = "";
my $playeridval = "";
my $srv_addr = $self->{server};
if ($::g_servers{$srv_addr}->{play_game} == L4D() && $self->{userid} < 0) {
$hideval = 1;
}
if ($playerid) {
my $query = "
INSERT INTO
hlstats_Players
(
lastName,
clan,
game,
displayEvents,
createdate,
hideranking,
playerId
)
VALUES
(
?,
?,
?,
?,
UNIX_TIMESTAMP(),
?,
?
)
";
my @vals = ($self->{name}, $self->{clan}, $::g_servers{$srv_addr}->{game}, $self->{display_events}, $hideval, $playerid);
&::execCached("player_insert_playerid", $query, @vals);
return $playerid;
}
my $query = "
INSERT INTO
hlstats_Players
(
lastName,
clan,
game,
displayEvents,
createdate,
hideranking
)
VALUES
(
?,
?,
?,
?,
UNIX_TIMESTAMP(),
?
)
";
my @vals = ($self->{name}, $self->{clan}, $::g_servers{$srv_addr}->{game}, $self->{display_events}, $hideval);
&::execCached("player_insert", $query, @vals);
$self->{playerid} = $::db_conn->{'mysql_insertid'};
}
#
# Insert initial live stats
#
sub insertPlayerLivestats
{
my ($self) = @_;
my $query = "
REPLACE INTO
hlstats_Livestats
(
player_id,
server_id,
cli_address,
steam_id,
name,
team,
ping,
connected,
skill,
cli_flag
)
VALUES
(
?,?,?,?,?,?,?,?,?,?
)
";
my @vals = ($self->{playerid}, $self->{server_id}, $self->{address}, $self->{plain_uniqueid},
$self->{name}, $self->{team}, $self->{ping}, $self->{connect_time}, $self->{skill}, $self->{flag});
&::execCached("player_livestats_insert", $query, @vals);
}
#
# Set player's name
#
sub setName
{
my ($self, $name) = @_;
my $oldname = $self->{name};
if ($oldname eq $name)
{
return 2;
}
if ($oldname)
{
$self->updateDB();
}
$self->{name} = $name;
my $is_bot = $self->{is_bot};
my $server_address = $self->{server};
if (($is_bot == 1) && ($::g_servers{$server_address}->{ignore_bots} == 1)) {
$self->{clan} = "";
} else {
$self->{clan} = &::getClanId($name);
}
my $playerid = $self->{playerid};
if ($playerid)
{
my $query = "
SELECT
playerId
FROM
hlstats_PlayerNames
WHERE
playerId = $playerid
AND name ='" . &::quoteSQL($self->{name}) . "'
";
my $result = &::doQuery($query);
if ($result->rows < 1)
{
my $query = "
REPLACE INTO
hlstats_PlayerNames
(
playerId,
name,
lastuse,
numuses
)
VALUES
(
$playerid,
'" . &::quoteSQL($self->{name}) . "',
FROM_UNIXTIME(" . $::ev_unixtime . "),
1
)
";
&::execNonQuery($query);
}
else
{
my $query = "
UPDATE
hlstats_PlayerNames
SET
lastuse=FROM_UNIXTIME(" . $::ev_unixtime . "),
numuses=numuses+1
WHERE
playerId = $playerid
AND name='" . &::quoteSQL($self->{name}) . "'
";
&::execNonQuery($query);
}
$result->finish;
}
else
{
&::error("HLstats_Player->setName(): No playerid");
}
}
#
# Update player information in database
#
sub flushDB
{
my ($self, $leaveLastUse, $callref) = @_;
my $playerid = $self->{playerid};
my $srv_addr = $self->{server};
my $serverid = $self->{server_id};
my $name = $self->{name};
my $clan = $self->{clan};
my $kills = $self->{kills};
my $deaths = $self->{deaths};
my $suicides = $self->{suicides};
my $skill = $self->{skill};
if ($skill < 0) {$skill = 0;}
my $headshots = $self->{headshots};
my $shots = $self->{shots};
my $hits = $self->{hits};
my $teamkills = $self->{teamkills};
my $team = $self->{team};
my $map_kills = $self->{map_kills};
my $map_deaths = $self->{map_deaths};
my $map_suicides = $self->{map_suicides};
my $map_headshots = $self->{map_headshots};
my $map_shots = $self->{map_shots};
my $map_hits = $self->{map_hits};
my $steamid = $self->{plain_uniqueid};
my $is_dead = $self->{is_dead};
my $has_bomb = $self->{has_bomb};
my $ping = $self->{ping};
my $connected = $self->{connect_time};
my $skill_change = $self->{session_skill};
my $death_streak = $self->{death_streak};
my $kill_streak = $self->{kill_streak};
my $add_connect_time = 0;
if (($::g_stdin == 0) && ($self->{last_update} > 0)) {
$add_connect_time = time() - $self->{last_update};
} elsif (($::g_stdin == 1) && ($self->{last_update} > 0)) {
$add_connect_time = $::ev_unixtime - $self->{last_update};
}
if (($::g_stdin == 1) && ($add_connect_time > 600)) {
$self->{last_update} = $::ev_unixtime;
$add_connect_time = 0;
}
my $address = $self->{address};
unless ($playerid)
{
warn ("Player->Update() with no playerid set!\n");
return 0;
}
if (($::g_stdin == 0) && ($self->{session_start_pos} == 0)) {
$self->{session_start_pos} = $self->getRank();
}
# TAG - review this, should probably be localtime($ev_unixtime);
# and why no Players_History if stdin?
#my ($sec,$min,$hour,$mday,$mon,$year) = localtime(time());
my ($sec,$min,$hour,$mday,$mon,$year) = localtime($::ev_unixtime);
my $date = sprintf("%04d-%02d-%02d", $year+1900, $mon+1, $mday, $hour, $min, $sec);
if ($::g_stdin == 0 || $::g_timestamp > 0) {
my $last_history_day = $self->{last_history_day};
if ($last_history_day ne sprintf("%02d", $mday)) {
my $query = "
INSERT IGNORE INTO
hlstats_Players_History
(
playerId,
eventTime,
game
) VALUES (
?,
?,
?
)
";
my @vals = ($playerid, $date, $::g_servers{$srv_addr}->{game});
&::execCached("player_flushdb_history_1", $query, @vals);
$self->{day_skill_change} = 0;
$self->{last_history_day} = sprintf("%02d", $mday);
}
}
my $add_history_skill = 0;
if ($self->{last_update_skill} > 0) {
$add_history_skill = $skill - $self->{last_update_skill};
}
$self->{day_skill_change} += $add_history_skill;
my $last_skill_change = $self->{day_skill_change};
my $is_bot = $self->{is_bot};
my $server_address = $self->{server};
if (($is_bot == 1) && ($::g_servers{$server_address}->{ignore_bots} == 1)) {
# Update player details
my $query = "
UPDATE
hlstats_Players
SET
connection_time = connection_time + ?,
lastName=?,
clan=0,
kills=kills + ?,
deaths=deaths + ?,
suicides=suicides + ?,
skill=0,
headshots=headshots + ?,
shots=shots + ?,
hits=hits + ?,
teamkills=teamkills + ?,
last_event=?,
hideranking=1
WHERE
playerId=?
";
my @vals = ($add_connect_time, $name, $kills, $deaths, $suicides, $headshots,
$shots, $hits, $teamkills, $::ev_unixtime, $playerid);
&::execCached("player_flushdb_player_1", $query, @vals);
} else {
# Update player details
my $query = "
UPDATE
hlstats_Players
SET
connection_time = connection_time + ?,
lastName=?,
clan=?,
kills=kills + ?,
deaths=deaths + ?,
suicides=suicides + ?,
skill=?,
headshots=headshots + ?,
shots=shots + ?,
hits=hits + ?,
teamkills=teamkills + ?,
last_event=?,
last_skill_change=?,
death_streak=IF(?>death_streak,?,death_streak),
kill_streak=IF(?>kill_streak,?,kill_streak),
hideranking=IF(hideranking=3,0,hideranking),
activity = 100
WHERE
playerId=?
";
my @vals = ($add_connect_time, $name, $clan, $kills, $deaths, $suicides, $skill,
$headshots, $shots, $hits, $teamkills, $::ev_unixtime, $last_skill_change, $death_streak,
$death_streak, $kill_streak, $kill_streak, $playerid);
&::execCached("player_flushdb_player_2", $query, @vals);
if ($::g_stdin == 0 || $::g_timestamp > 0) {
# Update player details
my $query = "
UPDATE
hlstats_Players_History
SET
connection_time = connection_time + ?,
kills=kills + ?,
deaths=deaths + ?,
suicides=suicides + ?,
skill=?,
headshots=headshots + ?,
shots=shots + ?,
hits=hits + ?,
teamkills=teamkills + ?,
death_streak=IF(?>death_streak,?,death_streak),
kill_streak=IF(?>kill_streak,?,kill_streak),
skill_change=skill_change + ?
WHERE
playerId=?
AND eventTime=?
AND game=?
";
my @vals = ($add_connect_time, $kills, $deaths, $suicides, $skill, $headshots,
$shots, $hits, $teamkills, $death_streak, $death_streak, $kill_streak,
$kill_streak, $add_history_skill, $playerid, $date, $::g_servers{$srv_addr}->{game});
&::execCached("player_flushdb_history_2", $query, @vals);
}
}
if ($name)
{
# Update alias details
$query = "
UPDATE
hlstats_PlayerNames
SET
connection_time = connection_time + ?,
kills=kills + ?,
deaths=deaths + ?,
suicides=suicides + ?,
headshots=headshots + ?,
shots=shots + ?,
hits=hits + ?"
;
my @vals = ($add_connect_time, $kills, $deaths, $suicides, $headshots, $shots, $hits);
unless ($leaveLastUse)
{
# except on ChangeName we update the last use on a player's old name
$query .= ",
lastuse=FROM_UNIXTIME(?)"
;
push(@vals, $::ev_unixtime);
}
$query .= "
WHERE
playerId=?
AND name=?
";
push(@vals, $playerid);
push(@vals, $self->{name});
&::execCached("player_flushdb_playernames", $query, @vals);
}
# reset player stat properties
$self->set("kills", 0, 1);
$self->set("deaths", 0, 1);
$self->set("suicides", 0, 1);
$self->set("headshots", 0, 1);
$self->set("shots", 0, 1);
$self->set("hits", 0, 1);
$self->set("teamkills", 0, 1);
if (($is_bot == 1) && ($::g_servers{$server_address}->{ignore_bots} == 1)) {
$skill = 0;
$skill_change = 0;
}
if ($::g_stdin == 0 && $self->{userid} > 0) {
# Update live stats
my $query = "
UPDATE
hlstats_Livestats
SET
cli_address=?,
steam_id=?,
name=?,
team=?,
kills=?,
deaths=?,
suicides=?,
headshots=?,
shots=?,
hits=?,
is_dead=?,
has_bomb=?,
ping=?,
connected=?,
skill_change=?,
skill=?
WHERE
player_id=?
";
my @vals = ($address, $steamid, $name,
$team, $map_kills, $map_deaths, $map_suicides, $map_headshots, $map_shots,
$map_hits, $is_dead, $has_bomb, $ping, $connected, $skill_change, $skill, $playerid);
&::execCached("player_flushdb_livestats", $query, @vals);
}
if ($::g_stdin == 0) {
$self->{last_update} = time();
} elsif ($::g_stdin == 1) {
$self->{last_update} = $::ev_unixtime;
}
$self->{last_update_skill} = $skill;
$self->{needsupdate} = 0;
&::printNotice("Updated player object " . $self->getInfoString());
return 1;
}
#
# Update player timestamp (time of last event for player - used to detect idle
# players)
#
sub updateTimestamp
{
my ($self, $timestamp) = @_;
$timestamp = $::ev_unixtime
unless ($timestamp);
$self->{timestamp} = $::ev_daemontime;
return $timestamp;
}
sub updateDB
{
my ($self) = @_;
$self->{needsupdate} = 1;
}
sub deleteLivestats
{
my ($self) = @_;
# delete live stats
my $query = "DELETE FROM hlstats_Livestats WHERE player_id=".$self->{playerid};
&::execNonQuery($query);
}
#
# Returns a string of information about the player.
#
sub getInfoString
{
my ($self) = @_;
return sprintf("\"%s\" \<P:%d,U:%d,W:%s,T:%s\>", $self->{name}, $self->{playerid}, $self->{userid}, $self->{uniqueid}, $self->{team});
}
sub getAddress
{
my ($self) = @_;
my $haveAddress = 0;
if ($self->{address} ne "")
{
$haveAddress = 1;
}
elsif ($::g_stdin == 0 && $self->{is_bot} == 0 && $self->{userid} > 0)
{
$s_addr = $self->{server};
&::printNotice("rcon_getaddress");
my $result = $::g_servers{$s_addr}->rcon_getaddress($self->{uniqueid});
if ($result->{Address} ne "") {
$haveAddress = 1;
$self->{address} = $result->{Address};
$self->{cli_port} = $result->{ClientPort};
$self->{ping} = $result->{Ping};
&::printEvent("RCON", "Got Address $self->{address} for Player $self->{name}", 1);
&::printNotice("rcon_getaddress successfully");
}
}
if ($haveAddress > 0)
{
# Update player IP address in database
my $query = "
UPDATE
hlstats_Players
SET
lastAddress=?
WHERE
playerId=?
";
my @vals = ($self->{address}, $self->{playerid});
&::execCached("player_update_lastaddress", $query, @vals);
&::printEvent("DEBUG", "Updated IP for ".$self->{playerid}." to ".$self->{address});
$self->geoLookup();
}
return 1;
}
sub geoLookup
{
my ($self) = @_;
my $ip_address = $self->{address};
my $found = 0;
if ($ip_address ne "")
{
my $country_code = undef;
my $country_code3 = undef;
my $country_name = undef;
my $region = undef;
my $city = undef;
my $postal_code = undef;
my $lat = undef;
my $lng = undef;
my $metro_code = undef;
my $area_code = undef;
if ($::g_geoip_binary > 0) {
if(!defined($::g_gi)) {
return;
}
($country_code, $country_code3, $country_name, $region, $city, $postal_code, $lat, $lng, $metro_code, $area_code) = $::g_gi->get_city_record($ip_address);
if ($lng) {
$found++;
$self->{city} = ((defined($city))?encode("utf8",$city):"");
$self->{state} = ((defined($region))?encode("utf8",$region):"");
$self->{country} = ((defined($country_name))?encode("utf8",$country_name):"");
$self->{flag} = ((defined($country_code))?encode("utf8",$country_code):"");
$self->{lat} = (($lat eq "")?undef:$lat);
$self->{lng} = (($lng eq "")?undef:$lng);
}
} else {
my @ipp = split (/\./,$ip_address);
my $ip_number = $ipp[0]*16777216+$ipp[1]*65536+$ipp[2]*256+$ipp[3];
my $query = "
SELECT locId FROM geoLiteCity_Blocks WHERE startIpNum<=".$ip_number." AND endIpNum>=".$ip_number." LIMIT 1;";
my $result = &::doQuery($query);
if ($result->rows > 0) {
my $locid = $result->fetchrow_array;
$result->finish;
my $query = "SELECT city, region AS state, name AS country, country AS flag, latitude AS lat, longitude AS lng FROM geoLiteCity_Location a inner join hlstats_Countries b ON a.country=b.flag WHERE locId=".$locid." LIMIT 1;";
my $result = &::doQuery($query);
if ($result->rows > 0) {
$found++;
($city, $state, $country, $flag, $lat, $lng) = $result->fetchrow_array;
$self->{city} = ((defined($city))?$city:"");
$self->{state} = ((defined($state))?$state:"");
$self->{country} = ((defined($country))?$country:"");
$self->{flag} = ((defined($flag))?$flag:"");
$self->{lat} = (($lat eq "")?undef:$lat);
$self->{lng} = (($lng eq "")?undef:$lng);
}
$result->finish;
}
}
if ($found > 0) {
&::execNonQuery("
UPDATE
hlstats_Players
SET
city='".&::quoteSQL($self->{city})."',
`state`='".&::quoteSQL($self->{state})."',
country='".&::quoteSQL($self->{country})."',
flag='".&::quoteSQL($self->{flag})."',
lat=".((defined($self->{lat}))?$self->{lat}:"NULL").",
lng=".((defined($self->{lng}))?$self->{lng}:"NULL")."
WHERE
playerId = ".$self->{playerid}
);
&::execNonQuery("
UPDATE
hlstats_Livestats
SET
cli_city='".&::quoteSQL($self->{city})."',
cli_country='".&::quoteSQL($self->{country})."',
cli_flag='".&::quoteSQL($self->{flag})."',
cli_state='".&::quoteSQL($self->{state})."',
cli_lat=".((defined($self->{lat}))?$self->{lat}:"NULL").",
cli_lng=".((defined($self->{lng}))?$self->{lng}:"NULL")."
WHERE
player_id =".$self->{playerid}
);
}
}
}
sub getRank
{
my ($self) = @_;
my $srv_addr = $self->{server};
$query = "
SELECT
kills,
deaths,
hideranking
FROM
hlstats_Players
WHERE
playerId=?
";
my $result = &::execCached("get_player_rank_stats", $query, $self->{playerid});
my ($kills, $deaths, $hideranking) = $result->fetchrow_array;
$result->finish;
return 0 if ($hideranking > 0);
$deaths = 1 if ($deaths == 0);
my $kpd = $kills/$deaths;
my $rank = 0;
if ($::g_ranktype ne "kills")
{
if (!defined($self->{skill}))
{
&::printEvent("ERROR","Attempted to get rank for uninitialized player \"".$self->{name}."\"");
return 0;
}
my $query = "
SELECT
COUNT(*)
FROM
hlstats_Players
WHERE
game=?
AND hideranking = 0
AND (
(skill > ?) OR (
(skill = ?) AND ((kills/IF(deaths=0,1,deaths)) > ?)
)
)
";
my @vals = (
&::quoteSQL($self->{game}),
$self->{skill},
$self->{skill},
$kpd
);
my $rankresult = &::execCached("get_player_skill_value", $query, @vals);
($rank) = $rankresult->fetchrow_array;
$rankresult->finish;
$rank++;
}
else
{
my $query ="
SELECT
COUNT(*)
FROM
hlstats_Players
WHERE
game=?
AND hideranking = 0
AND (
(kills > ?) OR (
(kills = ?) AND ((kills/IF(deaths=0,1,deaths)) > ?)
)
)
";
my @vals = (
&::quoteSQL($self->{game}),
$kills,
$kills,
$kpd
);
my $rankresult = &::execCached("get_player_rank_value", $query, @vals);
($rank) = $rankresult->fetchrow_array;
$rankresult->finish;
$rank++;
}
return $rank;
}
sub updateTrackable
{
my ($self) = @_;
if ((&::isTrackableTeam($self->{team}) == 0) || (($::g_servers{$self->{server}}->{ignore_bots} == 1) && (($self->{is_bot} == 1) || ($self->{userid} <= 0)))) {
$self->{trackable} = 0;
return;
}
$self->{trackable} = 1;
}
1;